@stigmer/runner-slim 3.10.0 → 3.11.1-dev.20260812192248

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@stigmer/runner-slim",
-  "version": "3.10.0",
+  "version": "3.11.1-dev.20260812192248",
   "description": "Self-contained Stigmer runner build for embedding in desktop apps — the bundle-friendly @stigmer/runner",
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=22.13"
+    "node": "^22.13.0 || >=23.4.0"
   },
   "bin": {
     "stigmer-runner": "./main.js"
@@ -16,11 +16,11 @@
     "jq-wasm": "^1.1.0-jq-1.8.1"
   },
   "optionalDependencies": {
-    "@stigmer/runner-slim-darwin-arm64": "3.10.0",
-    "@stigmer/runner-slim-darwin-x64": "3.10.0",
-    "@stigmer/runner-slim-linux-x64": "3.10.0",
-    "@stigmer/runner-slim-linux-arm64": "3.10.0",
-    "@stigmer/runner-slim-win32-x64": "3.10.0"
+    "@stigmer/runner-slim-darwin-arm64": "3.11.1-dev.20260812192248",
+    "@stigmer/runner-slim-darwin-x64": "3.11.1-dev.20260812192248",
+    "@stigmer/runner-slim-linux-x64": "3.11.1-dev.20260812192248",
+    "@stigmer/runner-slim-linux-arm64": "3.11.1-dev.20260812192248",
+    "@stigmer/runner-slim-win32-x64": "3.11.1-dev.20260812192248"
   },
   "keywords": [
     "stigmer",

package/workflow-bundle.js

@@ -25152,12 +25152,14 @@ function buildRecoveryContext(tasks) {
 "use strict";
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   RuntimePlaceholderResolutionError: () => (/* binding */ RuntimePlaceholderResolutionError),
 /* harmony export */   collectExpressions: () => (/* binding */ collectExpressions),
 /* harmony export */   isRuntimePlaceholder: () => (/* binding */ isRuntimePlaceholder),
 /* harmony export */   resolveConfigExpressions: () => (/* binding */ resolveConfigExpressions),
 /* harmony export */   resolveEmbeddedExpressions: () => (/* binding */ resolveEmbeddedExpressions),
 /* harmony export */   resolveObjectPlaceholders: () => (/* binding */ resolveObjectPlaceholders),
 /* harmony export */   resolveRuntimePlaceholders: () => (/* binding */ resolveRuntimePlaceholders),
+/* harmony export */   resolveRuntimePlaceholdersStrict: () => (/* binding */ resolveRuntimePlaceholdersStrict),
 /* harmony export */   substituteResults: () => (/* binding */ substituteResults)
 /* harmony export */ });
 /* harmony import */ var _clone_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./clone.js */ "./dist/workflow-engine/clone.js");
@@ -25288,6 +25290,8 @@ function parsePath(path) {
     return parts;
 }
 const RUNTIME_PLACEHOLDER_RE = /\$\{\.(secrets|env_vars)\.\w+\}/;
+/** Substitution form of {@link RUNTIME_PLACEHOLDER_RE} (global, capturing). */
+const RUNTIME_PLACEHOLDER_SUB_RE = /\$\{\.(secrets|env_vars)\.(\w+)\}/g;
 /**
  * Checks whether a string contains a runtime placeholder that should
  * NOT be evaluated in the workflow (deterministic) phase. These are
@@ -25301,16 +25305,49 @@ function isRuntimePlaceholder(value) {
 }
 /**
  * Resolves runtime placeholders (`${.secrets.KEY}`, `${.env_vars.KEY}`)
- * in a string using values from the runtime environment map.
+ * in a string using values from the runtime environment map. Missing
+ * keys resolve to `""` — callers that must fail loudly instead use
+ * {@link resolveRuntimePlaceholdersStrict}.
  *
  * This runs in activities only — never in the workflow sandbox.
  */
 function resolveRuntimePlaceholders(value, runtimeEnv) {
-    return value.replace(/\$\{\.(secrets|env_vars)\.(\w+)\}/g, (_match, _ns, key) => {
+    return value.replace(RUNTIME_PLACEHOLDER_SUB_RE, (_match, _ns, key) => {
         const resolved = runtimeEnv[key];
         return resolved !== undefined ? String(resolved) : "";
     });
 }
+/** Thrown by {@link resolveRuntimePlaceholdersStrict} for a missing key. */
+class RuntimePlaceholderResolutionError extends Error {
+    variableName;
+    context;
+    constructor(variableName, context) {
+        const where = context ? ` in ${context}` : "";
+        super(`Unresolved runtime placeholder for "${variableName}"${where}: ` +
+            `variable is not present in the workflow's runtime environment`);
+        this.variableName = variableName;
+        this.context = context;
+        this.name = "RuntimePlaceholderResolutionError";
+    }
+}
+/**
+ * Strict variant of {@link resolveRuntimePlaceholders}: a placeholder
+ * whose key is missing from the runtime environment throws instead of
+ * resolving to `""` — a silently-empty credential produces cryptic
+ * downstream failures, so declared-value consumers (the run task's env
+ * contract) fail fast with the variable named.
+ *
+ * This runs in activities only — never in the workflow sandbox.
+ */
+function resolveRuntimePlaceholdersStrict(value, runtimeEnv, context) {
+    return value.replace(RUNTIME_PLACEHOLDER_SUB_RE, (_match, _ns, key) => {
+        const resolved = runtimeEnv[key];
+        if (resolved === undefined) {
+            throw new RuntimePlaceholderResolutionError(key, context);
+        }
+        return String(resolved);
+    });
+}
 /**
  * Recursively resolves all runtime placeholders in a nested object.
  * Walks maps, arrays, and strings. Non-string leaves pass through.
@@ -28071,6 +28108,7 @@ async function emitProgress(input, childExecId, progress) {
             type: "agent_call_progress",
             taskName: input.taskName,
             occurredAt: new Date().toISOString(),
+            sequenceNumber: input.nextEventSequence?.(),
             childExecutionId: childExecId,
             agentSlug: input.config.agent ?? "",
             agentPhase: progress?.agentPhase ?? 0,
@@ -28125,6 +28163,13 @@ __webpack_require__.r(__webpack_exports__);
  * type-only imports, and pure JS/TS logic.
  */
 
+// Discovery's bounds ladder (issue #239): the activity heartbeats every 15s,
+// so heartbeatTimeout is pure LIVENESS (dead worker/pod detection) — it no
+// longer kills slow-but-alive discoveries. The activity bounds its own WORK
+// with a transport-aware init timeout (30s HTTP / 270s stdio) that fails with
+// an actionable, endpoint-naming error; startToCloseTimeout is the hard cap
+// above both. Keep the ordering: work bound < hard cap, heartbeat interval
+// (15s) < heartbeatTimeout.
 const discover = (0,_temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.proxyActivities)({
     startToCloseTimeout: "600s",
     heartbeatTimeout: "60s",
@@ -28253,6 +28298,7 @@ async function connectMcpServer(input) {
     const discovery = await discover.DiscoverMcpServerCapabilities({
         mcpServerId: input.mcp_server_id,
         executionContextId: input.execution_context_id ?? null,
+        executionContextToken: input.execution_context_token ?? null,
         invokerIdentityAccountId: input.invoker_identity_account_id ?? null,
     });
     // Content-addressed incremental classification: reuse prior decisions for
@@ -28317,6 +28363,7 @@ async function discoverMcpServerLegacy(input) {
     const discovery = await discover.DiscoverMcpServerCapabilities({
         mcpServerId: input.mcp_server_id,
         executionContextId: input.execution_context_id ?? null,
+        executionContextToken: input.execution_context_token ?? null,
         invokerIdentityAccountId: input.invoker_identity_account_id ?? null,
     });
     return {
@@ -28452,7 +28499,21 @@ async function runWorkflowEngine(input, options) {
         dsl: model.document.dsl,
     });
     (0,_metrics_sink_js__WEBPACK_IMPORTED_MODULE_1__.recordExecutionStartMetric)(model.document.name);
-    await eventProxy.ResetEventSequence(executionId);
+    // Event sequence numbers are workflow state: assigned here in the
+    // deterministic sandbox (seeded from the persisted high-water mark) so
+    // they are stable across activity retries, worker restarts, and
+    // concurrent executions — the store can then treat re-sent sequences as
+    // idempotent duplicates. Pre-patch histories recorded the activity
+    // result as void and assigned sequences inside the emit activity from a
+    // process-global counter; they must keep doing so on replay, hence the
+    // gate. Remove the gate (and the activity's legacy counter) once
+    // pre-patch executions have drained.
+    const workflowAssignedSequences = (0,_temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.patched)("workflow-assigned-event-sequences");
+    const eventLogHighWaterMark = await eventProxy.ResetEventSequence(executionId);
+    let eventSequence = workflowAssignedSequences ? Number(eventLogHighWaterMark ?? 0) : 0;
+    const nextEventSequence = workflowAssignedSequences
+        ? () => ++eventSequence
+        : undefined;
     let recoveryContext;
     if (options?.recoveryMode && executionId) {
         _temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.log.info("Recovery mode active — loading context", { executionId });
@@ -28476,10 +28537,16 @@ async function runWorkflowEngine(input, options) {
     const emitEvents = async (events) => {
         if (!executionId || events.length === 0)
             return;
+        const stamped = nextEventSequence
+            ? events.map(e => ({ ...e, sequenceNumber: nextEventSequence() }))
+            : events;
         try {
-            await eventProxy.EmitWorkflowEvents(executionId, events, taskStatusAccumulator.toArray());
+            await eventProxy.EmitWorkflowEvents(executionId, stamped, taskStatusAccumulator.toArray());
         }
         catch (err) {
+            // Final guard after the activity's retries are exhausted: a run must
+            // not die because its timeline write failed. With workflow-assigned
+            // sequences the result is a gap in the log, never a poisoned log.
             _temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.log.warn("Failed to emit workflow events (non-fatal)", {
                 executionId,
                 eventCount: events.length,
@@ -28531,6 +28598,7 @@ async function runWorkflowEngine(input, options) {
             parentWorkflowId: agentMeta.parentWorkflowId || (0,_temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.workflowInfo)().workflowId,
             taskName: agentMeta.taskName,
             workflowExecutionId: agentMeta.workflowExecutionId || executionId,
+            nextEventSequence,
         }),
         promoteTaskOutput: (taskOutput, wexId, taskName, displayName) => promoteProxy.PromoteTaskOutput(taskOutput, wexId || executionId, taskName, displayName),
     };
@@ -28714,7 +28782,17 @@ async function executeFromExecution(input) {
         envCount: Object.keys(materialized.env).length,
     });
     try {
-        return await (0,_engine_core_js__WEBPACK_IMPORTED_MODULE_1__.runWorkflowEngine)(materialized, {
+        // The engine's output is deliberately NOT returned. Both orchestrator
+        // parents discard this workflow's result (Java awaits it as Void, Go
+        // passes nil to Get), and the output already reaches users through
+        // PromoteTaskOutput and the event log. Returning it would (a) persist
+        // the full workflow output — which may embed secrets — as a plaintext
+        // payload in the cross-language parent's history, and (b) hand the Java
+        // parent a payload it must decode: once the payload-encryption codec is
+        // active, an encrypted result would fail Java's converter lookup
+        // (fromPayloads has no Void special-case). A void return produces a
+        // data-less binary/null payload that every SDK handles natively.
+        await (0,_engine_core_js__WEBPACK_IMPORTED_MODULE_1__.runWorkflowEngine)(materialized, {
             checkPause,
             recoveryMode: input.recovery_mode ?? false,
         });