@exellix/graph-engine 6.0.0

package/dist/src/runtime/memory.js

@@ -0,0 +1,250 @@
+import { LogicEngine } from '@x12i/graphenix';
+import { selectByPath, writeByPath } from './pathExpr.js';
+/**
+ * Resolves a mapping path reference to its actual value using Graphenix LogicEngine.
+ *
+ * Supports:
+ * - Literals: "\"Asset\"" -> "Asset"
+ * - Node paths: "node.X" (with inputs/data/metadata hierarchy)
+ * - Output paths: "output.X"
+ * - Variables: "variables.X"
+ * - Job Memory: "jobMemory.X"
+ *
+ * @param path - Path reference string
+ * @param context - Context object
+ * @returns Resolved value or undefined
+ */
+function resolveMappingPath(path, context) {
+    const { node, output, jobMemory, variables } = context;
+    // Map authoring-style paths to Graphenix `$` resolution where needed
+    let normalizedPath = path;
+    // If no prefix and not a literal, we try to be smart or just use it as is
+    // Graphenix resolveValue handles literals (starts with " or \")
+    // For variables/node/state, we prepend $ to use Graphenix resolution
+    if (!path.startsWith('"') && !path.startsWith('\\"') && !path.startsWith('$')) {
+        if (path.startsWith('node.')) {
+            normalizedPath = '$' + path;
+        }
+        else if (path.startsWith('output.')) {
+            normalizedPath = '$state.' + path.substring(7);
+        }
+        else if (path.startsWith('variables.')) {
+            normalizedPath = '$' + path.substring(10);
+        }
+        else if (path.startsWith('jobMemory.')) {
+            normalizedPath = '$memory.' + path.substring(10);
+        }
+        else {
+            // Shorthand: try output (state), then variables, then node
+            // We can't easily do this with a single resolveValue call in Graphenix
+            // so we try them sequentially
+            const resOutput = LogicEngine.resolveValue('$state.' + path, output, { state: output, variables: undefined, history: [], outputs: { byKey: {}, byNodeId: {} }, nodeStatus: {} });
+            if (resOutput !== undefined)
+                return resOutput;
+            const resVar = LogicEngine.resolveValue('$' + path, output, { state: output, variables: undefined, history: [], outputs: { byKey: {}, byNodeId: {} }, nodeStatus: {} });
+            if (resVar !== undefined)
+                return resVar;
+            const resNode = LogicEngine.resolveValue('$node.' + path, output, { state: output, variables: undefined, history: [], outputs: { byKey: {}, byNodeId: {} }, nodeStatus: {}, node: node });
+            if (resNode !== undefined)
+                return resNode;
+            return undefined;
+        }
+    }
+    // Build Graphenix ExecutionContext
+    const graphenixContext = {
+        state: output,
+        variables: variables || {},
+        history: [], // Not needed for simple value resolution
+        outputs: { byKey: {}, byNodeId: {} },
+        nodeStatus: {},
+        memory: jobMemory, // Pass jobMemory as history/memory
+        node: node
+    };
+    return LogicEngine.resolveValue(normalizedPath, output, graphenixContext);
+}
+/**
+ * Creates a mapped object from a map configuration.
+ * Uses pathExpr (selectByPath) for paths containing [*], {*}, or starting with executionMemory./jobMemory.;
+ * otherwise uses Graphenix resolveMappingPath for node.X, output.X, variables.X.
+ */
+export function createMappedObject(map, context) {
+    const result = {};
+    const usePathExprRoot = context.executionMemory !== undefined || context.jobMemory !== undefined;
+    const executionMem = context.executionMemory;
+    const selectionRoot = usePathExprRoot
+        ? {
+            executionMemory: context.executionMemory,
+            jobMemory: context.jobMemory,
+            variables: executionMem != null && typeof executionMem.jobVariables === 'object'
+                ? executionMem.jobVariables
+                : executionMem != null && typeof executionMem.variables === 'object'
+                    ? executionMem.variables
+                    : context.variables,
+            jobVariables: executionMem != null && typeof executionMem.jobVariables === 'object'
+                ? executionMem.jobVariables
+                : undefined,
+            taskVariables: executionMem != null && typeof executionMem.taskVariables === 'object'
+                ? executionMem.taskVariables
+                : undefined,
+            node: context.node,
+        }
+        : null;
+    for (const [targetKey, sourcePath] of Object.entries(map)) {
+        let value;
+        if (selectionRoot &&
+            (sourcePath.includes('[*]') ||
+                sourcePath.includes('{*}') ||
+                sourcePath.startsWith('executionMemory.') ||
+                sourcePath.startsWith('jobMemory.') ||
+                sourcePath.startsWith('jobVariables.') ||
+                sourcePath.startsWith('taskVariables.'))) {
+            value = selectByPath(selectionRoot, sourcePath);
+        }
+        else {
+            value = resolveMappingPath(sourcePath, context);
+        }
+        if (value !== undefined) {
+            result[targetKey] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Merges memory from job and node sources.
+ */
+export function mergeMemory(options) {
+    const { jobMemory: baseJobMemory, taskMemory: baseTaskMemory, node } = options;
+    let finalJobMemory = baseJobMemory;
+    let finalTaskMemory = baseTaskMemory;
+    if (node?.memory) {
+        if (node.memory.jobMemory !== undefined) {
+            finalJobMemory = node.memory.jobMemory;
+        }
+        if (node.memory.taskMemory !== undefined) {
+            finalTaskMemory = node.memory.taskMemory;
+        }
+    }
+    return {
+        jobMemory: finalJobMemory,
+        taskMemory: finalTaskMemory,
+    };
+}
+/**
+ * Merges output into execution object based on mapping configuration.
+ * Uses writeByPath for target path (supports nested paths, creates missing objects).
+ * Resolves map sources via selectByPath on { output, node, variables } with fallback to Graphenix.
+ */
+export function mergeExecutionObject(execution, path, output, mode, mappingConfig, context) {
+    // Start with a clean copy of the execution object
+    const result = execution ? JSON.parse(JSON.stringify(execution)) : {};
+    // Determine value to merge
+    let valueToMerge;
+    if (mappingConfig?.map) {
+        const outputRoot = { output, node: context?.node, variables: context?.variables };
+        valueToMerge = {};
+        for (const [targetKey, sourcePath] of Object.entries(mappingConfig.map)) {
+            let val = selectByPath(outputRoot, sourcePath);
+            if (val === undefined) {
+                val = resolveMappingPath(sourcePath, {
+                    node: context?.node,
+                    output,
+                    variables: context?.variables,
+                });
+            }
+            if (val !== undefined)
+                valueToMerge[targetKey] = val;
+        }
+    }
+    else if (mappingConfig?.fields) {
+        valueToMerge = {};
+        for (const field of mappingConfig.fields) {
+            const val = LogicEngine.resolveValue('$state.' + field, output, { state: output, variables: undefined, history: [], outputs: { byKey: {}, byNodeId: {} }, nodeStatus: {} });
+            if (val !== undefined)
+                valueToMerge[field] = val;
+        }
+    }
+    else {
+        valueToMerge = output;
+    }
+    const effectiveMode = mode ?? 'replace';
+    writeByPath(result, path, valueToMerge, effectiveMode);
+    return result;
+}
+/**
+ * Merges execution object into jobMemory so it appears in workingMemory.
+ */
+export function mergeExecutionIntoMemory(jobMemory, execution) {
+    if (execution === null || execution === undefined) {
+        return jobMemory;
+    }
+    // Use LogicEngine for the merge operation
+    const state = jobMemory ? JSON.parse(JSON.stringify(jobMemory)) : {};
+    const assignment = {
+        name: 'execution',
+        value: execution,
+        operation: 'merge'
+    };
+    LogicEngine.applyAssignment(assignment, state, { state: state, variables: state, history: [], outputs: { byKey: {}, byNodeId: {} }, nodeStatus: {} });
+    return state;
+}
+/**
+ * Builds a semantic memory key for a node result.
+ */
+export function buildMemoryKey(node) {
+    if (node.data?.memoryKey)
+        return node.data.memoryKey;
+    if (node.taskConfiguration?.memoryKey)
+        return node.taskConfiguration.memoryKey;
+    const name = node.data?.name || node.metadata?.name;
+    if (name) {
+        return name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+    }
+    return node.id;
+}
+/**
+ * Accumulates a node execution result into jobMemory.
+ */
+export function accumulateNodeResult(currentMemory, node, result) {
+    const jobMemory = currentMemory ? JSON.parse(JSON.stringify(currentMemory)) : {};
+    const memoryKey = buildMemoryKey(node);
+    const nodeMemoryEntry = {
+        nodeId: node.id,
+        skillKey: result.skillKey,
+        status: result.success ? 'completed' : 'failed',
+        timestamp: new Date().toISOString(),
+        metadata: {
+            nodeName: node.data?.name || node.metadata?.name || node.id,
+            nodeType: node.type,
+        },
+    };
+    if (result.success) {
+        nodeMemoryEntry.result = result.output;
+        if (result.metadata?.executionTime) {
+            nodeMemoryEntry.executionTime = result.metadata.executionTime;
+        }
+    }
+    else {
+        nodeMemoryEntry.error = {
+            code: result.error?.code,
+            message: result.error?.message,
+            diagnostics: result.error?.diagnostics,
+        };
+    }
+    jobMemory[memoryKey] = nodeMemoryEntry;
+    jobMemory[`_nodes.${node.id}`] = nodeMemoryEntry;
+    return jobMemory;
+}
+/** Copy selected execution fields when target omits them (e.g. webContext from response.executionMemory). */
+export function copyExecutionContextFields(targetExecution, sourceExecution, fields) {
+    if (targetExecution == null || typeof targetExecution !== 'object')
+        return;
+    if (sourceExecution == null || typeof sourceExecution !== 'object')
+        return;
+    const target = targetExecution;
+    const source = sourceExecution;
+    for (const field of fields) {
+        if (target[field] === undefined && source[field] !== undefined) {
+            target[field] = source[field];
+        }
+    }
+}

package/dist/src/runtime/mergeExellixGraphRuntimeInvocation.d.ts

@@ -0,0 +1,18 @@
+import type { HostExecuteGraphRunOptions } from '../types/options.js';
+/**
+ * Constructor-side options for {@link createExellixGraphRuntime} used when merging per-call input.
+ * Single canonical default in 5.x: `failFast` defaults to **false** on every entry (input → opts → false).
+ */
+export type ExellixGraphRuntimeMergeOpts = HostExecuteGraphRunOptions;
+/**
+ * Merges per-invocation graph-run knobs with runtime constructor defaults for injected execution.
+ *
+ * **Precedence:** each field uses `inputField ?? optsField ?? default`. `failFast` defaults to **false**
+ * (the legacy "different defaults per entry" rule was removed in 5.x).
+ *
+ * **Pipeline / node:** graph-level `executionPipeline` from this merge is passed as the run override;
+ * node metadata and `execution.executionPipeline` still win inside `executeNode`.
+ */
+export declare function mergeExellixGraphRuntimeInvocation(input: HostExecuteGraphRunOptions, opts: ExellixGraphRuntimeMergeOpts): HostExecuteGraphRunOptions & {
+    failFast: boolean;
+};

package/dist/src/runtime/mergeExellixGraphRuntimeInvocation.js

@@ -0,0 +1,32 @@
+/**
+ * Merges per-invocation graph-run knobs with runtime constructor defaults for injected execution.
+ *
+ * **Precedence:** each field uses `inputField ?? optsField ?? default`. `failFast` defaults to **false**
+ * (the legacy "different defaults per entry" rule was removed in 5.x).
+ *
+ * **Pipeline / node:** graph-level `executionPipeline` from this merge is passed as the run override;
+ * node metadata and `execution.executionPipeline` still win inside `executeNode`.
+ */
+export function mergeExellixGraphRuntimeInvocation(input, opts) {
+    return {
+        failFast: input.failFast ?? opts.failFast ?? false,
+        skillKeyResolution: input.skillKeyResolution ?? opts.skillKeyResolution,
+        nodeTimeoutMs: input.nodeTimeoutMs ?? opts.nodeTimeoutMs,
+        executionPipeline: input.executionPipeline ?? opts.executionPipeline,
+        playgroundMeta: input.playgroundMeta ?? opts.playgroundMeta,
+        clearSynthesizedContextPerNode: input.clearSynthesizedContextPerNode ?? opts.clearSynthesizedContextPerNode,
+        modelConfig: input.modelConfig ?? opts.modelConfig,
+        aliasConfig: input.aliasConfig ?? opts.aliasConfig,
+        nodes: input.nodes ?? opts.nodes,
+        llmCall: input.llmCall ?? opts.llmCall,
+        runTaskIdentity: input.runTaskIdentity ?? opts.runTaskIdentity,
+        runTaskExecutionMode: input.runTaskExecutionMode ?? opts.runTaskExecutionMode,
+        runLogMode: input.runLogMode ?? opts.runLogMode,
+        maxRunLogEntries: input.maxRunLogEntries ?? opts.maxRunLogEntries,
+        maxRunLogDataJsonChars: input.maxRunLogDataJsonChars ?? opts.maxRunLogDataJsonChars,
+        runTaskDiagnostics: input.runTaskDiagnostics ?? opts.runTaskDiagnostics,
+        runtimeObjects: input.runtimeObjects ?? opts.runtimeObjects,
+        stepRetryPolicy: input.stepRetryPolicy ?? opts.stepRetryPolicy,
+        mainReadinessPolicy: input.mainReadinessPolicy ?? opts.mainReadinessPolicy,
+    };
+}

package/dist/src/runtime/modelConfigSelection.d.ts

@@ -0,0 +1,7 @@
+import type { GraphAiModelConfig, ModelConfigCase, ModelConfigSelection, TaskNodeConditionWhen } from '../types/refs.js';
+export declare function isGraphAiModelConfig(value: unknown): value is GraphAiModelConfig;
+export declare function isEmptyConditionWhen(when: TaskNodeConditionWhen | undefined): boolean;
+export declare function isModelConfigSelection(value: unknown): value is ModelConfigSelection;
+/** Stable hash key for duplicate-when detection. */
+export declare function conditionWhenSignature(when: TaskNodeConditionWhen): string;
+export declare function countDefaultModelConfigCases(cases: ModelConfigCase[]): number;

package/dist/src/runtime/modelConfigSelection.js

@@ -0,0 +1,37 @@
+export function isGraphAiModelConfig(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const o = value;
+    const keys = Object.keys(o);
+    return (keys.length === 2 &&
+        keys.includes('xynthesisModel') &&
+        keys.includes('skillModel') &&
+        typeof o.xynthesisModel === 'string' &&
+        o.xynthesisModel.trim() !== '' &&
+        typeof o.skillModel === 'string' &&
+        o.skillModel.trim() !== '');
+}
+export function isEmptyConditionWhen(when) {
+    if (when == null)
+        return true;
+    if (typeof when !== 'object' || Array.isArray(when))
+        return false;
+    const keys = Object.keys(when);
+    if (keys.length === 0)
+        return true;
+    return (when.jsonConditions == null &&
+        when.jsConditionFunction == null &&
+        when.aiCondition == null);
+}
+export function isModelConfigSelection(value) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    return Array.isArray(value.cases);
+}
+/** Stable hash key for duplicate-when detection. */
+export function conditionWhenSignature(when) {
+    return JSON.stringify(when);
+}
+export function countDefaultModelConfigCases(cases) {
+    return cases.filter((c) => isEmptyConditionWhen(c.when)).length;
+}

package/dist/src/runtime/narrixIngestEnv.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Package-level Narrix ingest flag semantics:
+ * - default enabled
+ * - DISABLE_NARRIX_INGEST=1 disables
+ *
+ * Upstream ai-tasks currently uses USE_NARRIX_INGEST. This helper maps the new
+ * semantic into the legacy flag before ai-tasks module initialization.
+ */
+export declare function applyNarrixIngestEnvDefault(): void;

package/dist/src/runtime/narrixIngestEnv.js

@@ -0,0 +1,18 @@
+/**
+ * Package-level Narrix ingest flag semantics:
+ * - default enabled
+ * - DISABLE_NARRIX_INGEST=1 disables
+ *
+ * Upstream ai-tasks currently uses USE_NARRIX_INGEST. This helper maps the new
+ * semantic into the legacy flag before ai-tasks module initialization.
+ */
+export function applyNarrixIngestEnvDefault() {
+    const disabled = process.env.DISABLE_NARRIX_INGEST === '1';
+    if (disabled) {
+        process.env.USE_NARRIX_INGEST = '0';
+        return;
+    }
+    if (process.env.USE_NARRIX_INGEST == null) {
+        process.env.USE_NARRIX_INGEST = '1';
+    }
+}

package/dist/src/runtime/pathExpr.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Minimal path expression parser for graph mapping.
+ * Supports: dot paths (a.b.c), array wildcard (name[*]), object-values (name{*}).
+ * No full JSONPath; deterministic and minimal.
+ */
+export type PathSegment = {
+    kind: 'prop';
+    name: string;
+} | {
+    kind: 'arrayWildcard';
+    name: string;
+} | {
+    kind: 'objectValues';
+    name: string;
+};
+/**
+ * Splits path by '.' and parses each segment.
+ * - name -> { kind: 'prop', name }
+ * - name[*] -> { kind: 'arrayWildcard', name }
+ * - name{*} -> { kind: 'objectValues', name }
+ */
+export declare function parsePath(pathExpr: string): PathSegment[];
+/**
+ * Select value(s) at pathExpr from root.
+ * - Dot path: single value (or undefined).
+ * - [*]: flattens to array of values (one per array element).
+ * - {*}: flattens to array of object values (deterministic key order).
+ * Returns undefined if any step is missing.
+ */
+export declare function selectByPath(root: any, pathExpr: string): any;
+/**
+ * Write value at pathExpr into root. Creates missing objects along the path.
+ * Path must not contain [*] or {*} for write.
+ * mode: replace = set; merge = object spread; append = array push.
+ */
+export declare function writeByPath(root: any, pathExpr: string, value: any, mode: 'replace' | 'merge' | 'append'): void;

package/dist/src/runtime/pathExpr.js

@@ -0,0 +1,131 @@
+/**
+ * Minimal path expression parser for graph mapping.
+ * Supports: dot paths (a.b.c), array wildcard (name[*]), object-values (name{*}).
+ * No full JSONPath; deterministic and minimal.
+ */
+/**
+ * Splits path by '.' and parses each segment.
+ * - name -> { kind: 'prop', name }
+ * - name[*] -> { kind: 'arrayWildcard', name }
+ * - name{*} -> { kind: 'objectValues', name }
+ */
+export function parsePath(pathExpr) {
+    if (!pathExpr || typeof pathExpr !== 'string')
+        return [];
+    const parts = pathExpr.split('.');
+    const segments = [];
+    for (const part of parts) {
+        const t = part.trim();
+        if (!t)
+            continue;
+        if (t.endsWith('[*]')) {
+            segments.push({ kind: 'arrayWildcard', name: t.slice(0, -3) });
+        }
+        else if (t.endsWith('{*}')) {
+            segments.push({ kind: 'objectValues', name: t.slice(0, -3) });
+        }
+        else {
+            segments.push({ kind: 'prop', name: t });
+        }
+    }
+    return segments;
+}
+/**
+ * Select value(s) at pathExpr from root.
+ * - Dot path: single value (or undefined).
+ * - [*]: flattens to array of values (one per array element).
+ * - {*}: flattens to array of object values (deterministic key order).
+ * Returns undefined if any step is missing.
+ */
+export function selectByPath(root, pathExpr) {
+    const segments = parsePath(pathExpr);
+    if (segments.length === 0)
+        return root;
+    let current = [root];
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        const next = [];
+        for (const c of current) {
+            if (c === undefined || c === null)
+                continue;
+            if (seg.kind === 'prop') {
+                next.push(c[seg.name]);
+            }
+            else if (seg.kind === 'arrayWildcard') {
+                const arr = c[seg.name];
+                if (!Array.isArray(arr))
+                    continue;
+                for (const item of arr)
+                    next.push(item);
+            }
+            else if (seg.kind === 'objectValues') {
+                const obj = c[seg.name];
+                if (obj === null || typeof obj !== 'object' || Array.isArray(obj))
+                    continue;
+                const keys = Object.keys(obj).sort();
+                for (const k of keys)
+                    next.push(obj[k]);
+            }
+        }
+        current = next;
+        if (current.length === 0)
+            return undefined;
+    }
+    if (current.length === 0)
+        return undefined;
+    const hasExpand = segments.some(s => s.kind === 'arrayWildcard' || s.kind === 'objectValues');
+    if (hasExpand)
+        return current;
+    return current[0];
+}
+/**
+ * Write value at pathExpr into root. Creates missing objects along the path.
+ * Path must not contain [*] or {*} for write.
+ * mode: replace = set; merge = object spread; append = array push.
+ */
+export function writeByPath(root, pathExpr, value, mode) {
+    const segments = parsePath(pathExpr);
+    if (segments.length === 0)
+        return;
+    const hasExpand = segments.some(s => s.kind === 'arrayWildcard' || s.kind === 'objectValues');
+    if (hasExpand)
+        return; // write only supports simple paths
+    let current = root;
+    if (current === undefined || current === null)
+        return;
+    for (let i = 0; i < segments.length - 1; i++) {
+        const seg = segments[i];
+        if (seg.kind !== 'prop')
+            return;
+        const key = seg.name;
+        if (current[key] === undefined || current[key] === null) {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    const last = segments[segments.length - 1];
+    if (last.kind !== 'prop')
+        return;
+    const lastKey = last.name;
+    if (mode === 'replace') {
+        current[lastKey] = value;
+    }
+    else if (mode === 'merge') {
+        const existing = current[lastKey];
+        if (existing !== null && typeof existing === 'object' && !Array.isArray(existing) && typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            current[lastKey] = { ...existing, ...value };
+        }
+        else {
+            current[lastKey] = value;
+        }
+    }
+    else if (mode === 'append') {
+        const arr = current[lastKey];
+        if (!Array.isArray(arr)) {
+            current[lastKey] = [value];
+        }
+        else {
+            arr.push(value);
+        }
+    }
+}

package/dist/src/runtime/predicates.d.ts

@@ -0,0 +1,14 @@
+import type { GraphPredicate } from '../types/refs.js';
+export type PredicateEvalContext = {
+    executionMemory?: unknown;
+    variables?: Record<string, unknown> | undefined;
+    jobMemory?: unknown;
+    taskMemory?: unknown;
+};
+/**
+ * Evaluate a graph predicate deterministically.
+ *
+ * - `undefined` predicate is treated as `true` (edge active).
+ * - Invalid predicate shapes evaluate to `false` (edge inactive).
+ */
+export declare function evaluateGraphPredicate(predicate: GraphPredicate | undefined, ctx: PredicateEvalContext): boolean;

package/dist/src/runtime/predicates.js

@@ -0,0 +1,86 @@
+function getByDotPath(root, path) {
+    if (!path)
+        return undefined;
+    const parts = path.split('.').filter(Boolean);
+    let cur = root;
+    for (const p of parts) {
+        if (cur == null)
+            return undefined;
+        if (typeof cur !== 'object')
+            return undefined;
+        cur = cur[p];
+    }
+    return cur;
+}
+function resolvePath(ctx, fullPath) {
+    // Supported roots: executionMemory, variables, jobMemory, taskMemory, input, xynthesized
+    if (!fullPath)
+        return undefined;
+    const [rootKey, ...rest] = fullPath.split('.');
+    const tail = rest.join('.');
+    switch (rootKey) {
+        case 'executionMemory':
+            return tail ? getByDotPath(ctx.executionMemory, tail) : ctx.executionMemory;
+        case 'variables':
+        case 'jobVariables':
+            return tail
+                ? getByDotPath(ctx.executionMemory, `jobVariables.${tail}`)
+                : getByDotPath(ctx.executionMemory, 'jobVariables');
+        case 'taskVariables':
+            return tail
+                ? getByDotPath(ctx.executionMemory, `taskVariables.${tail}`)
+                : getByDotPath(ctx.executionMemory, 'taskVariables');
+        case 'jobMemory':
+            return tail ? getByDotPath(ctx.jobMemory, tail) : ctx.jobMemory;
+        case 'taskMemory':
+            return tail ? getByDotPath(ctx.taskMemory, tail) : ctx.taskMemory;
+        case 'input':
+            return tail ? getByDotPath(ctx.executionMemory, `input.${tail}`) : getByDotPath(ctx.executionMemory, 'input');
+        case 'xynthesized':
+            return tail ? getByDotPath(ctx.executionMemory, `xynthesized.${tail}`) : getByDotPath(ctx.executionMemory, 'xynthesized');
+        default:
+            return undefined;
+    }
+}
+/**
+ * Evaluate a graph predicate deterministically.
+ *
+ * - `undefined` predicate is treated as `true` (edge active).
+ * - Invalid predicate shapes evaluate to `false` (edge inactive).
+ */
+export function evaluateGraphPredicate(predicate, ctx) {
+    if (predicate == null)
+        return true;
+    if (typeof predicate !== 'object')
+        return false;
+    if ('all' in predicate) {
+        const items = predicate.all;
+        if (!Array.isArray(items))
+            return false;
+        return items.every((p) => evaluateGraphPredicate(p, ctx));
+    }
+    if ('any' in predicate) {
+        const items = predicate.any;
+        if (!Array.isArray(items))
+            return false;
+        return items.some((p) => evaluateGraphPredicate(p, ctx));
+    }
+    if ('not' in predicate) {
+        return !evaluateGraphPredicate(predicate.not, ctx);
+    }
+    if ('path' in predicate && typeof predicate.path === 'string') {
+        const v = resolvePath(ctx, predicate.path);
+        if (predicate.exists !== undefined) {
+            if (typeof predicate.exists !== 'boolean')
+                return false;
+            const exists = v !== undefined && v !== null;
+            return predicate.exists ? exists : !exists;
+        }
+        if (predicate.eq !== undefined) {
+            return v === predicate.eq;
+        }
+        // If no operator was specified, treat as invalid.
+        return false;
+    }
+    return false;
+}

package/dist/src/runtime/readTaskNodeInputsConfig.d.ts

@@ -0,0 +1,23 @@
+import type { TaskNode } from '../types/refs.js';
+export type TaskNodeInputsConfigCarrier = TaskNode & {
+    /** Runtime payload bindings (`executionMemoryPath`); canonical task-node field. */
+    inputsConfig?: Record<string, unknown>;
+    /** @deprecated Prefer `inputsConfig`. */
+    inputBindings?: Record<string, unknown>;
+    /**
+     * @deprecated Prefer `inputsConfig` — collides with `runtime.inputs` (caller bag)
+     * and `RunTaskRequest.inputs` on the wire.
+     */
+    inputs?: Record<string, unknown>;
+};
+/**
+ * Reads a task node's runtime binding recipe with backward-compatible fallbacks.
+ * Finalizers use `FinalizerNode.inputs` directly; this helper is for task nodes only.
+ */
+export declare function readTaskNodeInputsConfig(node: TaskNode): Record<string, unknown>;
+/**
+ * Model surface for graph.response selectors (`nodeInputsConfig` / legacy `nodeInputs`):
+ * runtime bindings plus `taskVariable` (taskVariable wins on key collision).
+ */
+export declare function readTaskNodeModelInputSurface(node: TaskNode): Record<string, unknown>;
+export declare function isNodeInputsConfigSelectorType(type: string): boolean;