@desplega.ai/agent-swarm 1.136.0 → 1.138.0

package/dist/{cli-jjhnma34.js → cli-4jaj24py.js}

@@ -1,3 +1,7 @@
+import {
+  DEFAULT_MODEL,
+  resolveCredential
+} from "./cli-2ypjdmqg.js";
 import {
   getOpenRouterBaseUrl
 } from "./cli-3dpj7atn.js";
@@ -18,15 +22,21 @@ import {
   sandboxSpawnEnv,
   snapshotCapped,
   touchScratchScriptLastUsed
-} from "./cli-bnq8h7ea.js";
+} from "./cli-3719ggyf.js";
 import {
   withSiblingAwareness
-} from "./cli-gpdtxzar.js";
+} from "./cli-23cpnqk9.js";
+import {
+  getSlackApp
+} from "./cli-cywkhzqs.js";
 import {
   FollowUpConfigSchema,
   ModelTierSchema,
   ReasoningEffortSchema,
+  cancelPendingApprovalRequestsForRun,
   cancelTask,
+  claimApprovalCancellationNotification,
+  completeApprovalCancellationNotificationClaim,
   createWorkflowRun,
   createWorkflowRunStep,
   createWorkflowVersion,
@@ -58,7 +68,9 @@ import {
   init_db,
   init_telemetry,
   init_types,
+  listCancelledApprovalRequestsForRun,
   listWorkflows,
+  releaseApprovalCancellationNotificationClaim,
   resolveApprovalRequest,
   resolveWaitState,
   splitLegacyModelAlias,
@@ -67,7 +79,7 @@ import {
   updateWorkflowRun,
   updateWorkflowRunStep,
   workflowContextKey
-} from "./cli-tmn19cdz.js";
+} from "./cli-kq9htgbr.js";
 import {
   deepInterpolate,
   findInterpolationTokens,
@@ -81,14 +93,14 @@ import {
 import {
   init_zod
 } from "./cli-s35981d0.js";
+import {
+  exports_external
+} from "./cli-pqv5gvyf.js";
 import {
   init_secret_scrubber,
   isSensitiveKey,
   scrubSecrets
 } from "./cli-mkq1rk7b.js";
-import {
-  exports_external
-} from "./cli-pqv5gvyf.js";
 import {
   init_event_bus,
   workflowEventBus
@@ -467,14 +479,19 @@ async function checkpointStepFailure(runId, stepId, error, retryCount, retryPoli
   return { shouldRetry: false };
 }
 async function checkpointStepWaiting(runId, stepId, ctx) {
-  await getDbClient().transaction(async () => {
-    await updateWorkflowRunStep(stepId, {
-      status: "waiting"
-    });
-    await updateWorkflowRun(runId, {
-      status: "waiting",
-      context: ctx
-    });
+  return getDbClient().transaction(async () => {
+    const step = await getDbClient().get(`UPDATE workflow_run_steps
+         SET status = 'waiting'
+       WHERE id = ? AND runId = ? AND status = 'running'
+         AND EXISTS (
+           SELECT 1 FROM workflow_runs
+           WHERE id = ? AND status IN ('running', 'waiting')
+         )
+       RETURNING id`, [stepId, runId, runId]);
+    if (!step)
+      return false;
+    await updateWorkflowRun(runId, { status: "waiting", context: ctx });
+    return true;
   });
 }
 function calculateBackoff(policy, attempt) {
@@ -497,35 +514,8 @@ function calculateBackoff(policy, attempt) {
   return Math.min(delay, policy.maxDelayMs);
 }
 
-// src/workflows/cooldown.ts
+// src/workflows/completed-step-routing.ts
 init_db();
-function cooldownToMs(cooldown) {
-  let ms = 0;
-  if (cooldown.hours)
-    ms += cooldown.hours * 60 * 60 * 1000;
-  if (cooldown.minutes)
-    ms += cooldown.minutes * 60 * 1000;
-  if (cooldown.seconds)
-    ms += cooldown.seconds * 1000;
-  return ms;
-}
-async function shouldSkipCooldown(workflowId, cooldown) {
-  const cooldownMs = cooldownToMs(cooldown);
-  const now = Date.now();
-  const lastSuccess = await getLastSuccessfulRun(workflowId);
-  if (lastSuccess?.finishedAt) {
-    const lastFinished = new Date(lastSuccess.finishedAt).getTime();
-    if (now - lastFinished < cooldownMs)
-      return true;
-  }
-  const lastAttempt = await getLastRunStart(workflowId);
-  if (lastAttempt?.startedAt) {
-    const lastStarted = new Date(lastAttempt.startedAt).getTime();
-    if (now - lastStarted < cooldownMs)
-      return true;
-  }
-  return false;
-}
 
 // src/workflows/foreach-join.ts
 init_db();
@@ -606,6 +596,54 @@ function resultStatus(step) {
   return step.error ? "failed" : "completed";
 }
 
+// src/workflows/completed-step-routing.ts
+async function loadCompletedStepRouting(def, runId, completedNodeIds) {
+  const activeEdges = new Set;
+  const stepsByNodeId = new Map;
+  for (const nodeId of completedNodeIds) {
+    if (resolveForeachParent(def, nodeId))
+      continue;
+    const step = await getLatestStepForNode(runId, nodeId);
+    if (step)
+      stepsByNodeId.set(nodeId, step);
+    const successors = step?.nextPort ? getSuccessors(def, nodeId, step.nextPort) : getSuccessors(def, nodeId);
+    for (const successor of successors) {
+      activeEdges.add(`${nodeId}→${successor.id}`);
+    }
+  }
+  return { activeEdges, stepsByNodeId };
+}
+
+// src/workflows/cooldown.ts
+init_db();
+function cooldownToMs(cooldown) {
+  let ms = 0;
+  if (cooldown.hours)
+    ms += cooldown.hours * 60 * 60 * 1000;
+  if (cooldown.minutes)
+    ms += cooldown.minutes * 60 * 1000;
+  if (cooldown.seconds)
+    ms += cooldown.seconds * 1000;
+  return ms;
+}
+async function shouldSkipCooldown(workflowId, cooldown) {
+  const cooldownMs = cooldownToMs(cooldown);
+  const now = Date.now();
+  const lastSuccess = await getLastSuccessfulRun(workflowId);
+  if (lastSuccess?.finishedAt) {
+    const lastFinished = new Date(lastSuccess.finishedAt).getTime();
+    if (now - lastFinished < cooldownMs)
+      return true;
+  }
+  const lastAttempt = await getLastRunStart(workflowId);
+  if (lastAttempt?.startedAt) {
+    const lastStarted = new Date(lastAttempt.startedAt).getTime();
+    if (now - lastStarted < cooldownMs)
+      return true;
+  }
+  return false;
+}
+
 // src/workflows/input.ts
 init_db();
 init_secret_scrubber();
@@ -912,31 +950,8 @@ async function walkGraph(def, runId, ctx, startNodes, registry, workflowId, secr
   if (!("run" in ctx)) {
     ctx.run = { id: runId };
   }
-  const completedNodeIds = new Set(await getCompletedStepNodeIds(runId));
-  const activeEdges = new Set;
-  if (completedNodeIds.size > 0) {
-    for (const nodeId of completedNodeIds) {
-      if (resolveForeachParent(def, nodeId))
-        continue;
-      const step = await getLatestStepForNode(runId, nodeId);
-      if (step?.output !== undefined) {
-        const node = def.nodes.find((n) => n.id === nodeId);
-        if (node && registry.has(node.type)) {
-          const executor = registry.get(node.type);
-          const parseResult = executor.outputSchema.safeParse(step.output);
-          if (!parseResult.success) {
-            console.warn(`[workflow] Recovery: step ${nodeId} output failed validation: ${parseResult.error.message}`);
-            continue;
-          }
-        }
-        ctx[nodeId] = step.output;
-      }
-      const successors = step?.nextPort ? getSuccessors(def, nodeId, step.nextPort) : getSuccessors(def, nodeId);
-      for (const succ of successors) {
-        activeEdges.add(`${nodeId}→${succ.id}`);
-      }
-    }
-  }
+  const { completedNodeIds } = await rehydrateCompletedStepOutputs(def, runId, ctx, registry);
+  const { activeEdges } = await loadCompletedStepRouting(def, runId, completedNodeIds);
   const allSteps = await getWorkflowRunStepsByRunId(runId);
   if (allSteps.length >= getMaxWorkflowStepsPerRun()) {
     await updateWorkflowRun(runId, {
@@ -1054,6 +1069,31 @@ async function walkGraph(def, runId, ctx, startNodes, registry, workflowId, secr
     }
   });
 }
+async function rehydrateCompletedStepOutputs(def, runId, ctx, registry) {
+  const completedNodeIds = new Set(await getCompletedStepNodeIds(runId));
+  const latestSteps = new Map;
+  for (const nodeId of completedNodeIds) {
+    if (resolveForeachParent(def, nodeId))
+      continue;
+    const step = await getLatestStepForNode(runId, nodeId);
+    if (!step)
+      continue;
+    if (step.output !== undefined) {
+      const node = def.nodes.find((candidate) => candidate.id === nodeId);
+      if (node && registry.has(node.type)) {
+        const executor = registry.get(node.type);
+        const parseResult = executor.outputSchema.safeParse(step.output);
+        if (!parseResult.success) {
+          console.warn(`[workflow] Recovery: step ${nodeId} output failed validation: ${parseResult.error.message}`);
+          continue;
+        }
+      }
+      ctx[nodeId] = step.output;
+    }
+    latestSteps.set(nodeId, step);
+  }
+  return { completedNodeIds, latestSteps };
+}
 function getAllPredecessors(def, nodeId) {
   const preds = [];
   for (const node of def.nodes) {
@@ -1067,6 +1107,10 @@ function getAllPredecessors(def, nodeId) {
 }
 async function executeStep(def, runId, ctx, node, registry, workflowId, secretKeys = new Set, options = {}) {
   const dedup = await getDbClient().transaction(async () => {
+    const run = await getWorkflowRun(runId);
+    if (!run || run.status !== "running" && run.status !== "waiting") {
+      return { halted: true };
+    }
     const iteration = await getStepCountForNode(runId, node.id);
     const idempotencyKey = `${runId}:${node.id}:${iteration}`;
     const existingStep2 = await getStepByIdempotencyKey(idempotencyKey);
@@ -1088,6 +1132,8 @@ async function executeStep(def, runId, ctx, node, registry, workflowId, secretKe
     }
     return { existingStep: existingStep2, stepId: stepId2, deduped: false };
   });
+  if ("halted" in dedup)
+    return { outcome: "completed", successors: [] };
   if (dedup.deduped && dedup.existingStep) {
     if (dedup.existingStep.status === "completed") {
       ctx[node.id] = dedup.existingStep.output;
@@ -1170,8 +1216,8 @@ async function executeStep(def, runId, ctx, node, registry, workflowId, secretKe
     return { outcome: "completed", successors: [] };
   }
   if ("async" in result && result.async) {
-    await checkpointStepWaiting(runId, stepId, ctx);
-    return { outcome: "waiting", successors: [] };
+    const waiting = await checkpointStepWaiting(runId, stepId, ctx);
+    return { outcome: waiting ? "waiting" : "completed", successors: [] };
   }
   if (node.outputSchema && result.status === "success") {
     const outputErrors = validateJsonSchema(node.outputSchema, result.output);
@@ -1347,6 +1393,44 @@ var FAILED_TASK_OUTPUT_PREFIX = "[FAILED:";
 // src/workflows/resume.ts
 init_db();
 init_secret_scrubber();
+
+// src/workflows/approval-notifications.ts
+init_db();
+init_secret_scrubber();
+async function postApprovalCancellationUpdates(approvals, reason, client = getSlackApp()?.client) {
+  if (!client)
+    return;
+  const text = `This approval is no longer actionable: ${reason}`;
+  for (const approval of approvals) {
+    const channels = approval.notificationChannels;
+    const slackThreads = (channels ?? []).filter((notification) => notification.channel === "slack" && notification.messageTs);
+    if (slackThreads.length === 0)
+      continue;
+    for (const notification of slackThreads) {
+      if (notification.channel !== "slack" || !notification.messageTs)
+        continue;
+      const notificationKey = `${notification.target}:${notification.messageTs}`;
+      const claim = await claimApprovalCancellationNotification(approval.id, notificationKey);
+      if (!claim)
+        continue;
+      try {
+        await client.chat.postMessage({
+          channel: notification.target,
+          thread_ts: notification.messageTs,
+          text,
+          unfurl_links: false,
+          unfurl_media: false
+        });
+        await completeApprovalCancellationNotificationClaim(approval.id, notificationKey, claim.leaseToken);
+      } catch (error) {
+        await releaseApprovalCancellationNotificationClaim(approval.id, notificationKey, claim.leaseToken);
+        console.error(`[HITL] Failed to post cancellation update for approval ${approval.id}:`, scrubSecrets(error instanceof Error ? error.message : String(error)));
+      }
+    }
+  }
+}
+
+// src/workflows/resume.ts
 init_event_bus();
 
 // src/workflows/executors/wait.ts
@@ -1886,23 +1970,31 @@ async function retryFailedRun(runId, registry) {
   const failedStep = steps.find((s) => s.status === "failed");
   if (!failedStep)
     throw new Error("No failed step found");
+  const completedNodeIds = new Set(await getCompletedStepNodeIds(runId));
+  const { activeEdges } = await loadCompletedStepRouting(workflow.definition, runId, completedNodeIds);
+  const foreachParent = resolveForeachParent(workflow.definition, failedStep.nodeId);
+  const failedNode = foreachParent ?? workflow.definition.nodes.find((n) => n.id === failedStep.nodeId);
+  if (!failedNode)
+    throw new Error(`Node ${failedStep.nodeId} not found in workflow definition`);
+  const hasStructuralPredecessor = workflow.definition.nodes.some((node) => node.next && getNextTargets(node.next).includes(failedNode.id));
+  const hasActivePredecessor = [...activeEdges].some((edge) => edge.endsWith(`→${failedNode.id}`));
+  const shouldRetryFailedNode = foreachParent != null || !hasStructuralPredecessor || hasActivePredecessor;
   const ctx = run.context ?? {};
   const claimed = await getDbClient().transaction(async () => {
     const current = await getWorkflowRun(runId);
     if (!current || current.status !== "failed")
       return false;
-    await updateWorkflowRunStep(failedStep.id, { status: "pending", error: null });
+    await updateWorkflowRunStep(failedStep.id, {
+      status: shouldRetryFailedNode ? "pending" : "cancelled",
+      error: shouldRetryFailedNode ? null : "Skipped on retry because its branch was not active"
+    });
     await updateWorkflowRun(runId, { status: "running", error: null, context: ctx });
     return true;
   });
   if (!claimed)
     throw new Error("Run is not in failed state");
-  const completedNodeIds = new Set(await getCompletedStepNodeIds(runId));
-  const readyNodes = findReadyNodes(workflow.definition, completedNodeIds);
-  const failedNode = resolveForeachParent(workflow.definition, failedStep.nodeId) ?? workflow.definition.nodes.find((n) => n.id === failedStep.nodeId);
-  if (!failedNode)
-    throw new Error(`Node ${failedStep.nodeId} not found in workflow definition`);
-  const nodesToRun = readyNodes.some((n) => n.id === failedNode.id) ? readyNodes : [failedNode, ...readyNodes];
+  const readyNodes = findReadyNodes(workflow.definition, completedNodeIds, activeEdges);
+  const nodesToRun = !shouldRetryFailedNode || readyNodes.some((n) => n.id === failedNode.id) ? readyNodes : [failedNode, ...readyNodes];
   const secretKeys = getSecretInputKeys(workflow.input);
   await walkGraph(workflow.definition, runId, ctx, nodesToRun, registry, workflow.id, secretKeys);
 }
@@ -1911,15 +2003,17 @@ async function cancelWorkflowRun(runId, reason) {
   if (!run)
     throw new Error("Workflow run not found");
   const terminalStatuses = ["completed", "failed", "cancelled", "skipped"];
-  if (terminalStatuses.includes(run.status)) {
+  if (terminalStatuses.includes(run.status) && run.status !== "cancelled") {
     throw new Error(`Cannot cancel run in '${run.status}' state`);
   }
   const now = new Date().toISOString();
   const cancelReason = reason ?? "Cancelled by user";
+  let applied = false;
   await getDbClient().transaction(async () => {
     const current = await getWorkflowRun(runId);
     if (!current || terminalStatuses.includes(current.status))
       return;
+    applied = true;
     const steps = await getWorkflowRunStepsByRunId(runId);
     for (const step of steps) {
       if (terminalStatuses.includes(step.status))
@@ -1934,12 +2028,19 @@ async function cancelWorkflowRun(runId, reason) {
         finishedAt: now
       });
     }
+    await cancelPendingApprovalRequestsForRun(runId, cancelReason);
     await updateWorkflowRun(runId, {
       status: "cancelled",
       error: cancelReason,
       finishedAt: now
     });
   });
+  const cancelledApprovals = await listCancelledApprovalRequestsForRun(runId);
+  const latestRun = await getWorkflowRun(runId);
+  if (!applied && latestRun?.status !== "cancelled") {
+    throw new Error(`Cannot cancel run in '${latestRun?.status ?? "missing"}' state`);
+  }
+  await postApprovalCancellationUpdates(cancelledApprovals, applied ? cancelReason : latestRun?.error ?? cancelReason);
 }
 async function resumeFromApprovalResolution(event, registry) {
   const run = await getWorkflowRun(event.workflowRunId);
@@ -2324,6 +2425,7 @@ function startRetryPoller(registry, intervalMs = 5000) {
           const ctx = run.context ?? {};
           if (!("run" in ctx))
             ctx.run = { id: run.id };
+          await rehydrateCompletedStepOutputs(workflow.definition, run.id, ctx, registry);
           const inputCtx = buildNodeInterpolationCtx(node, ctx);
           const { value: interpolatedValue, scriptBodyUnresolved } = interpolateNodeConfig(node, inputCtx);
           if (scriptBodyUnresolved && scriptBodyUnresolved.length > 0) {
@@ -2351,7 +2453,9 @@ function startRetryPoller(registry, intervalMs = 5000) {
               const retryPolicy = node.retry || executor.retryPolicy;
               await checkpointStepFailure(run.id, step.id, result.error || "Retry failed", step.retryCount, retryPolicy);
             } else if ("async" in result && result.async) {
-              await checkpointStepWaiting(run.id, step.id, ctx);
+              const waiting = await checkpointStepWaiting(run.id, step.id, ctx);
+              if (!waiting)
+                continue;
             } else {
               if (node.validation) {
                 const validationResult = await runStepValidation(registry, node, result.output, ctx, meta);
@@ -3054,6 +3158,7 @@ function normalizeExistingTaskOutput(output) {
 // src/workflows/executors/human-in-the-loop.ts
 init_zod();
 init_constants();
+init_secret_scrubber();
 var SelectOptionSchema = exports_external.object({
   value: exports_external.string(),
   label: exports_external.string(),
@@ -3138,6 +3243,12 @@ class HumanInTheLoopExecutor extends BaseExecutor {
     const existing = await db.getApprovalRequestByStepId(meta.stepId);
     if (existing) {
       if (existing.status !== "pending") {
+        if (existing.status === "cancelled") {
+          return {
+            status: "failed",
+            error: `Approval request was cancelled: ${existing.resolutionReason ?? "workflow run cancelled"}`
+          };
+        }
         const nextPort = existing.status === "timeout" ? "timeout" : existing.status === "rejected" ? "rejected" : "approved";
         return {
           status: "success",
@@ -3157,7 +3268,7 @@ class HumanInTheLoopExecutor extends BaseExecutor {
       };
     }
     const requestId = crypto.randomUUID();
-    await db.createApprovalRequest({
+    const created = await db.createApprovalRequest({
       id: requestId,
       title: config.title,
       questions: config.questions,
@@ -3166,11 +3277,20 @@ class HumanInTheLoopExecutor extends BaseExecutor {
       workflowRunStepId: meta.stepId,
       timeoutSeconds: config.timeout?.seconds,
       notificationChannels: config.notifications,
-      createdBy: meta.requestedByUserId
+      createdBy: meta.requestedByUserId,
+      requireActionableWorkflow: true
     });
+    if (created.status === "cancelled") {
+      return {
+        status: "success",
+        async: true,
+        waitFor: "approval.resolved",
+        correlationId: requestId
+      };
+    }
     if (config.notifications?.length) {
       this.dispatchNotifications(requestId, config, db).catch((err) => {
-        console.error("[HITL] Unexpected error dispatching notifications:", err);
+        console.error("[HITL] Unexpected error dispatching notifications:", scrubSecrets(err instanceof Error ? err.message : String(err)));
       });
     }
     return {
@@ -3194,8 +3314,8 @@ class HumanInTheLoopExecutor extends BaseExecutor {
       }
       if (notification.channel === "slack") {
         try {
-          const { getSlackApp } = await import("./app-g2s78xya.js");
-          const slackApp = getSlackApp();
+          const { getSlackApp: getSlackApp2 } = await import("./app-wb6bc7tt.js");
+          const slackApp = getSlackApp2();
           if (!slackApp) {
             console.warn("[HITL] Slack not initialized — cannot send notification");
             continue;
@@ -3245,15 +3365,19 @@ ${questionsSummary}${timeoutText}`
           }
           console.log(`[HITL] Slack notification sent to ${notification.target} for request ${requestId}`);
         } catch (err) {
-          console.error(`[HITL] Failed to send Slack notification to ${notification.target}:`, err);
+          console.error(`[HITL] Failed to send Slack notification to ${notification.target}:`, scrubSecrets(err instanceof Error ? err.message : String(err)));
         }
       }
     }
     if (updated) {
       try {
         await db.updateApprovalRequestNotifications(requestId, updatedChannels);
+        const latest = await db.getApprovalRequestById(requestId);
+        if (latest?.status === "cancelled") {
+          await postApprovalCancellationUpdates([latest], latest.resolutionReason ?? "Workflow run cancelled");
+        }
       } catch (err) {
-        console.error("[HITL] Failed to update notification channels in DB:", err);
+        console.error("[HITL] Failed to update notification channels in DB:", scrubSecrets(err instanceof Error ? err.message : String(err)));
       }
     }
   }
@@ -3310,8 +3434,8 @@ class NotifyExecutor extends BaseExecutor {
         }
       }
       case "slack": {
-        const { getSlackApp } = await import("./app-g2s78xya.js");
-        const app = getSlackApp();
+        const { getSlackApp: getSlackApp2 } = await import("./app-wb6bc7tt.js");
+        const app = getSlackApp2();
         if (!app) {
           return {
             status: "success",
@@ -3422,6 +3546,26 @@ function evaluateCondition(op, actual, expected) {
 
 // src/workflows/executors/raw-llm.ts
 init_zod();
+
+// src/workflows/executors/workflow-llm.ts
+async function resolveWorkflowLlmConfig(requestedModel, env = process.env) {
+  const credential = await resolveCredential({ env });
+  if (!credential) {
+    throw new Error("No workflow LLM credential found. Set OPENROUTER_API_KEY or OPENAI_API_KEY.");
+  }
+  if (credential.kind !== "openrouter" && credential.kind !== "openai") {
+    throw new Error(`Workflow LLM nodes do not support the resolved ${credential.kind} credential yet. Set OPENROUTER_API_KEY or OPENAI_API_KEY.`);
+  }
+  const providerPrefix = `${credential.kind}/`;
+  const model = requestedModel ?? DEFAULT_MODEL[credential.kind];
+  return {
+    apiKey: credential.apiKey,
+    baseURL: credential.kind === "openrouter" ? getOpenRouterBaseUrl(env) : undefined,
+    model: model.startsWith(providerPrefix) ? model.slice(providerPrefix.length) : model
+  };
+}
+
+// src/workflows/executors/raw-llm.ts
 var RawLlmConfigSchema = exports_external.object({
   prompt: exports_external.string(),
   model: exports_external.string().optional(),
@@ -3433,16 +3577,18 @@ var RawLlmOutputSchema = exports_external.object({
   model: exports_external.string()
 });
 async function executeRawLlm(config) {
-  const modelName = config.model ?? "google/gemini-3-flash-preview";
+  let modelName = config.model ?? "google/gemini-3-flash-preview";
   try {
-    const { createOpenAI } = await import("./index-p13cfsc2.js");
-    const openrouter = createOpenAI({
-      baseURL: getOpenRouterBaseUrl(),
-      apiKey: process.env.OPENROUTER_API_KEY
+    const { createOpenAI } = await import("./index-agykc6k2.js");
+    const llmConfig = await resolveWorkflowLlmConfig(config.model);
+    modelName = llmConfig.model;
+    const provider = createOpenAI({
+      baseURL: llmConfig.baseURL,
+      apiKey: llmConfig.apiKey
     });
-    const model = openrouter(modelName);
+    const model = provider(llmConfig.model);
     if (config.schema) {
-      const { generateObject, jsonSchema } = await import("./index-pe58mf1r.js");
+      const { generateObject, jsonSchema } = await import("./index-1nsdwvn5.js");
       const { object } = await generateObject({
         model,
         schema: jsonSchema(config.schema),
@@ -3456,7 +3602,7 @@ async function executeRawLlm(config) {
         output: { result: object, model: modelName }
       };
     }
-    const { generateText } = await import("./index-pe58mf1r.js");
+    const { generateText } = await import("./index-1nsdwvn5.js");
     const { text } = await generateText({
       model,
       prompt: config.prompt
@@ -3889,14 +4035,15 @@ class ValidateExecutor extends BaseExecutor {
     const interpolatedPrompt = this.deps.interpolate(prompt, context);
     const outputStr = typeof targetOutput === "string" ? targetOutput : JSON.stringify(targetOutput);
     try {
-      const { createOpenAI } = await import("./index-p13cfsc2.js");
-      const { generateObject, jsonSchema } = await import("./index-pe58mf1r.js");
-      const openrouter = createOpenAI({
-        baseURL: getOpenRouterBaseUrl(),
-        apiKey: process.env.OPENROUTER_API_KEY
+      const { createOpenAI } = await import("./index-agykc6k2.js");
+      const { generateObject, jsonSchema } = await import("./index-1nsdwvn5.js");
+      const llmConfig = await resolveWorkflowLlmConfig();
+      const provider = createOpenAI({
+        baseURL: llmConfig.baseURL,
+        apiKey: llmConfig.apiKey
       });
       const { object } = await generateObject({
-        model: openrouter("google/gemini-3-flash-preview"),
+        model: provider(llmConfig.model),
         schema: jsonSchema({
           type: "object",
           properties: {

package/dist/{cli-6gwgzdgw.js → cli-69377c2a.js}

@@ -1,6 +1,6 @@
 import {
   summarizeSession
-} from "./cli-qhfkxrpg.js";
+} from "./cli-390sgxn5.js";
 import {
   checkToolLoop,
   clearToolHistory
@@ -27,14 +27,14 @@ import {
   getMcpBaseUrl,
   init_constants
 } from "./cli-a1rrkrb4.js";
+import {
+  init_package,
+  package_default
+} from "./cli-kkn46gfr.js";
 import {
   init_secret_scrubber,
   scrubSecrets
 } from "./cli-mkq1rk7b.js";
-import {
-  init_package,
-  package_default
-} from "./cli-4r4jkqep.js";
 
 // src/hooks/hook.ts
 init_package();