@stigmer/runner 3.12.3 → 3.12.4

package/src/workflow-engine/tasks/call-function.ts

@@ -162,26 +162,87 @@ export class CallFunctionTaskBuilder implements TaskBuilder {
       const executionId =
         (state.env.__stigmer_execution_id as string | undefined) || undefined;
 
-      const result = await ctx.callFunction(
-        callType,
-        resolved,
-        state.env,
-        {
-          workflowExecutionId: executionId,
-        },
-      );
+      const fnMeta = { workflowExecutionId: executionId };
 
       if (callType === "llm") {
-        return normalizeLlmOutput(
-          result as LlmActivityResult,
-          !!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.
+   */
+  private async executeLlmCall(
+    resolved: Record<string, unknown>,
+    env: Record<string, unknown>,
+    fnMeta: { workflowExecutionId?: string },
+    ctx: Parameters<TaskExecutorFn>[2],
+  ): Promise<unknown> {
+    const hasSchema = !!resolved.response_schema;
+    const onInvalid = (resolved.on_invalid as string | undefined) ?? "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 as number | undefined) ?? 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,
+      )) as LlmActivityResult;
+
+      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(): Promise<boolean> {
     return true;
   }

package/src/workflow-engine/types.ts

@@ -336,6 +336,12 @@ export interface HttpCallConfig {
   readonly query?: Record<string, string>;
   readonly output?: string;
   readonly redirect?: string;
+  /**
+   * Request timeout in seconds (proto: HttpCallTaskConfig.timeout_seconds,
+   * 1-300). Aborts the request and fails the task with HTTP_CALL_TIMEOUT;
+   * the engine also widens the activity's startToClose to fit it (#686).
+   */
+  readonly timeout_seconds?: number;
 }
 
 export type EndpointDef = string | { readonly uri: string; readonly authentication?: Record<string, unknown> };

package/src/workflows/engine-core.ts

@@ -67,17 +67,44 @@ const evalProxy = proxyLocalActivities<EvalActivities>({
   startToCloseTimeout: "10s",
 });
 
+const CALL_PROXY_RETRY = {
+  maximumAttempts: 5,
+  initialInterval: "1s",
+  backoffCoefficient: 2,
+  maximumInterval: "1m",
+} as const;
+
 const callProxy = proxyActivities<HttpActivities & GrpcActivities & FunctionActivities>({
   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<number, typeof callProxy>();
+function callProxyFor(timeoutSeconds: number | undefined): typeof callProxy {
+  if (!timeoutSeconds || !Number.isFinite(timeoutSeconds)) return callProxy;
+  let proxy = timeoutAwareProxies.get(timeoutSeconds);
+  if (!proxy) {
+    proxy = proxyActivities<HttpActivities & GrpcActivities & FunctionActivities>({
+      startToCloseTimeout: `${timeoutSeconds + 30}s`,
+      heartbeatTimeout: "30s",
+      retry: CALL_PROXY_RETRY,
+    });
+    timeoutAwareProxies.set(timeoutSeconds, proxy);
+  }
+  return proxy;
+}
+
 const runProxy = proxyActivities<RunActivities>({
   startToCloseTimeout: "5m",
   heartbeatTimeout: "30s",
@@ -240,7 +267,7 @@ export async function runWorkflowEngine(
     runWorkflow: (config: RunWorkflowExecutionConfig) => orchestrateRunWorkflow(config),
     awaitHumanInput: (config: HumanInputExecutionConfig) => orchestrateHumanInput(config),
     callHttp: (config: HttpCallConfig, runtimeEnv: Record<string, unknown>) =>
-      callProxy.CallHttp(config, runtimeEnv),
+      callProxyFor(config.timeout_seconds).CallHttp(config, runtimeEnv),
     callGrpc: (config: GrpcCallConfig, runtimeEnv: Record<string, unknown>) =>
       callProxy.CallGrpc(config, runtimeEnv),
     callFunction: (
@@ -249,7 +276,11 @@ export async function runWorkflowEngine(
       runtimeEnv: Record<string, unknown>,
       fnMeta: CallFunctionMetadata,
     ) =>
-      callProxy.CallFunction(
+      callProxyFor(
+        call === "llm" && typeof config.timeout === "number"
+          ? config.timeout
+          : undefined,
+      ).CallFunction(
         call,
         config,
         runtimeEnv,