node_with_ignored

node_with_ignored

Error message

Node '${id}': 'with' is only supported on command, script, include, and workflow nodes — it is ignored here

What it means

The workflow loader warns that a node declared a 'with:' key is on a node type that does not support it, so Zod silently strips the value and the bindings never attach. 'with' is live only on command-sourced agent nodes, exec nodes with a non-sh runtime (script), include directives, and workflow nodes. The file still loads; the warning exists so authors learn their node-local input bindings were discarded (#2213, #2637).

Source

Thrown at packages/workflows/src/loader.ts:677

  collectUnknownNodeKeys(raw, id, `Node '${id}'`, warnings);
  collectGateAndLoopDeprecationWarnings(node, raw, id, warnings);

  // `with:` is live on an agent node's command-sourced form (node-local bindings,
  // #2637), on exec (script-runtime only), and on include/workflow (caller inputs).
  // On every other node type Zod strips it silently — surface that through the
  // parse-warnings channel (#2213) so an author learns the binding never attached,
  // without rejecting YAML that loaded fine before.
  const hasWithSupport =
    isIncludeDirective(node) ||
    isWorkflowNode(node) ||
    isComposeFanOutNode(node) ||
    (isExecNode(node) && node.runtime !== 'sh') ||
    (isAgentNode(node) && node.source.kind === 'command');
  if ((raw as Record<string, unknown>).with !== undefined && !hasWithSupport) {
    warnings.push(
      `Node '${id}': 'with' is only supported on command, script, include, and workflow nodes — it is ignored here`
    );
    getLog().warn({ id: node.id }, 'node_with_ignored');
  }

  // Warn about AI-specific fields on non-AI nodes (runtime behavior, not schema errors)
  let nonAiNode: { type: string; fields: readonly string[] } | undefined;
  if (isIncludeDirective(node)) {
    nonAiNode = { type: 'include', fields: INCLUDE_NODE_IGNORED_FIELDS };
  } else if (isComposeFanOutNode(node)) {
    // Same execution-less posture as a static include: the composed body's own nodes
    // carry their config, so AI-level fields declared here are ignored (#2512).
    nonAiNode = { type: 'include', fields: INCLUDE_NODE_IGNORED_FIELDS };
  } else if (isHaltNode(node)) {
    nonAiNode = { type: 'cancel', fields: GATE_AND_HALT_IGNORED_FIELDS };
  } else if (isWorkflowNode(node)) {
    nonAiNode = { type: 'workflow', fields: WORKFLOW_NODE_IGNORED_FIELDS };
  } else if (isGateNode(node)) {
    nonAiNode = { type: 'approval', fields: GATE_AND_HALT_IGNORED_FIELDS };
  } else if (isWaitNode(node)) {
    nonAiNode = { type: 'wait', fields: WAIT_NODE_IGNORED_FIELDS };

View on GitHub (pinned to 0773b97458)

Solutions

Move the `with:` block to a supported node (command-sourced agent, script exec node with runtime set, include, or workflow node)
For exec nodes, set the node's runtime away from 'sh' if you intended a script node that accepts `with:`
If the target agent should receive inputs, switch it to source.kind 'command' where node-local bindings apply
Remove the `with:` key if the bindings were never actually needed

Example fix

# before
- id: summarize
  agent: writer
  with:
    topic: release-notes
# after
- id: summarize
  agent: writer
  source:
    kind: command
  with:
    topic: release-notes

Defensive patterns

Strategy: validation

Validate before calling

const WITH_SUPPORTED = new Set(['include', 'workflow', 'compose_fan_out']);
function nodeSupportsWith(node) {
  if (WITH_SUPPORTED.has(node.type)) return true;
  if (node.type === 'exec') return node.runtime !== undefined && node.runtime !== 'sh';
  if (node.type === 'agent') return node.source?.kind === 'command';
  return false;
}
// assert nodeSupportsWith(node) for every node carrying `with:` before load

Type guard

function hasWithSupport(node) {
  return ('type' in node) && (['include','workflow','compose_fan_out'].includes(node.type) ||
    (node.type === 'exec' && node.runtime !== 'sh') ||
    (node.type === 'agent' && node.source?.kind === 'command'));
}

Prevention

Only attach `with:` to command/script/include/workflow nodes
For sh exec nodes, set an explicit non-sh runtime before adding `with:`
Capture and fail CI on loader parse warnings, not just load errors
When copy-pasting node templates, re-check which fields the target node type honors

When it happens

Trigger: Parsing a workflow YAML that sets `with:` on any node other than include/workflow/compose-fan-out nodes, exec nodes with runtime != 'sh', or agent nodes whose source.kind is 'command' — e.g. a plain prompt/agent node, a sh-runtime exec node, a gate, halt, or bash command node.

Common situations: Copy-pasting a `with:` block from a script node onto a prompt agent node; adding inputs to an exec node left at the default sh runtime; adding `with:` to a gate or halt node; assuming `with` is universal node syntax.

Related errors

AI-assisted analysis of coleam00/Archon@0773b97458 (2026-09-01). Data as JSON: /api/errors/940d95085793d92e. Report an issue: GitHub.