@stigmer/runner-slim 3.12.3 → 3.12.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stigmer/runner-slim",
-  "version": "3.12.3",
+  "version": "3.12.5",
   "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.12.3",
-    "@stigmer/runner-slim-darwin-x64": "3.12.3",
-    "@stigmer/runner-slim-linux-x64": "3.12.3",
-    "@stigmer/runner-slim-linux-arm64": "3.12.3",
-    "@stigmer/runner-slim-win32-x64": "3.12.3"
+    "@stigmer/runner-slim-darwin-arm64": "3.12.5",
+    "@stigmer/runner-slim-darwin-x64": "3.12.5",
+    "@stigmer/runner-slim-linux-x64": "3.12.5",
+    "@stigmer/runner-slim-linux-arm64": "3.12.5",
+    "@stigmer/runner-slim-win32-x64": "3.12.5"
   },
   "keywords": [
     "stigmer",

package/workflow-bundle.js

@@ -26416,15 +26416,59 @@ class CallFunctionTaskBuilder {
                 resolved.input = input;
             }
             const executionId = state.env.__stigmer_execution_id || undefined;
-            const result = await ctx.callFunction(callType, resolved, state.env, {
-                workflowExecutionId: executionId,
-            });
+            const fnMeta = { workflowExecutionId: executionId };
             if (callType === "llm") {
-                return normalizeLlmOutput(result, !!resolved.response_schema);
+                return this.executeLlmCall(resolved, state.env, fnMeta, ctx);
             }
-            return result;
+            return ctx.callFunction(callType, resolved, state.env, fnMeta);
         };
     }
+    /**
+     * Executes a `call: llm` with schema-validation policy orchestration —
+     * the llm twin of call-agent's output-contract loop (#686).
+     *
+     * With ON_INVALID_RETRY / ON_INVALID_FALLBACK the activity reports a
+     * validation miss as a `parse_error` result instead of throwing; each
+     * retry is its own activity invocation (visible in Temporal history)
+     * re-prompting with the validation errors so the model can self-correct.
+     * Exhausted retries (or immediate FALLBACK) branch to `fallback_task`
+     * via the engine's flow directive; without one, the task fails — the
+     * proto contract. ON_INVALID_FAIL (default) keeps the activity's
+     * throwing path: one attempt, LLM_SCHEMA_VALIDATION on miss.
+     */
+    async executeLlmCall(resolved, env, fnMeta, ctx) {
+        const hasSchema = !!resolved.response_schema;
+        const onInvalid = resolved.on_invalid ?? "ON_INVALID_FAIL";
+        const softHandling = hasSchema && (onInvalid === "ON_INVALID_RETRY" || onInvalid === "ON_INVALID_FALLBACK");
+        // Proto: max_retries "Default: 1", meaningful only for ON_INVALID_RETRY.
+        const maxRetries = onInvalid === "ON_INVALID_RETRY" ? resolved.max_retries ?? 1 : 0;
+        let attempts = 0;
+        let lastParseError = "";
+        do {
+            const attemptConfig = attempts === 0
+                ? resolved
+                : {
+                    ...resolved,
+                    prompt: `${resolved.prompt}\n\n[RETRY — Your previous response did not match ` +
+                        `the required output schema. Validation errors: ${lastParseError}. ` +
+                        `Please ensure your response strictly matches the JSON schema provided.]`,
+                };
+            const result = (await ctx.callFunction("llm", attemptConfig, env, fnMeta));
+            if (!softHandling || !result.parse_error) {
+                return normalizeLlmOutput(result, hasSchema);
+            }
+            lastParseError = result.parse_error;
+            attempts++;
+        } while (onInvalid === "ON_INVALID_RETRY" && attempts <= maxRetries);
+        if (typeof resolved.fallback_task === "string" && resolved.fallback_task !== "") {
+            return {
+                __flow_directive__: resolved.fallback_task,
+                validation_errors: [lastParseError],
+            };
+        }
+        throw new Error(`LLM output validation failed after ${attempts} attempt(s) ` +
+            `for task '${this.taskName}': ${lastParseError}`);
+    }
     async shouldRun() {
         return true;
     }
@@ -26935,11 +26979,11 @@ async function executeHumanInputTask(taskDef, taskName, state, ctx) {
             ...review.artifactEvents,
         ]);
     }
-    const result = await ctx.awaitHumanInput({
+    const result = applyTimeoutOutcomeContract(await ctx.awaitHumanInput({
         signalName,
         timeoutSeconds,
         onTimeout,
-    });
+    }), config.outcomes);
     if (ctx.emitEvents) {
         await ctx.emitEvents([{
                 type: "approval_resolved",
@@ -26965,6 +27009,27 @@ function validateConfig(config, taskName) {
         throw new Error(`human_input task '${taskName}': 'prompt' is required`);
     }
 }
+/**
+ * Applies the proto contract for timeout auto-resolution with custom
+ * outcomes (HumanInputTaskConfig.outcomes doc): auto-approve resolves to
+ * the FIRST declared outcome and auto-deny to the LAST, so `then` routing
+ * and downstream outcome switches see declared outcome names — never the
+ * orchestrator's internal approve/deny words, which a reviewer of a
+ * custom-outcome gate was never offered. Binary gates (no custom outcomes)
+ * keep the plain approve/deny result.
+ */
+function applyTimeoutOutcomeContract(result, outcomes) {
+    if (!result.auto_resolved || result.reason !== "timeout" || !outcomes?.length) {
+        return result;
+    }
+    if (result.outcome === "approve") {
+        return { ...result, outcome: outcomes[0].name };
+    }
+    if (result.outcome === "deny") {
+        return { ...result, outcome: outcomes[outcomes.length - 1].name };
+    }
+    return result;
+}
 const NO_REVIEW_PAYLOAD = { artifactEvents: [] };
 /**
  * Resolves the review payload's `${ ... }` expressions and decides how it
@@ -28440,16 +28505,42 @@ __webpack_require__.r(__webpack_exports__);
 const evalProxy = (0,_temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.proxyLocalActivities)({
     startToCloseTimeout: "10s",
 });
+const CALL_PROXY_RETRY = {
+    maximumAttempts: 5,
+    initialInterval: "1s",
+    backoffCoefficient: 2,
+    maximumInterval: "1m",
+};
 const callProxy = (0,_temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.proxyActivities)({
     startToCloseTimeout: "5m",
     heartbeatTimeout: "30s",
-    retry: {
-        maximumAttempts: 5,
-        initialInterval: "1s",
-        backoffCoefficient: 2,
-        maximumInterval: "1m",
-    },
+    retry: CALL_PROXY_RETRY,
 });
+/**
+ * Task-config timeouts (llm_call.timeout ≤600s, http_call.timeout_seconds
+ * ≤300s) can exceed or crowd the default 5m startToClose, which would kill
+ * the activity before its own well-typed LLM_TIMEOUT / HTTP_CALL_TIMEOUT
+ * failure fires. When a task declares a budget, proxy its call with
+ * startToClose = budget + 30s so the in-activity bound always wins (#686).
+ *
+ * proxyActivities in workflow code is a deterministic proxy construction
+ * (no Temporal commands); the memo just avoids rebuilding per call.
+ */
+const timeoutAwareProxies = new Map();
+function callProxyFor(timeoutSeconds) {
+    if (!timeoutSeconds || !Number.isFinite(timeoutSeconds))
+        return callProxy;
+    let proxy = timeoutAwareProxies.get(timeoutSeconds);
+    if (!proxy) {
+        proxy = (0,_temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.proxyActivities)({
+            startToCloseTimeout: `${timeoutSeconds + 30}s`,
+            heartbeatTimeout: "30s",
+            retry: CALL_PROXY_RETRY,
+        });
+        timeoutAwareProxies.set(timeoutSeconds, proxy);
+    }
+    return proxy;
+}
 const runProxy = (0,_temporalio_workflow__WEBPACK_IMPORTED_MODULE_0__.proxyActivities)({
     startToCloseTimeout: "5m",
     heartbeatTimeout: "30s",
@@ -28589,9 +28680,11 @@ async function runWorkflowEngine(input, options) {
             : runProxy.RunShell(config),
         runWorkflow: (config) => (0,_run_orchestrator_js__WEBPACK_IMPORTED_MODULE_4__.orchestrateRunWorkflow)(config),
         awaitHumanInput: (config) => (0,_human_input_orchestrator_js__WEBPACK_IMPORTED_MODULE_5__.orchestrateHumanInput)(config),
-        callHttp: (config, runtimeEnv) => callProxy.CallHttp(config, runtimeEnv),
+        callHttp: (config, runtimeEnv) => callProxyFor(config.timeout_seconds).CallHttp(config, runtimeEnv),
         callGrpc: (config, runtimeEnv) => callProxy.CallGrpc(config, runtimeEnv),
-        callFunction: (call, config, runtimeEnv, fnMeta) => callProxy.CallFunction(call, config, runtimeEnv, fnMeta.workflowExecutionId ?? executionId),
+        callFunction: (call, config, runtimeEnv, fnMeta) => callProxyFor(call === "llm" && typeof config.timeout === "number"
+            ? config.timeout
+            : undefined).CallFunction(call, config, runtimeEnv, fnMeta.workflowExecutionId ?? executionId),
         callAgent: (config, runtimeEnv, agentMeta) => (0,_call_agent_orchestrator_js__WEBPACK_IMPORTED_MODULE_2__.orchestrateAgentCall)({
             config,
             runtimeEnv,