@stigmer/runner-slim 3.2.0 → 3.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stigmer/runner-slim",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "description": "Self-contained Stigmer runner build for embedding in desktop apps — the bundle-friendly @stigmer/runner",
   "license": "Apache-2.0",
   "engines": {
@@ -16,11 +16,11 @@
     "jq-wasm": "^1.1.0-jq-1.8.1"
   },
   "optionalDependencies": {
-    "@stigmer/runner-slim-darwin-arm64": "3.2.0",
-    "@stigmer/runner-slim-darwin-x64": "3.2.0",
-    "@stigmer/runner-slim-linux-x64": "3.2.0",
-    "@stigmer/runner-slim-linux-arm64": "3.2.0",
-    "@stigmer/runner-slim-win32-x64": "3.2.0"
+    "@stigmer/runner-slim-darwin-arm64": "3.2.2",
+    "@stigmer/runner-slim-darwin-x64": "3.2.2",
+    "@stigmer/runner-slim-linux-x64": "3.2.2",
+    "@stigmer/runner-slim-linux-arm64": "3.2.2",
+    "@stigmer/runner-slim-win32-x64": "3.2.2"
   },
   "keywords": [
     "stigmer",

package/workflow-bundle.js

@@ -24214,6 +24214,7 @@ function deepClone(value) {
 "use strict";
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   TASK_STARTED_INPUT_SUMMARY_PATCH: () => (/* binding */ TASK_STARTED_INPUT_SUMMARY_PATCH),
 /* harmony export */   executeDoTasks: () => (/* binding */ executeDoTasks)
 /* harmony export */ });
 /* harmony import */ var _types_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./types.js */ "./dist/workflow-engine/types.js");
@@ -24253,6 +24254,37 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+/**
+ * Deterministic-version gate id for the task_started emission reorder
+ * (input resolution moved ahead of the event so it can carry
+ * `input_summary`). Pre-change histories replay the old order — emit
+ * first, resolve second — via `TaskExecutionContext.isPatched`.
+ */
+const TASK_STARTED_INPUT_SUMMARY_PATCH = "task-started-input-summary";
+/**
+ * Truncation budget for event I/O summaries. Deliberately far below the
+ * 64KB snapshot cap: events are the live-stream preview source and the
+ * proto documents them as "truncated to prevent event bloat" — the full
+ * I/O lives on `status.tasks[]`.
+ */
+const EVENT_SUMMARY_MAX_BYTES = 8_192;
+/**
+ * Projects a task I/O value into the shape an event summary Struct can
+ * carry: truncated to the event budget, objects only (mirroring the
+ * snapshot path's `toJsonObject` semantics — proto Struct fields cannot
+ * carry scalars or arrays, and `status.tasks[].input/output` share the
+ * same limitation). Oversize values come back as `truncatePayload`'s
+ * `{_truncated, _preview}` marker object, which IS carried.
+ */
+function toEventSummary(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    const truncated = (0,_task_status_accumulator_js__WEBPACK_IMPORTED_MODULE_9__.truncatePayload)(value, EVENT_SUMMARY_MAX_BYTES);
+    if (truncated === null || typeof truncated !== "object" || Array.isArray(truncated)) {
+        return undefined;
+    }
+    return truncated;
+}
 /**
  * Returns the task kind string used for event emission. For call:function
  * tasks, appends the specific function name (e.g., "call:function:llm")
@@ -24349,20 +24381,37 @@ async function executeDoTasks(tasks, input, state, doc, evaluateExpressions, ctx
         const kind = eventTaskKind(entry);
         effectiveCtx.taskStatusAccumulator?.taskStarted(entry.key, kind);
         const attemptNumber = effectiveCtx.taskStatusAccumulator?.getAttempt(entry.key) ?? 1;
-        if (effectiveCtx.emitEvents) {
+        const emitTaskStarted = async (inputSummary) => {
+            if (!effectiveCtx.emitEvents)
+                return;
             await effectiveCtx.emitEvents([{
                     type: "task_started",
                     taskName: entry.key,
                     occurredAt: new Date().toISOString(),
                     taskKind: kind,
                     attemptNumber,
+                    inputSummary,
                 }]);
-        }
+        };
+        // Emission-order gate: carrying `input_summary` on task_started
+        // requires resolving the input BEFORE emitting, which reorders two
+        // local-activity commands — a non-deterministic change for in-flight
+        // histories (a gated or waiting task can be parked across a deploy).
+        // Pre-change histories replay the old emit-then-resolve order.
+        const emitStartedAfterResolve = effectiveCtx.isPatched?.(TASK_STARTED_INPUT_SUMMARY_PATCH) ?? true;
+        if (!emitStartedAfterResolve) {
+            await emitTaskStarted();
+        }
+        let startedEmitted = !emitStartedAfterResolve;
         const taskStartMs = Date.now();
         let taskOutput;
         try {
             const effectiveInput = await resolveTaskInput(entry, input, state, effectiveCtx);
             effectiveCtx.taskStatusAccumulator?.taskStartedWithInput(entry.key, kind, (0,_task_status_accumulator_js__WEBPACK_IMPORTED_MODULE_9__.truncatePayload)(effectiveInput));
+            if (emitStartedAfterResolve) {
+                await emitTaskStarted(toEventSummary(effectiveInput));
+                startedEmitted = true;
+            }
             taskOutput = await runSingleTask(entry, effectiveInput, state, doc, effectiveCtx);
         }
         catch (taskErr) {
@@ -24378,6 +24427,12 @@ async function executeDoTasks(tasks, input, state, doc, evaluateExpressions, ctx
                 });
             }
             if (effectiveCtx.emitEvents) {
+                // Input resolution failed before the reordered task_started could
+                // fire — emit it now so consumers always see the started→failed pair.
+                if (!startedEmitted) {
+                    await emitTaskStarted();
+                    startedEmitted = true;
+                }
                 await effectiveCtx.emitEvents([{
                         type: "task_failed",
                         taskName: entry.key,
@@ -24419,6 +24474,10 @@ async function executeDoTasks(tasks, input, state, doc, evaluateExpressions, ctx
                     durationMs: taskDurationMs,
                     costMicros: costInfo.costMicros,
                     tokensUsed: costInfo.inputTokens + costInfo.outputTokens,
+                    // The live-stream preview source for task cards: post-promotion
+                    // output (the artifact-promoted form is what downstream sees),
+                    // truncated to the event budget. Full output rides the snapshot.
+                    outputSummary: toEventSummary(promotedOutput),
                 }];
             for (const evt of promotionEvents) {
                 events.push(evt);
@@ -26217,6 +26276,69 @@ __webpack_require__.r(__webpack_exports__);
  * Mirrors Go's custom call function dispatch in `task_builder.go`.
  */
 
+/**
+ * Detaches deferred-code fields from a call-function config before
+ * expression resolution and returns a restorer that puts the originals
+ * back afterwards.
+ *
+ * Some config fields carry jq CODE that the activity evaluates later
+ * against its own input — not data to interpolate at config time:
+ *
+ * - `transform.expression` — evaluated by `transformAction` against the
+ *   transform's `input`.
+ * - `validate.rules[].expression` — evaluated by `validateAction` per
+ *   rule against the validated data.
+ *
+ * Without the detach, a `${ }`-wrapped predicate is pre-evaluated here
+ * against the WRONG input and its non-string RESULT is substituted back
+ * into the config; the activity then tries to evaluate that result as jq
+ * (the `expr.includes is not a function` crash class). All other fields
+ * — including `rules[].message` and the llm/eval prompt fields — are
+ * data and continue to interpolate normally. The original config object
+ * is never mutated (shared across retries).
+ */
+function detachDeferredCode(callType, config) {
+    if (callType === "transform" && "expression" in config) {
+        const { expression, ...rest } = config;
+        return {
+            config: rest,
+            restore: (resolved) => {
+                resolved.expression = expression;
+            },
+        };
+    }
+    if (callType === "validate" && Array.isArray(config.rules)) {
+        const originalRules = config.rules;
+        const strippedRules = originalRules.map((rule) => {
+            if (isPlainObject(rule) && "expression" in rule) {
+                const { expression: _deferred, ...rest } = rule;
+                return rest;
+            }
+            return rule;
+        });
+        return {
+            config: { ...config, rules: strippedRules },
+            restore: (resolved) => {
+                const resolvedRules = resolved.rules;
+                if (!Array.isArray(resolvedRules))
+                    return;
+                for (let i = 0; i < resolvedRules.length; i++) {
+                    const original = originalRules[i];
+                    const target = resolvedRules[i];
+                    if (isPlainObject(original) &&
+                        isPlainObject(target) &&
+                        "expression" in original) {
+                        target.expression = original.expression;
+                    }
+                }
+            },
+        };
+    }
+    return { config, restore: () => { } };
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 /**
  * Normalizes the raw LlmCallResult from the activity into the documented
  * task output contract: { text, structured, model, usage }.
@@ -26248,8 +26370,12 @@ class CallFunctionTaskBuilder {
     build() {
         return async (input, state, ctx) => {
             const withConfig = this.taskDef.with ?? {};
-            const resolved = await (0,_resolve_js__WEBPACK_IMPORTED_MODULE_0__.resolveConfigExpressions)(withConfig, input, state, ctx.evaluateExpressions);
             const callType = this.taskDef.call;
+            // Deferred-code fields (transform/validate expressions) must reach
+            // the activity as unresolved jq strings — see detachDeferredCode.
+            const deferred = detachDeferredCode(callType, withConfig);
+            const resolved = await (0,_resolve_js__WEBPACK_IMPORTED_MODULE_0__.resolveConfigExpressions)(deferred.config, input, state, ctx.evaluateExpressions);
+            deferred.restore(resolved);
             if ((callType === "transform" || callType === "validate") &&
                 !("input" in resolved) || resolved.input === undefined) {
                 resolved.input = input;
@@ -28371,6 +28497,10 @@ async function runWorkflowEngine(input, options) {
         checkPause: options?.checkPause,
         emitEvents,
         taskStatusAccumulator,
+        // Deterministic version gate for engine command-order changes (the
+        // kernel never imports Temporal APIs — it receives patched() as an
+        // opaque callback, like every other capability on this context).
+        isPatched: (changeId) => (0,_temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.patched)(changeId),
         sleep: async (durationMs) => {
             try {
                 await (0,_temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.sleep)(durationMs);