@smithers-orchestrator/engine 0.17.0 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/engine",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "Concrete Smithers workflow execution engine",
   "type": "module",
   "sideEffects": false,
@@ -33,20 +33,20 @@
     "react": "^19.2.5",
     "react-dom": "^19.2.5",
     "zod": "^4.3.6",
-    "@smithers-orchestrator/agents": "0.17.0",
-    "@smithers-orchestrator/components": "0.17.0",
-    "@smithers-orchestrator/driver": "0.17.0",
-    "@smithers-orchestrator/db": "0.17.0",
-    "@smithers-orchestrator/errors": "0.17.0",
-    "@smithers-orchestrator/graph": "0.17.0",
-    "@smithers-orchestrator/memory": "0.17.0",
-    "@smithers-orchestrator/react-reconciler": "0.17.0",
-    "@smithers-orchestrator/observability": "0.17.0",
-    "@smithers-orchestrator/sandbox": "0.17.0",
-    "@smithers-orchestrator/scheduler": "0.17.0",
-    "@smithers-orchestrator/scorers": "0.17.0",
-    "@smithers-orchestrator/time-travel": "0.17.0",
-    "@smithers-orchestrator/vcs": "0.17.0"
+    "@smithers-orchestrator/components": "0.19.0",
+    "@smithers-orchestrator/agents": "0.19.0",
+    "@smithers-orchestrator/db": "0.19.0",
+    "@smithers-orchestrator/errors": "0.19.0",
+    "@smithers-orchestrator/driver": "0.19.0",
+    "@smithers-orchestrator/graph": "0.19.0",
+    "@smithers-orchestrator/memory": "0.19.0",
+    "@smithers-orchestrator/observability": "0.19.0",
+    "@smithers-orchestrator/react-reconciler": "0.19.0",
+    "@smithers-orchestrator/sandbox": "0.19.0",
+    "@smithers-orchestrator/scheduler": "0.19.0",
+    "@smithers-orchestrator/scorers": "0.19.0",
+    "@smithers-orchestrator/time-travel": "0.19.0",
+    "@smithers-orchestrator/vcs": "0.19.0"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/effect/builder.js

@@ -14,6 +14,9 @@ import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
 /**
  * @typedef {import("effect").Schema.Schema<unknown, unknown, never>} AnySchema
  */
+/**
+ * @typedef {unknown | Promise<unknown> | import("effect").Effect.Effect<unknown, unknown, unknown>} AnyEffect
+ */
 /**
  * @typedef {{ needs?: Record<string, BuilderStepHandle>; request: (ctx: Record<string, unknown>) => { title: string; summary?: string | null; }; onDeny?: "fail" | "continue" | "skip"; }} ApprovalOptions
  */
@@ -24,6 +27,41 @@ import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
 /** @typedef {import("./BuilderStepHandle.ts").BuilderStepHandle} BuilderStepHandle */
 /** @typedef {import("@smithers-orchestrator/scheduler/RetryPolicy").RetryPolicy} RetryPolicy */
 /** @typedef {import("./SmithersSqliteOptions.ts").SmithersSqliteOptions} SmithersSqliteOptions */
+/**
+ * @typedef {{
+ *   output: AnySchema;
+ *   needs?: Record<string, BuilderStepHandle>;
+ *   run?: (ctx: BuilderStepContext) => AnyEffect;
+ *   retry?: unknown;
+ *   retryPolicy?: RetryPolicy;
+ *   timeout?: unknown;
+ *   skipIf?: (ctx: BuilderStepContext) => boolean;
+ *   cache?: import("@smithers-orchestrator/scheduler/CachePolicy").CachePolicy;
+ * }} StepOptions
+ */
+/**
+ * @typedef {{
+ *   step: (id: string, options: StepOptions) => BuilderStepHandle;
+ *   approval: (id: string, options: ApprovalOptions) => BuilderStepHandle;
+ *   sequence: (...nodes: BuilderNode[]) => BuilderNode;
+ *   parallel: (...nodesOrOptions: [...BuilderNode[], { maxConcurrency?: number }] | BuilderNode[]) => BuilderNode;
+ *   loop: (options: { id?: string; children: BuilderNode; until: (outputs: Record<string, unknown>) => boolean; maxIterations?: number; onMaxReached?: "fail" | "return-last"; }) => BuilderNode;
+ *   match: (source: BuilderStepHandle, options: { when: (value: unknown) => boolean; then: () => BuilderNode; else?: () => BuilderNode; }) => BuilderNode;
+ *   component: (instanceId: string, definition: ComponentDefinition, params?: Record<string, unknown>) => BuilderNode;
+ * }} BuilderApi
+ */
+/**
+ * @typedef {{ execute: (input: unknown, opts?: Omit<Parameters<typeof runWorkflow>[1], "input">) => import("effect").Effect.Effect<unknown, unknown, unknown> }} BuiltSmithersWorkflow
+ */
+/**
+ * @typedef {{ build: (buildGraph: ($: BuilderApi) => BuilderNode) => BuiltSmithersWorkflow }} WorkflowDefinitionBuilder
+ */
+/**
+ * @typedef {{ kind: "component-definition"; name: string; buildWithPrefix: (prefix: string, params?: Record<string, unknown>) => BuilderNode }} ComponentDefinition
+ */
+/**
+ * @typedef {{ build: (buildGraph: ($: BuilderApi, params?: Record<string, unknown>) => BuilderNode) => ComponentDefinition }} ComponentDefinitionBuilder
+ */
 
 const SmithersSqlite = Context.GenericTag("smithers/effect/sqlite");
 class ApprovalDecision extends Schema.Class("ApprovalDecision")({
@@ -754,7 +792,7 @@ function normalizeExecutionError(result) {
 /**
  * @param {{ name: string; input: AnySchema }} options
  */
-function _createWorkflow(options) {
+export function createWorkflow(options) {
     return {
         /**
      * @param {($: BuilderApi) => BuilderNode} buildGraph
@@ -804,7 +842,7 @@ function _createWorkflow(options) {
 /**
  * @param {{ name: string; params?: Record<string, unknown> }} options
  */
-function _createComponent(options) {
+export function createComponent(options) {
     return {
         /**
      * @param {($: BuilderApi, params: Record<string, unknown>) => BuilderNode} buildGraph
@@ -831,7 +869,9 @@ function _createComponent(options) {
 function sqlite(options) {
     return Layer.succeed(SmithersSqlite, options);
 }
-/** @type {{ sqlite: typeof sqlite }} */
+/** @type {{ sqlite: typeof sqlite; createWorkflow: typeof createWorkflow; createComponent: typeof createComponent }} */
 export const Smithers = {
     sqlite,
+    createWorkflow,
+    createComponent,
 };

package/src/effect/workflow-bridge.js

@@ -72,8 +72,12 @@ function isRetryableBridgeTaskFailure(attempt) {
     if (meta?.failureRetryable === false) {
         return false;
     }
+    const errorCode = parseAttemptErrorCode(attempt?.errorJson);
+    if (errorCode === "AGENT_CONFIG_INVALID") {
+        return false;
+    }
     const kind = typeof meta?.kind === "string" ? meta.kind : null;
-    return !(kind !== "agent" && parseAttemptErrorCode(attempt?.errorJson) === "INVALID_OUTPUT");
+    return !(kind !== "agent" && errorCode === "INVALID_OUTPUT");
 }
 /**
  * @param {SmithersDb} adapter

package/src/engine.js

@@ -25,7 +25,7 @@ import { findVcsRoot } from "@smithers-orchestrator/vcs/find-root";
 import * as BunContext from "@effect/platform-bun/BunContext";
 import { eq, getTableName } from "drizzle-orm";
 import { getTableColumns } from "drizzle-orm/utils";
-import { Chunk, Duration, Effect, Fiber, Metric, Queue, Schedule } from "effect";
+import { Cause, Chunk, Duration, Effect, Exit, Fiber, Metric, Queue, Schedule } from "effect";
 import { attemptDuration, cacheHits, cacheMisses, nodeDuration, promptSizeBytes, responseSizeBytes, runDuration, runsResumedTotal, schedulerConcurrencyUtilization, schedulerQueueDepth, schedulerWaitDuration, trackEvent, } from "@smithers-orchestrator/observability/metrics";
 import { runScorersAsync } from "@smithers-orchestrator/scorers/run-scorers";
 import { dirname, resolve } from "node:path";
@@ -287,6 +287,25 @@ function isHeartbeatPayloadValidationError(err) {
     return (code === "HEARTBEAT_PAYLOAD_NOT_JSON_SERIALIZABLE" ||
         code === "HEARTBEAT_PAYLOAD_TOO_LARGE");
 }
+/**
+ * Effect.runPromise rejects with a FiberFailure wrapper. For task execution we
+ * need the original failure so retry metadata can read SmithersError fields.
+ *
+ * @template A
+ * @param {Effect.Effect<A, unknown>} effect
+ * @returns {Promise<A>}
+ */
+async function runPromisePreservingFailure(effect) {
+    const exit = await Effect.runPromiseExit(effect);
+    if (Exit.isSuccess(exit)) {
+        return exit.value;
+    }
+    const failure = Cause.failureOption(exit.cause);
+    if (failure._tag === "Some") {
+        throw failure.value;
+    }
+    throw Cause.squash(exit.cause);
+}
 /**
  * @param {Record<string, unknown>} meta
  * @param {string} engine
@@ -1784,6 +1803,7 @@ function resolveTaskOutputs(tasks, workflow) {
         if (isTimerTask(task)) {
             continue;
         }
+        const hasAmbiguousOutputRef = Boolean(task.outputRef && workflow.ambiguousZodSchemas?.has(task.outputRef));
         // Already resolved (has a table)
         if (task.outputTable) {
             if (!task.outputSchema && task.outputTableName && workflow.schemaRegistry) {
@@ -1807,10 +1827,14 @@ function resolveTaskOutputs(tasks, workflow) {
                 }
             }
             if (!task.outputTable) {
+                if (hasAmbiguousOutputRef) {
+                    throw new SmithersError("UNKNOWN_OUTPUT_SCHEMA", `Task "${task.nodeId}" uses an output schema that is registered under multiple keys. Use createSmithers(...).outputs.<key> or a string output key instead of the shared raw Zod object.`);
+                }
                 throw new SmithersError("UNKNOWN_OUTPUT_SCHEMA", `Task "${task.nodeId}" uses an output ZodObject that is not registered in createSmithers()`);
             }
         }
         const raw = task.outputSchema;
+        const hasAmbiguousOutputSchema = Boolean(raw && typeof raw === "object" && workflow.ambiguousZodSchemas?.has(raw));
         // Resolve ZodObject via outputSchema when no outputRef resolved.
         if (!task.outputTable && raw && typeof raw === "object" && workflow.zodToKeyName) {
             const keyName = workflow.zodToKeyName.get(raw);
@@ -1824,6 +1848,9 @@ function resolveTaskOutputs(tasks, workflow) {
                 }
             }
             if (!task.outputTable) {
+                if (hasAmbiguousOutputSchema) {
+                    throw new SmithersError("UNKNOWN_OUTPUT_SCHEMA", `Task "${task.nodeId}" uses an output schema that is registered under multiple keys. Use createSmithers(...).outputs.<key> or a string output key instead of the shared raw Zod object.`);
+                }
                 throw new SmithersError("UNKNOWN_OUTPUT_SCHEMA", `Task "${task.nodeId}" uses an output ZodObject that is not registered in createSmithers()`);
             }
         }
@@ -2554,6 +2581,7 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
     let cacheJjBase = null;
     let responseText = null;
     let effectiveAgent = null;
+    let supportsNativeStructuredOutput = false;
     // Resolve effective root once so both caching and execution share it.
     const taskRoot = desc.worktreePath ?? toolConfig.rootDir;
     const stepCacheEnabled = cacheEnabled || Boolean(desc.cachePolicy);
@@ -2874,7 +2902,8 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                     maybeCompleteHijack();
                 };
                 let effectivePrompt = desc.prompt ?? "";
-                if (desc.outputTable) {
+                supportsNativeStructuredOutput = effectiveAgent.supportsNativeStructuredOutput === true;
+                if (desc.outputTable && !supportsNativeStructuredOutput) {
                     const schemaDesc = describeSchemaShape(desc.outputTable, desc.outputSchema);
                     const jsonInstructions = [
                         "**REQUIRED OUTPUT** — You MUST end your response with a JSON object in a code fence matching this schema:",
@@ -3026,7 +3055,7 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                 // Use fallback agent on retry attempts when available
                 let result;
                 try {
-                    result = await Effect.runPromise(withSmithersSpan(smithersSpanNames.agent, Effect.tryPromise({
+                    result = await runPromisePreservingFailure(withSmithersSpan(smithersSpanNames.agent, Effect.tryPromise({
                         try: () => {
                             const agentCall = guidedResumeMessages?.length
                                 ? {
@@ -3486,17 +3515,25 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
             const zodIssues = validation.error?.issues
                 ?.map((iss) => `  - ${(iss.path ?? []).join(".")}: ${iss.message}`)
                 .join("\n") ?? "Unknown validation error";
-            const schemaRetryPrompt = [
-                `Your output didn't match the required schema. Validation errors:`,
-                zodIssues,
-                ``,
-                `Please return valid JSON matching the schema exactly.`,
-                ``,
-                `You MUST output ONLY a valid JSON object with exactly these fields and types:`,
-                schemaDesc,
-                ``,
-                `Output ONLY the JSON object, no other text.`,
-            ].join("\n");
+            const schemaRetryPrompt = supportsNativeStructuredOutput
+                ? [
+                    `Your structured output didn't match the required schema. Validation errors:`,
+                    zodIssues,
+                    ``,
+                    `Return corrected structured data matching this schema:`,
+                    schemaDesc,
+                ].join("\n")
+                : [
+                    `Your output didn't match the required schema. Validation errors:`,
+                    zodIssues,
+                    ``,
+                    `Please return valid JSON matching the schema exactly.`,
+                    ``,
+                    `You MUST output ONLY a valid JSON object with exactly these fields and types:`,
+                    schemaDesc,
+                    ``,
+                    `Output ONLY the JSON object, no other text.`,
+                ].join("\n");
             logInfo("schema validation retry", {
                 runId,
                 nodeId: desc.nodeId,
@@ -3526,6 +3563,9 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                     recordInternalHeartbeat();
                     emitOutput(text, "stderr");
                 },
+                ...(supportsNativeStructuredOutput
+                    ? { outputSchema: desc.outputSchema }
+                    : {}),
             });
             const retryText = (schemaRetryResult.text ?? "").trim();
             responseText = retryText || responseText;
@@ -3547,8 +3587,24 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                 cloneJsonValue(schemaRetryMessages) ?? schemaRetryMessages;
             // Try to parse the retry response
             let retryOutput;
+            if (supportsNativeStructuredOutput) {
+                try {
+                    if (schemaRetryResult._output !== undefined &&
+                        schemaRetryResult._output !== null) {
+                        retryOutput = schemaRetryResult._output;
+                    }
+                    else if (schemaRetryResult.output !== undefined &&
+                        schemaRetryResult.output !== null) {
+                        retryOutput = schemaRetryResult.output;
+                    }
+                }
+                catch {
+                    // Structured output access threw; fall back to text parsing.
+                }
+            }
             try {
-                if (retryText.startsWith("{") || retryText.startsWith("[")) {
+                if (retryOutput === undefined &&
+                    (retryText.startsWith("{") || retryText.startsWith("["))) {
                     retryOutput = JSON.parse(retryText);
                 }
             }
@@ -3743,9 +3799,9 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
         if (effectiveError &&
             typeof effectiveError === "object" &&
             // @ts-ignore — duck-type on SmithersError shape
-            effectiveError.details &&
-            // @ts-ignore
-            effectiveError.details.failureRetryable === false) {
+            (effectiveError.details?.failureRetryable === false ||
+                // @ts-ignore
+                effectiveError.code === "AGENT_CONFIG_INVALID")) {
             attemptMeta.failureRetryable = false;
         }
         // Honour `discardResumeSession: true` from agent-side errors (e.g. kimi

package/src/index.d.ts

@@ -1220,10 +1220,63 @@ type WorktreeNode = {
     children: BuilderNode$1;
 };
 type BuilderNode$1 = BuilderStepHandle$1 | SequenceNode | ParallelNode | LoopNode | MatchNode | BranchNode | WorktreeNode;
-
-/** @type {{ sqlite: typeof sqlite }} */
+type StepOptions = {
+    output: AnySchema$1;
+    needs?: Record<string, BuilderStepHandle$1>;
+    run?: (ctx: BuilderStepContext$1) => AnyEffect;
+    retry?: unknown;
+    retryPolicy?: RetryPolicy$1;
+    timeout?: unknown;
+    skipIf?: (ctx: BuilderStepContext$1) => boolean;
+    cache?: CachePolicy;
+};
+type ComponentDefinition = {
+    kind: "component-definition";
+    name: string;
+    buildWithPrefix: (prefix: string, params?: Record<string, unknown>) => BuilderNode$1;
+};
+type BuilderApi = {
+    step: (id: string, options: StepOptions) => BuilderStepHandle$1;
+    approval: (id: string, options: ApprovalOptions$1) => BuilderStepHandle$1;
+    sequence: (...nodes: BuilderNode$1[]) => BuilderNode$1;
+    parallel: (...nodesOrOptions: Array<BuilderNode$1 | {
+        maxConcurrency?: number;
+    }>) => BuilderNode$1;
+    loop: (options: {
+        id?: string;
+        children: BuilderNode$1;
+        until: (outputs: Record<string, unknown>) => boolean;
+        maxIterations?: number;
+        onMaxReached?: "fail" | "return-last";
+    }) => BuilderNode$1;
+    match: (source: BuilderStepHandle$1, options: {
+        when: (value: unknown) => boolean;
+        then: () => BuilderNode$1;
+        else?: () => BuilderNode$1;
+    }) => BuilderNode$1;
+    component: (instanceId: string, definition: ComponentDefinition, params?: Record<string, unknown>) => BuilderNode$1;
+};
+type BuiltSmithersWorkflow = {
+    execute: (input: unknown, opts?: Omit<Parameters<typeof runWorkflow>[1], "input">) => Effect.Effect<unknown, unknown, unknown>;
+};
+type WorkflowDefinitionBuilder = {
+    build: (buildGraph: ($: BuilderApi) => BuilderNode$1) => BuiltSmithersWorkflow;
+};
+type ComponentDefinitionBuilder = {
+    build: (buildGraph: ($: BuilderApi, params?: Record<string, unknown>) => BuilderNode$1) => ComponentDefinition;
+};
+declare function createWorkflow(options: {
+    name: string;
+    input: AnySchema$1;
+}): WorkflowDefinitionBuilder;
+declare function createComponent(options: {
+    name: string;
+    params?: Record<string, unknown>;
+}): ComponentDefinitionBuilder;
 declare const Smithers: {
     sqlite: typeof sqlite;
+    createWorkflow: typeof createWorkflow;
+    createComponent: typeof createComponent;
 };
 type AnySchema = effect.Schema.Schema<unknown, unknown, never>;
 type ApprovalOptions = {
@@ -1234,6 +1287,12 @@ type ApprovalOptions = {
     };
     onDeny?: "fail" | "continue" | "skip";
 };
+type BuiltSmithersWorkflow$1 = BuiltSmithersWorkflow;
+type BuilderApi$1 = BuilderApi;
+type ComponentDefinition$1 = ComponentDefinition;
+type ComponentDefinitionBuilder$1 = ComponentDefinitionBuilder;
+type StepOptions$1 = StepOptions;
+type WorkflowDefinitionBuilder$1 = WorkflowDefinitionBuilder;
 type BuilderNode = BuilderNode$1;
 type BuilderStepContext = Record<string, unknown> & {
     input: unknown;
@@ -1594,4 +1653,4 @@ type SmithersWorkflow = any;
 
 type ChildWorkflowDefinition = ChildWorkflowDefinition$1;
 
-export { type AlertHumanRequestOptions, AlertRuntime, type AlertRuntimeServices, type AnySchema, type ApprovalOptions, type ApprovalPayload, ApprovalPayloadSchema, type ApprovalResult, ApprovalResultSchema, type BridgeManagedTaskKind, type BuilderNode, type BuilderStepContext, type BuilderStepHandle, type CancelPayload, CancelPayloadSchema, type CancelResult, CancelResultSchema, type ChildWorkflowDefinition, type ChildWorkflowExecuteOptions, CodeplaneSandboxExecutorLive, type ComputeTaskBridgeToolConfig, type ContinuationRequest, type CorrelatedSmithersEvent, type CorrelationContext, type DiffBundle, DockerSandboxExecutorLive, EventBus, type ExecuteTaskActivityOptions, type FilePatch, type GetRunPayload, GetRunPayloadSchema, type GetRunResult, GetRunResultSchema, HUMAN_REQUEST_KINDS, HUMAN_REQUEST_STATUSES, type HijackState, type HotReloadEvent, HotWorkflowController, type HumanRequestKind, type HumanRequestSchemaValidation, type HumanRequestStatus, type JsonSchema, type LegacyExecuteTaskFn, type ListRunsPayload, ListRunsPayloadSchema, type OverlayOptions, type PlanNode, type RalphMeta, type RalphState, type RalphStateMap, type ReadonlyTaskStateMap, RetriableTaskFailure, type RetryPolicy, type RetryWaitMap, type RunResult$2 as RunResult, RunStatusSchema, type RunSummary, RunSummarySchema, type SQLiteTable, SandboxHttpRunner, type ScheduleResult, type ScheduleSnapshot, type SignalPayload, SignalPayloadSchema, type SignalResult, SignalResultSchema, type SignalRunOptions, Smithers, type SmithersAlertPolicy, type SmithersEvent, SmithersRpcGroup, type SmithersSqliteOptions, SqlMessageStorage, type StaticTaskBridgeToolConfig, type TaskActivityContext, type TaskActivityRetryOptions, type TaskBridgeToolConfig, type TaskRecord, TaskResult, type TaskState, type TaskStateMap, TaskWorkerEntity, WatchTree, type WatchTreeOptions, WorkerDispatchKind, WorkerTask$1 as WorkerTask, WorkerTaskKind, type WorkflowPatchDecisionRecord, type WorkflowPatchDecisions, type WorkflowVersioningRuntime, type WorkflowVersioningRuntimeOptions, type XmlNode, type _TaskActivityContext, applyDiffBundle, approve, approveNode, awaitApprovalDurableDeferred, awaitWaitForEventDurableDeferred, bridgeApprovalResolve, bridgeSignalResolve, bridgeWaitForEventResolve, buildHumanRequestId, buildOverlay, buildPlanTree, canExecuteBridgeManagedComputeTask, canExecuteBridgeManagedStaticTask, cancel, cancelPendingTimersBridge, cleanupGenerations, computeDiffBundle, computeDiffBundleBetweenRefs, createSchedulerWakeQueue, createWorkflowVersioningRuntime, denyNode, dispatchWorkerTask, ensureSqlMessageStorage, ensureSqlMessageStorageEffect, executeChildWorkflow, executeComputeTaskBridge, executeStaticTaskBridge, executeTaskActivity, executeTaskBridge, executeTaskBridgeEffect, getDefinedToolMetadata, getHumanTaskPrompt, getRun, getSqlMessageStorage, getWorkflowMakeBridgeRuntime, getWorkflowPatchDecisions, getWorkflowVersioningRuntime, isBridgeManagedTimerTask, isBridgeManagedWaitForEventTask, isHumanRequestPastTimeout, isHumanTaskMeta, isPidAlive, isRunHeartbeatFresh, isTaskResultFailure, jsonSchemaToZod, listRuns, makeAbortError, makeApprovalDurableDeferred, makeDurableDeferredBridgeExecutionId, makeTaskActivity, makeTaskBridgeKey, makeWaitForEventDurableDeferred, makeWorkerTask, parseAttemptMetaJson, parseRuntimeOwnerPid, renderFrame, resolveDeferredTaskStateBridge, resolveOverlayEntry, resolveSchema, runWorkflow, runWorkflowWithMakeBridge, scheduleTasks, signal, signalRun, subscribeTaskWorkerDispatches, usePatched, validateHumanRequestValue, wireAbortSignal, withWorkflowMakeBridgeRuntime, withWorkflowVersioningRuntime };
+export { type AlertHumanRequestOptions, AlertRuntime, type AlertRuntimeServices, type AnySchema, type ApprovalOptions, type ApprovalPayload, ApprovalPayloadSchema, type ApprovalResult, ApprovalResultSchema, type BridgeManagedTaskKind, type BuilderApi$1 as BuilderApi, type BuilderNode, type BuilderStepContext, type BuilderStepHandle, type BuiltSmithersWorkflow$1 as BuiltSmithersWorkflow, type CancelPayload, CancelPayloadSchema, type CancelResult, CancelResultSchema, type ChildWorkflowDefinition, type ChildWorkflowExecuteOptions, CodeplaneSandboxExecutorLive, type ComponentDefinition$1 as ComponentDefinition, type ComponentDefinitionBuilder$1 as ComponentDefinitionBuilder, type ComputeTaskBridgeToolConfig, type ContinuationRequest, type CorrelatedSmithersEvent, type CorrelationContext, type DiffBundle, DockerSandboxExecutorLive, EventBus, type ExecuteTaskActivityOptions, type FilePatch, type GetRunPayload, GetRunPayloadSchema, type GetRunResult, GetRunResultSchema, HUMAN_REQUEST_KINDS, HUMAN_REQUEST_STATUSES, type HijackState, type HotReloadEvent, HotWorkflowController, type HumanRequestKind, type HumanRequestSchemaValidation, type HumanRequestStatus, type JsonSchema, type LegacyExecuteTaskFn, type ListRunsPayload, ListRunsPayloadSchema, type OverlayOptions, type PlanNode, type RalphMeta, type RalphState, type RalphStateMap, type ReadonlyTaskStateMap, RetriableTaskFailure, type RetryPolicy, type RetryWaitMap, type RunResult$2 as RunResult, RunStatusSchema, type RunSummary, RunSummarySchema, type SQLiteTable, SandboxHttpRunner, type ScheduleResult, type ScheduleSnapshot, type SignalPayload, SignalPayloadSchema, type SignalResult, SignalResultSchema, type SignalRunOptions, Smithers, type SmithersAlertPolicy, type SmithersEvent, SmithersRpcGroup, type SmithersSqliteOptions, SqlMessageStorage, type StaticTaskBridgeToolConfig, type StepOptions$1 as StepOptions, type TaskActivityContext, type TaskActivityRetryOptions, type TaskBridgeToolConfig, type TaskRecord, TaskResult, type TaskState, type TaskStateMap, TaskWorkerEntity, WatchTree, type WatchTreeOptions, WorkerDispatchKind, WorkerTask$1 as WorkerTask, WorkerTaskKind, type WorkflowDefinitionBuilder$1 as WorkflowDefinitionBuilder, type WorkflowPatchDecisionRecord, type WorkflowPatchDecisions, type WorkflowVersioningRuntime, type WorkflowVersioningRuntimeOptions, type XmlNode, type _TaskActivityContext, applyDiffBundle, approve, approveNode, awaitApprovalDurableDeferred, awaitWaitForEventDurableDeferred, bridgeApprovalResolve, bridgeSignalResolve, bridgeWaitForEventResolve, buildHumanRequestId, buildOverlay, buildPlanTree, canExecuteBridgeManagedComputeTask, canExecuteBridgeManagedStaticTask, cancel, cancelPendingTimersBridge, cleanupGenerations, computeDiffBundle, computeDiffBundleBetweenRefs, createComponent, createSchedulerWakeQueue, createWorkflow, createWorkflowVersioningRuntime, denyNode, dispatchWorkerTask, ensureSqlMessageStorage, ensureSqlMessageStorageEffect, executeChildWorkflow, executeComputeTaskBridge, executeStaticTaskBridge, executeTaskActivity, executeTaskBridge, executeTaskBridgeEffect, getDefinedToolMetadata, getHumanTaskPrompt, getRun, getSqlMessageStorage, getWorkflowMakeBridgeRuntime, getWorkflowPatchDecisions, getWorkflowVersioningRuntime, isBridgeManagedTimerTask, isBridgeManagedWaitForEventTask, isHumanRequestPastTimeout, isHumanTaskMeta, isPidAlive, isRunHeartbeatFresh, isTaskResultFailure, jsonSchemaToZod, listRuns, makeAbortError, makeApprovalDurableDeferred, makeDurableDeferredBridgeExecutionId, makeTaskActivity, makeTaskBridgeKey, makeWaitForEventDurableDeferred, makeWorkerTask, parseAttemptMetaJson, parseRuntimeOwnerPid, renderFrame, resolveDeferredTaskStateBridge, resolveOverlayEntry, resolveSchema, runWorkflow, runWorkflowWithMakeBridge, scheduleTasks, signal, signalRun, subscribeTaskWorkerDispatches, usePatched, validateHumanRequestValue, wireAbortSignal, withWorkflowMakeBridgeRuntime, withWorkflowVersioningRuntime };