@smithers-orchestrator/engine 0.16.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 William Cory
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@smithers-orchestrator/engine",
+  "version": "0.16.0",
+  "description": "Concrete Smithers workflow execution engine",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    },
+    "./*": {
+      "types": "./src/index.d.ts",
+      "import": "./src/*.js",
+      "default": "./src/*.js"
+    }
+  },
+  "files": [
+    "src/"
+  ],
+  "dependencies": {
+    "@effect/platform-bun": "^0.89.0",
+    "effect": "^3.21.0",
+    "@smithers-orchestrator/agents": "0.16.0",
+    "@smithers-orchestrator/db": "0.16.0",
+    "@smithers-orchestrator/driver": "0.16.0",
+    "@smithers-orchestrator/graph": "0.16.0",
+    "@smithers-orchestrator/memory": "0.16.0",
+    "@smithers-orchestrator/errors": "0.16.0",
+    "@smithers-orchestrator/observability": "0.16.0",
+    "@smithers-orchestrator/react-reconciler": "0.16.0",
+    "@smithers-orchestrator/scheduler": "0.16.0",
+    "@smithers-orchestrator/components": "0.16.0",
+    "@smithers-orchestrator/sandbox": "0.16.0",
+    "@smithers-orchestrator/time-travel": "0.16.0",
+    "@smithers-orchestrator/vcs": "0.16.0",
+    "@smithers-orchestrator/scorers": "0.16.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "react": "^18.3.0 || ^19.0.0",
+    "typescript": "~5.9.3"
+  },
+  "scripts": {
+    "build": "tsup --dts-only",
+    "test": "bun test tests",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}

package/src/AlertHumanRequestOptions.ts

@@ -0,0 +1,8 @@
+export type AlertHumanRequestOptions = {
+	runId: string;
+	nodeId: string;
+	iteration: number;
+	kind: "ask" | "confirm" | "select" | "json";
+	prompt: string;
+	linkedAlertId?: string;
+};

package/src/AlertRuntimeServices.ts

@@ -0,0 +1,10 @@
+import type { AlertHumanRequestOptions } from "./AlertHumanRequestOptions.ts";
+
+export type AlertRuntimeServices = {
+	runId: string;
+	adapter: unknown;
+	eventBus: unknown;
+	requestCancel: () => void;
+	createHumanRequest: (options: AlertHumanRequestOptions) => Promise<void>;
+	pauseScheduler: (reason: string) => void;
+};

package/src/ChildWorkflowDefinition.ts

@@ -0,0 +1,5 @@
+import type { SmithersWorkflow } from "@smithers-orchestrator/components/SmithersWorkflow";
+
+export type ChildWorkflowDefinition =
+	| SmithersWorkflow<unknown>
+	| (() => SmithersWorkflow<unknown> | unknown);

package/src/ChildWorkflowExecuteOptions.ts

@@ -0,0 +1,14 @@
+import type { ChildWorkflowDefinition } from "./ChildWorkflowDefinition.ts";
+
+export type ChildWorkflowExecuteOptions = {
+	workflow: ChildWorkflowDefinition;
+	input?: unknown;
+	runId?: string;
+	parentRunId?: string;
+	rootDir?: string;
+	allowNetwork?: boolean;
+	maxOutputBytes?: number;
+	toolTimeoutMs?: number;
+	workflowPath?: string;
+	signal?: AbortSignal;
+};

package/src/ContinuationRequest.ts

@@ -0,0 +1,3 @@
+export type ContinuationRequest = {
+	stateJson?: string;
+};

package/src/HijackState.ts

@@ -0,0 +1,19 @@
+type HijackCompletion = {
+	requestedAtMs: number;
+	nodeId: string;
+	iteration: number;
+	attempt: number;
+	engine: string;
+	mode: "native-cli" | "conversation";
+	resume?: string;
+	messages?: unknown[];
+	cwd: string;
+};
+
+export type HijackState = {
+	request: {
+		requestedAtMs: number;
+		target?: string | null;
+	} | null;
+	completion: HijackCompletion | null;
+};

package/src/HumanRequestKind.ts

@@ -0,0 +1 @@
+export type HumanRequestKind = "ask" | "confirm" | "select" | "json";

package/src/HumanRequestStatus.ts

@@ -0,0 +1 @@
+export type HumanRequestStatus = "pending" | "answered" | "cancelled" | "expired";

package/src/PlanNode.ts

@@ -0,0 +1,29 @@
+export type PlanNode =
+	| { kind: "task"; nodeId: string }
+	| { kind: "sequence"; children: PlanNode[] }
+	| { kind: "parallel"; children: PlanNode[] }
+	| {
+			kind: "ralph";
+			id: string;
+			children: PlanNode[];
+			until: boolean;
+			maxIterations: number;
+			onMaxReached: "fail" | "return-last";
+			continueAsNewEvery?: number;
+	  }
+	| { kind: "continue-as-new"; stateJson?: string }
+	| { kind: "group"; children: PlanNode[] }
+	| {
+			kind: "saga";
+			id: string;
+			actionChildren: PlanNode[];
+			compensationChildren: PlanNode[];
+			onFailure: "compensate" | "compensate-and-fail" | "fail";
+	  }
+	| {
+			kind: "try-catch-finally";
+			id: string;
+			tryChildren: PlanNode[];
+			catchChildren: PlanNode[];
+			finallyChildren: PlanNode[];
+	  };

package/src/RalphMeta.ts

@@ -0,0 +1,7 @@
+export type RalphMeta = {
+	id: string;
+	until: boolean;
+	maxIterations: number;
+	onMaxReached: "fail" | "return-last";
+	continueAsNewEvery?: number;
+};

package/src/RalphState.ts

@@ -0,0 +1,4 @@
+export type RalphState = {
+	iteration: number;
+	done: boolean;
+};

package/src/RalphStateMap.ts

@@ -0,0 +1,3 @@
+import type { RalphState } from "./RalphState.ts";
+
+export type RalphStateMap = Map<string, RalphState>;

package/src/ScheduleResult.ts

@@ -0,0 +1,15 @@
+import type { TaskDescriptor } from "@smithers-orchestrator/graph/TaskDescriptor";
+import type { RalphMeta } from "./RalphMeta.ts";
+import type { ContinuationRequest } from "./ContinuationRequest.ts";
+
+export type ScheduleResult = {
+	runnable: TaskDescriptor[];
+	pendingExists: boolean;
+	waitingApprovalExists: boolean;
+	waitingEventExists: boolean;
+	waitingTimerExists: boolean;
+	readyRalphs: RalphMeta[];
+	continuation?: ContinuationRequest;
+	nextRetryAtMs?: number;
+	fatalError?: string;
+};

package/src/SignalRunOptions.ts

@@ -0,0 +1,5 @@
+export type SignalRunOptions = {
+	correlationId?: string | null;
+	receivedBy?: string | null;
+	timestampMs?: number;
+};

package/src/alert-runtime.js

@@ -0,0 +1,22 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./AlertHumanRequestOptions.ts").AlertHumanRequestOptions} AlertHumanRequestOptions */
+/** @typedef {import("./AlertRuntimeServices.ts").AlertRuntimeServices} AlertRuntimeServices */
+// @smithers-type-exports-end
+
+/** @typedef {import("@smithers-orchestrator/scheduler/SmithersWorkflowOptions").SmithersAlertPolicy} SmithersAlertPolicy */
+export class AlertRuntime {
+    /** @type {SmithersAlertPolicy} */
+    policy;
+    /** @type {AlertRuntimeServices} */
+    services;
+    /**
+   * @param {SmithersAlertPolicy} policy
+   * @param {AlertRuntimeServices} services
+   */
+    constructor(policy, services) {
+        this.policy = policy;
+        this.services = services;
+    }
+    start() { }
+    stop() { }
+}

package/src/approvals.js

@@ -0,0 +1,220 @@
+import { Effect, Metric } from "effect";
+import { nowMs } from "@smithers-orchestrator/scheduler/nowMs";
+import { SmithersDb } from "@smithers-orchestrator/db/adapter";
+import { approvalWaitDuration, trackEvent, updateAsyncExternalWaitPending, } from "@smithers-orchestrator/observability/metrics";
+import { bridgeApprovalResolve } from "./effect/durable-deferred-bridge.js";
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+/**
+ * @param {string | null | undefined} currentStatus
+ * @param {number} pendingApprovals
+ * @returns {"waiting-approval" | "waiting-event" | null}
+ */
+function nextRunStatusForApproval(currentStatus, pendingApprovals) {
+    if (currentStatus !== "waiting-approval" &&
+        currentStatus !== "waiting-event") {
+        return null;
+    }
+    return pendingApprovals > 0 ? "waiting-approval" : "waiting-event";
+}
+/**
+ * @param {unknown} decision
+ */
+function serializeDecision(decision) {
+    return decision === undefined ? null : JSON.stringify(decision);
+}
+/**
+ * @param {string | null} [requestJson]
+ */
+function isAsyncApprovalRequest(requestJson) {
+    if (!requestJson)
+        return false;
+    try {
+        return JSON.parse(requestJson)?.waitAsync === true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * @param {string} runId
+ * @param {string} nodeId
+ * @param {number} iteration
+ * @param {string | null | undefined} state
+ * @returns {Effect.Effect<void, SmithersError>}
+ */
+function validateNodeWaitingForApproval(runId, nodeId, iteration, state) {
+    if (state === "waiting-approval" || state === "waiting_approval") {
+        return Effect.void;
+    }
+    return Effect.fail(new SmithersError("INVALID_INPUT", `Node ${nodeId} is not waiting for approval.`, { runId, nodeId, iteration, state: state ?? null }));
+}
+/**
+ * @param {SmithersDb} adapter
+ * @param {string} runId
+ * @param {string} nodeId
+ * @param {number} iteration
+ * @param {string} [note]
+ * @param {string} [decidedBy]
+ * @param {unknown} [decision]
+ * @param {boolean} [autoApproved]
+ * @returns {Effect.Effect<void, SmithersError, never>}
+ */
+export function approveNode(adapter, runId, nodeId, iteration, note, decidedBy, decision, autoApproved = false) {
+    const ts = nowMs();
+    const event = {
+        type: autoApproved ? "ApprovalAutoApproved" : "ApprovalGranted",
+        runId,
+        nodeId,
+        iteration,
+        timestampMs: ts,
+    };
+    return Effect.gen(function* () {
+        const existing = yield* adapter.getApproval(runId, nodeId, iteration);
+        const currentNode = yield* adapter.getNode(runId, nodeId, iteration);
+        yield* validateNodeWaitingForApproval(runId, nodeId, iteration, currentNode?.state);
+        yield* adapter.withTransactionEffect("approval", Effect.gen(function* () {
+            yield* adapter.insertOrUpdateApproval({
+                runId,
+                nodeId,
+                iteration,
+                status: "approved",
+                requestedAtMs: null,
+                decidedAtMs: ts,
+                note: note ?? null,
+                decidedBy: decidedBy ?? null,
+                requestJson: existing?.requestJson ?? null,
+                decisionJson: serializeDecision(decision) ?? existing?.decisionJson ?? null,
+                autoApproved,
+            });
+            yield* adapter.insertNode({
+                runId,
+                nodeId,
+                iteration,
+                state: "pending",
+                lastAttempt: currentNode?.lastAttempt ?? null,
+                updatedAtMs: nowMs(),
+                outputTable: currentNode?.outputTable ?? "",
+                label: currentNode?.label ?? null,
+            });
+            const run = yield* adapter.getRun(runId);
+            if (run) {
+                const pending = yield* adapter.listPendingApprovals(runId);
+                const nextStatus = nextRunStatusForApproval(run.status, pending.length);
+                if (nextStatus && run.status !== nextStatus) {
+                    yield* adapter.updateRun(runId, { status: nextStatus });
+                }
+            }
+        }));
+        if (existing?.requestedAtMs) {
+            yield* Metric.update(approvalWaitDuration, ts - existing.requestedAtMs);
+        }
+        if (existing?.status === "requested" && isAsyncApprovalRequest(existing.requestJson)) {
+            yield* updateAsyncExternalWaitPending("approval", -1);
+        }
+        yield* adapter.insertEventWithNextSeq({
+            runId,
+            timestampMs: ts,
+            type: event.type,
+            payloadJson: JSON.stringify(event),
+        });
+        yield* trackEvent(event);
+        yield* Effect.logInfo(autoApproved ? "approval auto-approved" : "approval granted");
+        yield* Effect.promise(() => bridgeApprovalResolve(adapter, runId, nodeId, iteration, {
+            approved: true,
+            note: note ?? null,
+            decidedBy: decidedBy ?? null,
+            decisionJson: serializeDecision(decision),
+            autoApproved,
+        }));
+    }).pipe(Effect.annotateLogs({
+        runId,
+        nodeId,
+        iteration,
+        approvalStatus: autoApproved ? "auto-approved" : "approved",
+        approvalDecidedBy: decidedBy ?? null,
+    }), Effect.withLogSpan("approval:grant"));
+}
+/**
+ * @param {SmithersDb} adapter
+ * @param {string} runId
+ * @param {string} nodeId
+ * @param {number} iteration
+ * @param {string} [note]
+ * @param {string} [decidedBy]
+ * @param {unknown} [decision]
+ * @returns {Effect.Effect<void, SmithersError, never>}
+ */
+export function denyNode(adapter, runId, nodeId, iteration, note, decidedBy, decision) {
+    const ts = nowMs();
+    const event = {
+        type: "ApprovalDenied",
+        runId,
+        nodeId,
+        iteration,
+        timestampMs: ts,
+    };
+    return Effect.gen(function* () {
+        const existing = yield* adapter.getApproval(runId, nodeId, iteration);
+        const currentNode = yield* adapter.getNode(runId, nodeId, iteration);
+        yield* validateNodeWaitingForApproval(runId, nodeId, iteration, currentNode?.state);
+        yield* adapter.withTransactionEffect("approval", Effect.gen(function* () {
+            yield* adapter.insertOrUpdateApproval({
+                runId,
+                nodeId,
+                iteration,
+                status: "denied",
+                requestedAtMs: null,
+                decidedAtMs: ts,
+                note: note ?? null,
+                decidedBy: decidedBy ?? null,
+                requestJson: existing?.requestJson ?? null,
+                decisionJson: serializeDecision(decision) ?? existing?.decisionJson ?? null,
+                autoApproved: false,
+            });
+            yield* adapter.insertNode({
+                runId,
+                nodeId,
+                iteration,
+                state: "failed",
+                lastAttempt: currentNode?.lastAttempt ?? null,
+                updatedAtMs: nowMs(),
+                outputTable: currentNode?.outputTable ?? "",
+                label: currentNode?.label ?? null,
+            });
+            const run = yield* adapter.getRun(runId);
+            if (run) {
+                const pending = yield* adapter.listPendingApprovals(runId);
+                const nextStatus = nextRunStatusForApproval(run.status, pending.length);
+                if (nextStatus && run.status !== nextStatus) {
+                    yield* adapter.updateRun(runId, { status: nextStatus });
+                }
+            }
+        }));
+        if (existing?.requestedAtMs) {
+            yield* Metric.update(approvalWaitDuration, ts - existing.requestedAtMs);
+        }
+        if (existing?.status === "requested" && isAsyncApprovalRequest(existing.requestJson)) {
+            yield* updateAsyncExternalWaitPending("approval", -1);
+        }
+        yield* adapter.insertEventWithNextSeq({
+            runId,
+            timestampMs: ts,
+            type: "ApprovalDenied",
+            payloadJson: JSON.stringify(event),
+        });
+        yield* trackEvent(event);
+        yield* Effect.logInfo("approval denied");
+        yield* Effect.promise(() => bridgeApprovalResolve(adapter, runId, nodeId, iteration, {
+            approved: false,
+            note: note ?? null,
+            decidedBy: decidedBy ?? null,
+            decisionJson: serializeDecision(decision),
+        }));
+    }).pipe(Effect.annotateLogs({
+        runId,
+        nodeId,
+        iteration,
+        approvalStatus: "denied",
+        approvalDecidedBy: decidedBy ?? null,
+    }), Effect.withLogSpan("approval:deny"));
+}

package/src/child-workflow.js

@@ -0,0 +1,163 @@
+import { Effect } from "effect";
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+import { SmithersDb } from "@smithers-orchestrator/db/adapter";
+import { requireTaskRuntime } from "@smithers-orchestrator/driver/task-runtime";
+import { getWorkflowMakeBridgeRuntime } from "./effect/workflow-make-bridge.js";
+/** @typedef {import("./ChildWorkflowDefinition.ts").ChildWorkflowDefinition} ChildWorkflowDefinition */
+/** @typedef {import("./ChildWorkflowExecuteOptions.ts").ChildWorkflowExecuteOptions} ChildWorkflowExecuteOptions */
+/** @typedef {import("@smithers-orchestrator/driver/RunResult").RunResult} RunResult */
+
+/**
+ * @param {unknown} value
+ * @returns {value is import("@smithers-orchestrator/components/SmithersWorkflow").SmithersWorkflow<any>}
+ */
+function isWorkflowLike(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        "build" in value &&
+        typeof value.build === "function");
+}
+/**
+ * @param {unknown} input
+ * @returns {Record<string, unknown>}
+ */
+function normalizeChildInput(input) {
+    if (!input)
+        return {};
+    if (typeof input === "object" && !Array.isArray(input)) {
+        return input;
+    }
+    return { value: input };
+}
+/**
+ * @param {unknown} value
+ * @returns {unknown}
+ */
+function stripSystemColumns(value) {
+    if (!value || typeof value !== "object")
+        return value;
+    if (Array.isArray(value)) {
+        return value.map(stripSystemColumns);
+    }
+    const obj = value;
+    const out = {};
+    for (const [key, val] of Object.entries(obj)) {
+        if (key === "runId" || key === "nodeId" || key === "iteration")
+            continue;
+        out[key] = val;
+    }
+    return out;
+}
+/**
+ * @param {RunResult} runResult
+ * @returns {unknown}
+ */
+function normalizeChildOutput(runResult) {
+    const output = runResult.output;
+    if (!Array.isArray(output))
+        return stripSystemColumns(output);
+    const rows = output.map((row) => stripSystemColumns(row));
+    if (rows.length === 0)
+        return null;
+    if (rows.length === 1)
+        return rows[0];
+    return rows;
+}
+/**
+ * @param {string} parentRunId
+ * @param {string} stepId
+ * @param {number} iteration
+ * @returns {string}
+ */
+function buildChildWorkflowRunId(parentRunId, stepId, iteration) {
+    return [
+        parentRunId,
+        "child",
+        stepId,
+        String(iteration),
+    ].join(":");
+}
+/**
+ * @param {ChildWorkflowDefinition} definition
+ * @param {import("@smithers-orchestrator/components/SmithersWorkflow").SmithersWorkflow<any>} [parentWorkflow]
+ * @returns {import("@smithers-orchestrator/components/SmithersWorkflow").SmithersWorkflow<any>}
+ */
+function resolveChildWorkflow(definition, parentWorkflow) {
+    const resolved = typeof definition === "function" ? definition() : definition;
+    if (isWorkflowLike(resolved)) {
+        return {
+            db: resolved.db ?? parentWorkflow?.db,
+            build: resolved.build,
+            opts: resolved.opts ?? {},
+            schemaRegistry: resolved.schemaRegistry ?? parentWorkflow?.schemaRegistry,
+            zodToKeyName: resolved.zodToKeyName ?? parentWorkflow?.zodToKeyName,
+        };
+    }
+    if (typeof resolved === "function") {
+        if (!parentWorkflow) {
+            throw new SmithersError("INVALID_INPUT", "Child workflow function requires a parent workflow context.");
+        }
+        const render = resolved;
+        return {
+            db: parentWorkflow.db,
+            build: (ctx) => render(ctx),
+            opts: {},
+            schemaRegistry: parentWorkflow.schemaRegistry,
+            zodToKeyName: parentWorkflow.zodToKeyName,
+        };
+    }
+    throw new SmithersError("INVALID_INPUT", "Child workflow must be a Smithers workflow object or function.");
+}
+/**
+ * @param {import("@smithers-orchestrator/components/SmithersWorkflow").SmithersWorkflow<any> | undefined} parentWorkflow
+ * @param {ChildWorkflowExecuteOptions} options
+ * @returns {Promise<{ runId: string; status: RunResult["status"]; output: unknown; }>}
+ */
+export async function executeChildWorkflow(parentWorkflow, options) {
+    const runtime = requireTaskRuntime();
+    const childWorkflow = resolveChildWorkflow(options.workflow, parentWorkflow);
+    const input = normalizeChildInput(options.input);
+    const childRunId = options.runId ??
+        buildChildWorkflowRunId(options.parentRunId ?? runtime.runId, runtime.stepId, runtime.iteration);
+    const adapter = new SmithersDb(childWorkflow.db);
+    const existingChildRun = await adapter.getRun(childRunId);
+    const resume = Boolean(existingChildRun);
+    const bridgeRuntime = getWorkflowMakeBridgeRuntime();
+    if (bridgeRuntime) {
+        const result = await bridgeRuntime.executeChildWorkflow(childWorkflow, {
+            input,
+            runId: childRunId,
+            resume,
+            parentRunId: options.parentRunId ?? runtime.runId,
+            rootDir: options.rootDir,
+            workflowPath: options.workflowPath,
+            allowNetwork: options.allowNetwork,
+            maxOutputBytes: options.maxOutputBytes,
+            toolTimeoutMs: options.toolTimeoutMs,
+            signal: options.signal ?? runtime.signal,
+        });
+        return {
+            runId: result.runId,
+            status: result.status,
+            output: normalizeChildOutput(result),
+        };
+    }
+    const { runWorkflow } = await import("./engine.js");
+    const result = await Effect.runPromise(runWorkflow(childWorkflow, {
+        input,
+        runId: childRunId,
+        resume,
+        parentRunId: options.parentRunId ?? runtime.runId,
+        rootDir: options.rootDir,
+        workflowPath: options.workflowPath,
+        allowNetwork: options.allowNetwork,
+        maxOutputBytes: options.maxOutputBytes,
+        toolTimeoutMs: options.toolTimeoutMs,
+        signal: options.signal ?? runtime.signal,
+    }));
+    return {
+        runId: result.runId,
+        status: result.status,
+        output: normalizeChildOutput(result),
+    };
+}

package/src/effect/ApprovalDeferredResolution.ts

@@ -0,0 +1,13 @@
+import type { Schema } from "effect";
+
+/**
+ * Mirrors the shape of the approvalDeferredSuccessSchema defined in
+ * deferred-bridge.js. Kept in sync with the runtime schema.
+ */
+export type ApprovalDeferredResolution = Schema.Schema.Type<
+	Schema.Struct<{
+		approved: typeof Schema.Boolean;
+		note: Schema.NullOr<typeof Schema.String>;
+		decidedBy: Schema.NullOr<typeof Schema.String>;
+	}>
+>;

package/src/effect/ApprovalDurableDeferredResolution.ts

@@ -0,0 +1,11 @@
+import type { Schema } from "effect";
+
+export type ApprovalDurableDeferredResolution = Schema.Schema.Type<
+	Schema.Struct<{
+		approved: typeof Schema.Boolean;
+		note: Schema.NullOr<typeof Schema.String>;
+		decidedBy: Schema.NullOr<typeof Schema.String>;
+		decisionJson: Schema.NullOr<typeof Schema.String>;
+		autoApproved: typeof Schema.Boolean;
+	}>
+>;

package/src/effect/ApprovalPayload.ts

@@ -0,0 +1,7 @@
+export type ApprovalPayload = {
+	runId: string;
+	nodeId: string;
+	iteration?: number;
+	note?: string;
+	decidedBy?: string;
+};

package/src/effect/ApprovalResult.ts

@@ -0,0 +1,6 @@
+export type ApprovalResult = {
+	runId: string;
+	nodeId: string;
+	iteration: number;
+	approved: boolean;
+};