@smithers-orchestrator/engine 0.20.1 → 0.20.4

package/src/effect/static-task-bridge.js

@@ -21,13 +21,13 @@ import * as BunContext from "@effect/platform-bun/BunContext";
 function isAbortError(err) {
     if (!err)
         return false;
-    if (err.name === "AbortError")
-        return true;
     if (typeof DOMException !== "undefined" &&
         err instanceof DOMException &&
         err.name === "AbortError") {
         return true;
     }
+    if (err.name === "AbortError")
+        return true;
     if (err instanceof Error) {
         return /aborted|abort/i.test(err.message);
     }
@@ -304,3 +304,7 @@ export const executeStaticTaskBridge = async (adapter, runId, desc, eventBus, to
         removeAbortForwarder();
     }
 };
+
+export const __staticTaskBridgeInternals = {
+    isAbortError,
+};

package/src/effect/workflow-bridge.js

@@ -113,6 +113,12 @@ const getNextTaskActivityAttempt = async (adapter, runId, desc) => {
     const latestAttempt = attempts[0]?.attempt ?? 0;
     return latestAttempt + 1;
 };
+function taskBridgeResultForError(error) {
+    if (error instanceof RetriableTaskFailure) {
+        return { terminal: false };
+    }
+    throw error;
+}
 /**
  * @param {SmithersDb} adapter
  * @param {_BunSQLiteDatabase} db
@@ -174,10 +180,7 @@ const runTaskBridgeExecution = async (adapter, db, runId, desc, descriptorMap, i
             return { terminal: true };
         }
         catch (error) {
-            if (error instanceof RetriableTaskFailure) {
-                return { terminal: false };
-            }
-            throw error;
+            return taskBridgeResultForError(error);
         }
     });
 };
@@ -260,3 +263,11 @@ export const executeTaskBridgeEffect = (adapter, db, runId, desc, descriptorMap,
     try: () => executeTaskBridge(adapter, db, runId, desc, descriptorMap, inputTable, eventBus, toolConfig, workflowName, cacheEnabled, signal, disabledAgents, runAbortController, hijackState, legacyExecuteTaskFn),
     catch: (cause) => toSmithersError(cause, "execute task bridge"),
 });
+export const __workflowBridgeInternals = {
+    classifyTaskAttempt,
+    getNextTaskActivityAttempt,
+    isRetryableBridgeTaskFailure,
+    parseAttemptErrorCode,
+    runEffectOrPromise,
+    taskBridgeResultForError,
+};

package/src/effect/workflow-make-bridge.js

@@ -175,9 +175,6 @@ export function createSchedulerWakeQueue() {
             }
             return new Promise((resolve) => {
                 resolver = () => {
-                    if (pending > 0) {
-                        pending -= 1;
-                    }
                     resolve();
                 };
             });
@@ -231,3 +228,13 @@ export async function runWorkflowWithMakeBridge(workflow, opts, executeBody) {
         }
     }
 }
+
+export const __workflowMakeBridgeInternals = {
+    createWorkflowExecutionEffect,
+    createWorkflowMakeBridgeRuntime,
+    executeRegisteredChildWorkflow,
+    getWorkflowNamespace,
+    isSuspendingStatus,
+    makeBridgeWorkflow,
+    registerBridgeWorkflow,
+};

package/src/engine.js

@@ -2980,14 +2980,14 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                 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:",
-                        "```json",
+                        "**REQUIRED OUTPUT** — You MUST return ONLY a raw JSON object matching this schema:",
                         schemaDesc,
-                        "```",
-                        "Output the JSON at the END of your response. The workflow will fail without it.",
+                        "Do not include prose, markdown, headings, commentary, or code fences.",
+                        "The first character of your response must be `{` and the last character must be `}`.",
+                        "The workflow will fail unless the entire response is the JSON object.",
                     ].join("\n");
                     effectivePrompt = [
-                        "IMPORTANT: After completing the task below, you MUST output a JSON object in a ```json code fence at the very end of your response. Do NOT forget this — the workflow fails without it.",
+                        "IMPORTANT: After completing the task below, you MUST output ONLY a raw JSON object. Do NOT wrap it in markdown or add any prose — the workflow fails without it.",
                         "",
                         effectivePrompt,
                         "",
@@ -3448,7 +3448,7 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                             `Now you MUST output ONLY a valid JSON object (no other text) summarizing your work above, with exactly these fields and types:`,
                             schemaDesc,
                             ``,
-                            `Output ONLY the JSON object, nothing else.`,
+                            `Output ONLY the raw JSON object, with no markdown fences or prose.`,
                         ].join("\n");
                         const retryResult = await effectiveAgent.generate({
                             options: undefined,
@@ -3679,7 +3679,7 @@ async function legacyExecuteTask(adapter, db, runId, desc, descriptorMap, inputT
                     `You MUST output ONLY a valid JSON object with exactly these fields and types:`,
                     schemaDesc,
                     ``,
-                    `Output ONLY the JSON object, no other text.`,
+                    `Output ONLY the raw JSON object, with no markdown fences or other text.`,
                 ].join("\n");
             logInfo("schema validation retry", {
                 runId,
@@ -4318,7 +4318,8 @@ async function runWorkflowAsync(workflow, opts) {
  * @returns {Promise<RunBodyResult>}
  */
 async function runWorkflowBody(workflow, opts) {
-    if (process.env.SMITHERS_LEGACY_ENGINE === "1") {
+    if (opts.__smithersEngineMode === "legacy" ||
+        process.env.SMITHERS_LEGACY_ENGINE === "1") {
         return runWorkflowBodyLegacy(workflow, opts);
     }
     return runWorkflowBodyDriver(workflow, opts);
@@ -7229,3 +7230,79 @@ export function runWorkflow(workflow, opts) {
         root: true,
     });
 }
+
+export const __engineInternals = {
+    sha256Hex,
+    isBlockingAgentActionKind,
+    makeAbortError,
+    isAbortError,
+    collectErrorMessages,
+    isStructuredOutputParseFailure,
+    depsTextAccessHint,
+    makeStructuredOutputCompatibilityError,
+    makePlainTextOutputError,
+    abortPromise,
+    parseAttemptMetaJson,
+    asConversationMessages,
+    cloneJsonValue,
+    parseAttemptHeartbeatData,
+    validateHeartbeatValue,
+    serializeHeartbeatPayload,
+    heartbeatTimeoutReasonFromAbort,
+    isHeartbeatPayloadValidationError,
+    runPromisePreservingFailure,
+    extractHijackContinuation,
+    findHijackContinuation,
+    collectDefinedToolMetadata,
+    collectToolResumeWarnings,
+    buildToolResumeWarningMessage,
+    hasToolResumeWarningMessage,
+    appendToolResumeWarningMessage,
+    prependToolResumeWarningMessage,
+    workflowSessionTaskId,
+    workflowSessionTaskIds,
+    summarizeWorkflowSessionDecision,
+    summarizeLegacySchedulerDecision,
+    workflowSessionSummaryKey,
+    coercePositiveInt,
+    buildInputRow,
+    normalizeInputRow,
+    normalizeOutputRow,
+    quoteSqlIdent,
+    toSqlValue,
+    getTableColumnEntries,
+    insertRowWithClient,
+    copyRunScopedRowsWithClient,
+    ralphStateToObject,
+    cloneRalphStateMap,
+    buildCarriedInputRow,
+    continueRunAsNew,
+    resolveRootDir,
+    resolveLogDir,
+    getWorkflowImportScanLoader,
+    extractWorkflowImportSpecifiers,
+    resolveWorkflowImport,
+    buildDurabilityConfig,
+    getStoredDurabilityConfig,
+    compareNullableString,
+    assertResumeDurabilityMetadata,
+    wireAbortSignal,
+    parseRunConfigJson,
+    parseRunAuthContext,
+    isResumableRunStatus,
+    normalizeHotOptions,
+    assertInputObject,
+    validateRunOptions,
+    iterationsToMap,
+    ralphStateFromDriverTransition,
+    resolveTaskOutputs,
+    buildDescriptorMap,
+    buildRalphStateMap,
+    ralphIterationsFromState,
+    ralphIterationsObject,
+    buildRalphDoneMap,
+    parseAttemptErrorCode,
+    isRetryableTaskFailure,
+    cancelInProgress,
+    cancelStaleAttempts,
+};

package/src/hot/HotWorkflowController.js

@@ -17,6 +17,37 @@ import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
 
 const DEFAULT_MAX_GENERATIONS = 3;
 const DEFAULT_DEBOUNCE_MS = 100;
+
+function makeHotReloadFailureEvent(err, ctx) {
+    const { entryPath, generation, changedFiles } = ctx;
+    if (err instanceof Error && err.message?.includes("Schema change detected")) {
+        logWarning("hot workflow reload marked unsafe", {
+            entryPath,
+            generation,
+            changedFileCount: changedFiles.length,
+            reason: err.message,
+        }, "hot:reload");
+        return {
+            type: "unsafe",
+            generation,
+            changedFiles,
+            reason: err.message,
+        };
+    }
+    logWarning("hot workflow reload failed", {
+        entryPath,
+        generation,
+        changedFileCount: changedFiles.length,
+        error: err instanceof Error ? err.message : String(err),
+    }, "hot:reload");
+    return {
+        type: "failed",
+        generation,
+        changedFiles,
+        error: err,
+    };
+}
+
 export class HotWorkflowController {
     entryPath;
     hotRoot;
@@ -160,32 +191,11 @@ export class HotWorkflowController {
             };
         }).pipe(Effect.catchAll((err) => Effect.gen(function* () {
             yield* Metric.increment(hotReloadFailures);
-            if (err instanceof Error && err.message?.includes("Schema change detected")) {
-                logWarning("hot workflow reload marked unsafe", {
-                    entryPath,
-                    generation: gen,
-                    changedFileCount: changedFiles.length,
-                    reason: err.message,
-                }, "hot:reload");
-                return {
-                    type: "unsafe",
-                    generation: gen,
-                    changedFiles,
-                    reason: err.message,
-                };
-            }
-            logWarning("hot workflow reload failed", {
+            return makeHotReloadFailureEvent(err, {
                 entryPath,
                 generation: gen,
-                changedFileCount: changedFiles.length,
-                error: err instanceof Error ? err.message : String(err),
-            }, "hot:reload");
-            return {
-                type: "failed",
-                generation: gen,
                 changedFiles,
-                error: err,
-            };
+            });
         })), Effect.annotateLogs({
             entryPath,
             hotRoot,
@@ -218,3 +228,7 @@ export class HotWorkflowController {
         }), Effect.withLogSpan("hot:close"));
     }
 }
+
+export const __hotWorkflowControllerInternals = {
+    makeHotReloadFailureEvent,
+};

package/src/hot/overlay.js

@@ -13,6 +13,17 @@ const DEFAULT_EXCLUDE = [
     ".smithers",
     ".DS_Store",
 ];
+
+function hotOverlayError(cause, operation, details) {
+    return toSmithersError(cause, operation, {
+        code: "HOT_OVERLAY_FAILED",
+        details,
+    });
+}
+
+function hotOverlayErrorMapper(operation, details) {
+    return (cause) => hotOverlayError(cause, operation, details);
+}
 /**
  * Build a generation overlay by hardlinking (or copying) the hot root
  * tree into a new generation directory.
@@ -31,9 +42,10 @@ export function buildOverlayEffect(hotRoot, outDir, generation, opts) {
     return Effect.gen(function* () {
         yield* Effect.tryPromise({
             try: () => mkdir(genDir, { recursive: true }),
-            catch: (cause) => toSmithersError(cause, "create hot overlay generation dir", {
-                code: "HOT_OVERLAY_FAILED",
-                details: { hotRoot, outDir, generation },
+            catch: hotOverlayErrorMapper("create hot overlay generation dir", {
+                hotRoot,
+                outDir,
+                generation,
             }),
         });
         yield* mirrorTreeEffect(hotRoot, genDir, exclude);
@@ -63,9 +75,9 @@ function mirrorTreeEffect(src, dest, exclude) {
     return Effect.gen(function* () {
         const entries = yield* Effect.tryPromise({
             try: () => readdir(src, { withFileTypes: true }),
-            catch: (cause) => toSmithersError(cause, "read hot overlay source dir", {
-                code: "HOT_OVERLAY_FAILED",
-                details: { src, dest },
+            catch: hotOverlayErrorMapper("read hot overlay source dir", {
+                src,
+                dest,
             }),
         });
         for (const entry of entries) {
@@ -78,9 +90,9 @@ function mirrorTreeEffect(src, dest, exclude) {
             if (entry.isDirectory()) {
                 yield* Effect.tryPromise({
                     try: () => mkdir(destPath, { recursive: true }),
-                    catch: (cause) => toSmithersError(cause, "create mirrored hot overlay dir", {
-                        code: "HOT_OVERLAY_FAILED",
-                        details: { srcPath, destPath },
+                    catch: hotOverlayErrorMapper("create mirrored hot overlay dir", {
+                        srcPath,
+                        destPath,
                     }),
                 });
                 yield* mirrorTreeEffect(srcPath, destPath, exclude);
@@ -88,24 +100,24 @@ function mirrorTreeEffect(src, dest, exclude) {
             else if (entry.isFile()) {
                 const linked = yield* Effect.either(Effect.tryPromise({
                     try: () => link(srcPath, destPath),
-                    catch: (cause) => toSmithersError(cause, "hardlink overlay file", {
-                        code: "HOT_OVERLAY_FAILED",
-                        details: { srcPath, destPath },
+                    catch: hotOverlayErrorMapper("hardlink overlay file", {
+                        srcPath,
+                        destPath,
                     }),
                 }));
                 if (linked._tag === "Left") {
                     yield* Effect.tryPromise({
                         try: () => mkdir(dirname(destPath), { recursive: true }),
-                        catch: (cause) => toSmithersError(cause, "create overlay file parent dir", {
-                            code: "HOT_OVERLAY_FAILED",
-                            details: { srcPath, destPath },
+                        catch: hotOverlayErrorMapper("create overlay file parent dir", {
+                            srcPath,
+                            destPath,
                         }),
                     });
                     yield* Effect.tryPromise({
                         try: () => copyFile(srcPath, destPath),
-                        catch: (cause) => toSmithersError(cause, "copy overlay file", {
-                            code: "HOT_OVERLAY_FAILED",
-                            details: { srcPath, destPath },
+                        catch: hotOverlayErrorMapper("copy overlay file", {
+                            srcPath,
+                            destPath,
                         }),
                     });
                 }
@@ -126,9 +138,9 @@ export function cleanupGenerationsEffect(outDir, keepLast) {
             return;
         const entries = yield* Effect.tryPromise({
             try: () => readdir(outDir, { withFileTypes: true }),
-            catch: (cause) => toSmithersError(cause, "read hot overlay generations", {
-                code: "HOT_OVERLAY_FAILED",
-                details: { outDir, keepLast },
+            catch: hotOverlayErrorMapper("read hot overlay generations", {
+                outDir,
+                keepLast,
             }),
         });
         const genDirs = entries
@@ -143,9 +155,9 @@ export function cleanupGenerationsEffect(outDir, keepLast) {
         for (const dir of toRemove) {
             yield* Effect.either(Effect.tryPromise({
                 try: () => rm(join(outDir, dir.name), { recursive: true, force: true }),
-                catch: (cause) => toSmithersError(cause, "remove stale hot overlay generation", {
-                    code: "HOT_OVERLAY_FAILED",
-                    details: { outDir, generationDir: dir.name },
+                catch: hotOverlayErrorMapper("remove stale hot overlay generation", {
+                    outDir,
+                    generationDir: dir.name,
                 }),
             }));
         }
@@ -175,3 +187,9 @@ export function resolveOverlayEntry(entryPath, hotRoot, genDir) {
     const rel = relative(hotRoot, entryPath);
     return resolve(genDir, rel);
 }
+
+export const __overlayInternals = {
+    hotOverlayError,
+    hotOverlayErrorMapper,
+    mirrorTreeEffect,
+};

package/src/human-requests.js

@@ -118,3 +118,6 @@ export function validateHumanRequestValue(request, value) {
     }
     return { ok: true };
 }
+export const __humanRequestInternals = {
+    formatValidationIssues,
+};