@exellix/graph-engine 6.0.0

package/dist/src/runtime/readTaskNodeInputsConfig.js

@@ -0,0 +1,27 @@
+/**
+ * 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 function readTaskNodeInputsConfig(node) {
+    const n = node;
+    const recipe = n.inputsConfig ?? n.inputBindings ?? n.inputs;
+    if (recipe != null && typeof recipe === 'object' && !Array.isArray(recipe)) {
+        return recipe;
+    }
+    return {};
+}
+/**
+ * Model surface for graph.response selectors (`nodeInputsConfig` / legacy `nodeInputs`):
+ * runtime bindings plus `taskVariable` (taskVariable wins on key collision).
+ */
+export function readTaskNodeModelInputSurface(node) {
+    const bindings = readTaskNodeInputsConfig(node);
+    const taskVariable = node.taskVariable;
+    if (taskVariable != null && typeof taskVariable === 'object' && !Array.isArray(taskVariable)) {
+        return { ...bindings, ...taskVariable };
+    }
+    return bindings;
+}
+export function isNodeInputsConfigSelectorType(type) {
+    return type === 'nodeInputsConfig' || type === 'nodeInputs';
+}

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

@@ -0,0 +1,11 @@
+import type { TaskNode } from '../types/refs.js';
+import type { ExecutionStepOption } from '../types/options.js';
+/**
+ * Resolves the effective execution pipeline for a task node, including `taskConfiguration.aiTaskProfile.inputSynthesis`
+ * bridge and INPUT_SYNTHESIS_PIPELINE_CONFLICT rules (GE-007 / GE-008).
+ */
+export declare function resolveExecutionPipelineForTaskNode(args: {
+    node: TaskNode;
+    optionsExecutionPipeline?: ExecutionStepOption[];
+    executionExecutionPipeline?: unknown;
+}): ExecutionStepOption[];

package/dist/src/runtime/resolveExecutionPipelineForTaskNode.js

@@ -0,0 +1,93 @@
+function isPlainObject(v) {
+    return v != null && typeof v === 'object' && !Array.isArray(v);
+}
+function pipelineError(code, message) {
+    const e = new Error(message);
+    e.code = code;
+    return e;
+}
+function findPreSynthesizedContextIndex(pipeline) {
+    return pipeline.findIndex((s) => s.phase === 'pre' && s.type === 'synthesized-context');
+}
+function uniqStrings(paths) {
+    return [...new Set(paths.map((p) => p.trim()).filter(Boolean))];
+}
+function buildInputSynthesisPreConfig(synth) {
+    const sources = Array.isArray(synth.sources) ? synth.sources : [];
+    return {
+        contextSourcePolicy: 'memory-only',
+        memoryPaths: sources.map((p) => String(p).trim()).filter(Boolean),
+        autoEnableContext: true,
+        xynthesizedOutput: {
+            destination: synth.destination,
+            outputKey: synth.outputKey,
+            mode: synth.mode ?? 'merge',
+        },
+    };
+}
+function mergeSynthConfigs(params) {
+    const { existing, fromAuthoring } = params;
+    const pol = existing.contextSourcePolicy;
+    if (pol != null && pol !== 'memory-only') {
+        throw pipelineError('INPUT_SYNTHESIS_PIPELINE_CONFLICT', `Existing PRE synthesized-context uses contextSourcePolicy "${String(pol)}"; inputSynthesis requires memory-only`);
+    }
+    const existingPaths = Array.isArray(existing.memoryPaths)
+        ? existing.memoryPaths.filter((x) => typeof x === 'string')
+        : [];
+    const newPaths = fromAuthoring.memoryPaths;
+    const mergedPaths = uniqStrings([...existingPaths, ...newPaths]);
+    const xOutExisting = isPlainObject(existing.xynthesizedOutput) ? existing.xynthesizedOutput : null;
+    const xOutNew = fromAuthoring.xynthesizedOutput;
+    if (xOutExisting != null && Object.keys(xOutExisting).length > 0) {
+        if (xOutExisting.destination !== xOutNew.destination || xOutExisting.outputKey !== xOutNew.outputKey) {
+            throw pipelineError('INPUT_SYNTHESIS_PIPELINE_CONFLICT', 'Existing PRE synthesized-context xynthesizedOutput conflicts with taskConfiguration.aiTaskProfile.inputSynthesis');
+        }
+    }
+    return {
+        ...existing,
+        ...fromAuthoring,
+        contextSourcePolicy: 'memory-only',
+        memoryPaths: mergedPaths,
+        xynthesizedOutput: {
+            ...(xOutExisting ?? {}),
+            ...xOutNew,
+        },
+    };
+}
+/**
+ * Resolves the effective execution pipeline for a task node, including `taskConfiguration.aiTaskProfile.inputSynthesis`
+ * bridge and INPUT_SYNTHESIS_PIPELINE_CONFLICT rules (GE-007 / GE-008).
+ */
+export function resolveExecutionPipelineForTaskNode(args) {
+    const { node } = args;
+    const synthRaw = node.taskConfiguration?.aiTaskProfile?.inputSynthesis;
+    const synthEnabled = synthRaw?.enabled === true;
+    const authorPipelineRaw = args.optionsExecutionPipeline ??
+        node.executionPipeline ??
+        args.executionExecutionPipeline ??
+        null;
+    const authorPipeline = authorPipelineRaw != null && Array.isArray(authorPipelineRaw)
+        ? [...authorPipelineRaw]
+        : null;
+    if (!synthEnabled) {
+        if (authorPipeline != null && authorPipeline.length > 0)
+            return authorPipeline;
+        return [{ phase: 'main', type: 'direct' }];
+    }
+    const synth = synthRaw;
+    const preFromAuthoring = buildInputSynthesisPreConfig(synth);
+    if (authorPipeline != null && authorPipeline.length > 0) {
+        // assertCanonicalGraphDocument already rejects manual PRE synthesized-context steps when
+        // inputSynthesis is enabled, so reaching this branch means the author authored a non-PRE pipeline.
+        // Inject the engine-built PRE synthesized-context at the front.
+        const idx = findPreSynthesizedContextIndex(authorPipeline);
+        if (idx >= 0) {
+            throw pipelineError('INPUT_SYNTHESIS_PIPELINE_CONFLICT', 'inputSynthesis.enabled is true but executionPipeline already has a PRE synthesized-context step');
+        }
+        return [{ phase: 'pre', type: 'synthesized-context', config: preFromAuthoring }, ...authorPipeline];
+    }
+    return [
+        { phase: 'pre', type: 'synthesized-context', config: preFromAuthoring },
+        { phase: 'main', type: 'direct' },
+    ];
+}

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

@@ -0,0 +1,63 @@
+/**
+ * Caller / graph-entry `inputs` bag only (not merged with MAIN `input`).
+ */
+export declare function extractCallerInputsBag(args: {
+    execution?: Record<string, unknown>;
+    jobMemory?: Record<string, unknown>;
+    extraLayers?: Array<Record<string, unknown> | undefined>;
+}): Record<string, unknown> | undefined;
+/**
+ * MAIN `RunTaskRequest.input` bucket: runtime MAIN object layers plus materialized node
+ * binding keys only. Does **not** merge the caller `inputs` bag (see {@link extractCallerInputsBag}).
+ */
+export declare function buildRunTaskMainInput(args: {
+    nodeBindings?: Record<string, unknown>;
+    execution?: Record<string, unknown>;
+    jobMemory?: Record<string, unknown>;
+    extraLayers?: Array<Record<string, unknown> | undefined>;
+}): Record<string, unknown>;
+export type GraphEngineMemoryResolutionRoot = {
+    /** MAIN bucket (`RunTaskRequest.input`). */
+    input: Record<string, unknown>;
+    /** Caller bag (`RunTaskRequest.inputs`). */
+    inputs: Record<string, unknown>;
+    /** Job / graph run template variables (`execution.jobVariables`). */
+    jobVariables?: Record<string, unknown>;
+    /** Task/node-scoped template variables (`execution.taskVariables`). */
+    taskVariables?: Record<string, unknown>;
+    jobMemory?: Record<string, unknown>;
+    taskMemory?: Record<string, unknown>;
+    executionMemory?: Record<string, unknown>;
+    xynthesized?: {
+        job: Record<string, unknown>;
+        task: Record<string, unknown>;
+        execution: Record<string, unknown>;
+    };
+};
+/**
+ * Builds a resolution root for {@link resolveGraphEngineMemoryPathValue} from outbound runTask fields.
+ */
+export declare function buildGraphEngineMemoryResolutionRoot(args: {
+    input: Record<string, unknown>;
+    inputs?: Record<string, unknown>;
+    jobVariables?: Record<string, unknown>;
+    taskVariables?: Record<string, unknown>;
+    jobMemory?: unknown;
+    taskMemory?: unknown;
+    executionMemory?: Record<string, unknown>;
+    xynthesized?: {
+        job: Record<string, unknown>;
+        task: Record<string, unknown>;
+        execution?: Record<string, unknown>;
+    };
+}): GraphEngineMemoryResolutionRoot;
+/**
+ * Flat graphs-studio / host `workingMemory` object.
+ */
+export declare function buildGraphEngineMemoryResolutionRootFromWorkingMemory(workingMemory: Record<string, unknown>, opts?: {
+    nodeId?: string;
+}): GraphEngineMemoryResolutionRoot;
+/**
+ * Resolves a memory path against distinct roots (`input.*` and `inputs.*` do not cross-fallback).
+ */
+export declare function resolveGraphEngineMemoryPathValue(root: GraphEngineMemoryResolutionRoot, path: string): unknown;

package/dist/src/runtime/resolveGraphEngineMemoryPaths.js

@@ -0,0 +1,213 @@
+/**
+ * Resolves graph-engine smart-input / input-synthesis memory paths against RunTask-shaped
+ * or working-memory-shaped roots (`input`, `inputs`, etc.).
+ */
+import { splitGraphEngineMemoryPath } from './graphEngineMemoryPaths.js';
+import { selectByPath } from './pathExpr.js';
+function isPlainObject(v) {
+    return v != null && typeof v === 'object' && !Array.isArray(v);
+}
+function readInputsBag(container) {
+    if (!container)
+        return undefined;
+    const bag = container.inputs;
+    return isPlainObject(bag) ? bag : undefined;
+}
+function readInputObjectLayer(container) {
+    if (!container)
+        return undefined;
+    return isPlainObject(container.input) ? container.input : undefined;
+}
+/** MAIN `input` merge layer — omits `input.raw` (PRE synthesis container, not a model field). */
+function readMainInputObjectLayer(container) {
+    const layer = readInputObjectLayer(container);
+    if (!layer)
+        return undefined;
+    const { raw: _raw, ...rest } = layer;
+    return Object.keys(rest).length > 0 ? rest : undefined;
+}
+/**
+ * Caller / graph-entry `inputs` bag only (not merged with MAIN `input`).
+ */
+export function extractCallerInputsBag(args) {
+    const layers = [
+        readInputsBag(args.jobMemory),
+        readInputsBag(args.execution),
+        ...(args.extraLayers ?? []).flatMap((wm) => (wm ? [readInputsBag(wm)] : [])),
+    ];
+    const out = {};
+    for (const layer of layers) {
+        if (layer)
+            Object.assign(out, layer);
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+/**
+ * MAIN `RunTaskRequest.input` bucket: runtime MAIN object layers plus materialized node
+ * binding keys only. Does **not** merge the caller `inputs` bag (see {@link extractCallerInputsBag}).
+ */
+export function buildRunTaskMainInput(args) {
+    const layers = [
+        readMainInputObjectLayer(args.jobMemory),
+        readMainInputObjectLayer(args.execution),
+        ...(args.extraLayers ?? []).flatMap((wm) => (wm ? [readMainInputObjectLayer(wm)] : [])),
+        args.nodeBindings,
+    ];
+    const out = {};
+    for (const layer of layers) {
+        if (layer)
+            Object.assign(out, layer);
+    }
+    return out;
+}
+function resolveXynthesizedSubpath(xy, subRoot, tail) {
+    if (!xy)
+        return undefined;
+    if (subRoot === 'xynthesized.job') {
+        const job = xy.job;
+        return tail ? selectByPath(job, tail) : job;
+    }
+    if (subRoot === 'xynthesized.execution') {
+        const executionBucket = xy.execution;
+        return tail ? selectByPath(executionBucket, tail) : executionBucket;
+    }
+    const task = xy.task;
+    return tail ? selectByPath(task, tail) : task;
+}
+function resolveInputSubpath(root, tail) {
+    if (!tail)
+        return root.input;
+    return selectByPath(root.input, tail);
+}
+function resolveInputsSubpath(root, tail) {
+    if (!tail)
+        return root.inputs;
+    return selectByPath(root.inputs, tail);
+}
+/**
+ * Builds a resolution root for {@link resolveGraphEngineMemoryPathValue} from outbound runTask fields.
+ */
+export function buildGraphEngineMemoryResolutionRoot(args) {
+    const inputs = args.inputs ?? {};
+    const executionMemory = args.executionMemory;
+    const xy = args.xynthesized;
+    const jobVariables = isPlainObject(args.jobVariables)
+        ? args.jobVariables
+        : isPlainObject(executionMemory?.jobVariables)
+            ? executionMemory.jobVariables
+            : isPlainObject(executionMemory?.variables)
+                ? executionMemory.variables
+                : undefined;
+    const taskVariables = isPlainObject(args.taskVariables)
+        ? args.taskVariables
+        : isPlainObject(executionMemory?.taskVariables)
+            ? executionMemory.taskVariables
+            : undefined;
+    return {
+        input: args.input,
+        inputs,
+        jobVariables,
+        taskVariables,
+        jobMemory: isPlainObject(args.jobMemory) ? args.jobMemory : undefined,
+        taskMemory: isPlainObject(args.taskMemory) ? args.taskMemory : undefined,
+        executionMemory,
+        xynthesized: xy
+            ? {
+                job: xy.job,
+                task: xy.task,
+                execution: xy.execution ?? {},
+            }
+            : undefined,
+    };
+}
+/**
+ * Flat graphs-studio / host `workingMemory` object.
+ */
+export function buildGraphEngineMemoryResolutionRootFromWorkingMemory(workingMemory, opts) {
+    const execution = isPlainObject(workingMemory.execution)
+        ? workingMemory.execution
+        : undefined;
+    const inputs = extractCallerInputsBag({
+        execution,
+        jobMemory: isPlainObject(workingMemory.jobMemory) ? workingMemory.jobMemory : undefined,
+        extraLayers: [workingMemory],
+    }) ?? {};
+    const input = buildRunTaskMainInput({
+        execution,
+        jobMemory: isPlainObject(workingMemory.jobMemory) ? workingMemory.jobMemory : undefined,
+        extraLayers: [workingMemory],
+        nodeBindings: isPlainObject(workingMemory.taskInput) ? workingMemory.taskInput : undefined,
+    });
+    const wmXy = isPlainObject(workingMemory.xynthesized) ? workingMemory.xynthesized : undefined;
+    const exXy = isPlainObject(execution?.xynthesized) ? execution.xynthesized : undefined;
+    const xySource = wmXy ?? exXy;
+    const job = (isPlainObject(xySource?.job) ? xySource.job : undefined) ??
+        (isPlainObject(exXy?.job) ? exXy.job : undefined) ??
+        {};
+    const nodeId = opts?.nodeId;
+    let task = {};
+    if (isPlainObject(xySource?.task)) {
+        task = xySource.task;
+    }
+    else if (nodeId && isPlainObject(xySource?.taskByNode)) {
+        const bucket = (xySource.taskByNode)[nodeId];
+        task = isPlainObject(bucket) ? bucket : {};
+    }
+    const executionBucket = (isPlainObject(xySource?.execution) ? xySource.execution : undefined) ??
+        (isPlainObject(exXy?.execution) ? exXy.execution : undefined) ??
+        {};
+    return buildGraphEngineMemoryResolutionRoot({
+        input,
+        inputs,
+        jobVariables: isPlainObject(execution?.jobVariables)
+            ? execution.jobVariables
+            : isPlainObject(execution?.variables)
+                ? execution.variables
+                : isPlainObject(workingMemory.variables)
+                    ? workingMemory.variables
+                    : undefined,
+        taskVariables: isPlainObject(execution?.taskVariables) ? execution.taskVariables : undefined,
+        jobMemory: workingMemory.jobMemory,
+        taskMemory: workingMemory.taskMemory,
+        executionMemory: execution,
+        xynthesized: {
+            job: job,
+            task,
+            execution: executionBucket,
+        },
+    });
+}
+/**
+ * Resolves a memory path against distinct roots (`input.*` and `inputs.*` do not cross-fallback).
+ */
+export function resolveGraphEngineMemoryPathValue(root, path) {
+    const trimmed = typeof path === 'string' ? path.trim() : '';
+    if (!trimmed)
+        return undefined;
+    const { root: rootKey, tail } = splitGraphEngineMemoryPath(trimmed);
+    switch (rootKey) {
+        case 'input':
+            return resolveInputSubpath(root, tail);
+        case 'inputs':
+            return resolveInputsSubpath(root, tail);
+        case 'xynthesized.job':
+            return resolveXynthesizedSubpath(root.xynthesized, 'xynthesized.job', tail);
+        case 'xynthesized.task':
+            return resolveXynthesizedSubpath(root.xynthesized, 'xynthesized.task', tail);
+        case 'xynthesized.execution':
+            return resolveXynthesizedSubpath(root.xynthesized, 'xynthesized.execution', tail);
+        case 'variables':
+        case 'jobVariables':
+            return tail ? selectByPath(root.jobVariables, tail) : root.jobVariables;
+        case 'taskVariables':
+            return tail ? selectByPath(root.taskVariables, tail) : root.taskVariables;
+        case 'jobMemory':
+            return tail ? selectByPath(root.jobMemory, tail) : root.jobMemory;
+        case 'taskMemory':
+            return tail ? selectByPath(root.taskMemory, tail) : root.taskMemory;
+        case 'executionMemory':
+            return tail ? selectByPath(root.executionMemory, tail) : root.executionMemory;
+        default:
+            return undefined;
+    }
+}

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

@@ -0,0 +1,20 @@
+import type { RunxClient } from '@x12i/runx';
+import type { GraphAiModelConfig, GraphModelAliasConfig, ModelConfigSelection, TaskNodeRuntimeObject } from '../types/refs.js';
+import { conditionWhenSignature, isEmptyConditionWhen } from './modelConfigSelection.js';
+import { type TaskNodeConditionEvalContext } from './taskNodeConditionsEvaluation.js';
+export type ResolveModelConfigForNodeArgs = {
+    runtimeNodeConfig?: TaskNodeRuntimeObject;
+    nodeModelConfig?: unknown;
+    runtimeModelConfig?: ModelConfigSelection;
+    graphModelConfig?: ModelConfigSelection;
+    runtimeAliasConfig?: GraphModelAliasConfig;
+    conditionCtx: TaskNodeConditionEvalContext;
+    executionInput: Record<string, unknown>;
+    runx?: RunxClient;
+};
+export declare function resolveGraphAiModelConfigAliases(modelConfig: GraphAiModelConfig | undefined, aliasConfig: GraphModelAliasConfig | undefined): GraphAiModelConfig | undefined;
+/**
+ * Resolves effective model config for a task node (precedence + conditional cases + aliases).
+ */
+export declare function resolveModelConfigForNode(args: ResolveModelConfigForNodeArgs): Promise<GraphAiModelConfig | undefined>;
+export { conditionWhenSignature, isEmptyConditionWhen };

package/dist/src/runtime/resolveModelConfigForNode.js

@@ -0,0 +1,69 @@
+import { conditionWhenSignature, isEmptyConditionWhen, isGraphAiModelConfig, isModelConfigSelection, } from './modelConfigSelection.js';
+import { evaluateConditionWhen } from './taskNodeConditionsEvaluation.js';
+function resolveModelAlias(modelOrAlias, aliases) {
+    return aliases?.[modelOrAlias] ?? modelOrAlias;
+}
+function mergeAliasConfigs(root, node) {
+    if (root == null && node == null)
+        return undefined;
+    return { ...(root ?? {}), ...(node ?? {}) };
+}
+export function resolveGraphAiModelConfigAliases(modelConfig, aliasConfig) {
+    if (!isGraphAiModelConfig(modelConfig))
+        return undefined;
+    return {
+        xynthesisModel: resolveModelAlias(modelConfig.xynthesisModel, aliasConfig),
+        skillModel: resolveModelAlias(modelConfig.skillModel, aliasConfig),
+    };
+}
+async function selectFromCases(selection, ctx, executionInput, runx) {
+    const cases = selection.cases;
+    if (!Array.isArray(cases) || cases.length === 0)
+        return undefined;
+    let defaultCase;
+    for (const c of cases) {
+        if (isEmptyConditionWhen(c.when)) {
+            defaultCase = c;
+            continue;
+        }
+        if (c.when == null)
+            continue;
+        const ev = await evaluateConditionWhen(c.when, ctx, executionInput, { runx });
+        if (ev.error)
+            continue;
+        if (ev.ok && isGraphAiModelConfig(c.modelConfig)) {
+            return c.modelConfig;
+        }
+    }
+    if (defaultCase != null && isGraphAiModelConfig(defaultCase.modelConfig)) {
+        return defaultCase.modelConfig;
+    }
+    return undefined;
+}
+async function resolveTier(value, ctx, executionInput, runx) {
+    if (isGraphAiModelConfig(value))
+        return value;
+    if (isModelConfigSelection(value)) {
+        return selectFromCases(value, ctx, executionInput, runx);
+    }
+    return undefined;
+}
+/**
+ * Resolves effective model config for a task node (precedence + conditional cases + aliases).
+ */
+export async function resolveModelConfigForNode(args) {
+    const aliasConfig = mergeAliasConfigs(args.runtimeAliasConfig, args.runtimeNodeConfig?.aliasConfig);
+    const staticHost = args.runtimeNodeConfig?.modelConfig;
+    if (isGraphAiModelConfig(staticHost)) {
+        return resolveGraphAiModelConfigAliases(staticHost, aliasConfig);
+    }
+    const tiers = [args.nodeModelConfig, args.runtimeModelConfig, args.graphModelConfig];
+    for (const tier of tiers) {
+        const selected = await resolveTier(tier, args.conditionCtx, args.executionInput, args.runx);
+        if (selected != null) {
+            return resolveGraphAiModelConfigAliases(selected, aliasConfig);
+        }
+    }
+    return undefined;
+}
+export { conditionWhenSignature, isEmptyConditionWhen };

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

@@ -0,0 +1,14 @@
+import type { NarrixPreProcessorConfig, ResolvedNarrixWirePayload } from '../types/narrix.js';
+import type { AiTaskProfileMetadata } from '../types/aiTaskProfile.js';
+/**
+ * Resolves outbound `RunTaskRequest.narrix`: starts from node taskConfiguration (authoring shape, no web fields),
+ * shallow-merges graph-level `variables.narrix` discovery fields, then derives web-scope fields from
+ * `taskConfiguration.aiTaskProfile.webScoping` via {@link applyAiTaskProfileWebScopingToNarrix}.
+ *
+ * Shared by {@link ExellixGraphRuntime}.
+ */
+export declare function resolveNarrixForTaskNode(args: {
+    nodeMetadataNarrix: NarrixPreProcessorConfig | undefined;
+    graphVariablesNarrix: Partial<NarrixPreProcessorConfig> | undefined;
+    aiTaskProfile: AiTaskProfileMetadata | undefined;
+}): ResolvedNarrixWirePayload | undefined;

package/dist/src/runtime/resolveNarrixForTaskNode.js

@@ -0,0 +1,19 @@
+import { applyAiTaskProfileWebScopingToNarrix } from './applyAiTaskProfileWebScopingToNarrix.js';
+/**
+ * Resolves outbound `RunTaskRequest.narrix`: starts from node taskConfiguration (authoring shape, no web fields),
+ * shallow-merges graph-level `variables.narrix` discovery fields, then derives web-scope fields from
+ * `taskConfiguration.aiTaskProfile.webScoping` via {@link applyAiTaskProfileWebScopingToNarrix}.
+ *
+ * Shared by {@link ExellixGraphRuntime}.
+ */
+export function resolveNarrixForTaskNode(args) {
+    let resolved = args.nodeMetadataNarrix != null ? { ...args.nodeMetadataNarrix } : undefined;
+    const graphNarrix = args.graphVariablesNarrix;
+    if (graphNarrix) {
+        resolved = {
+            ...graphNarrix,
+            ...(resolved ?? {}),
+        };
+    }
+    return applyAiTaskProfileWebScopingToNarrix(resolved, args.aiTaskProfile);
+}

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

@@ -0,0 +1,11 @@
+import { GraphNode } from '../types/refs.js';
+import { SkillKeyResolutionOptions } from '../types/options.js';
+/**
+ * Resolves skillKey from a node. 5.x reads only the canonical `node.skillKey`.
+ * Legacy aliases on `node.data.skillKey` / `node.metadata.skillKey` are rejected
+ * by `assertCanonicalGraphDocument` before execution.
+ */
+export declare function resolveTaskKey(node: GraphNode, options?: SkillKeyResolutionOptions, context?: {
+    jobId?: string;
+    graphId?: string;
+}): string;

package/dist/src/runtime/resolveTaskKey.js

@@ -0,0 +1,28 @@
+import { ExellixGraphError } from '../errors/ExellixGraphError.js';
+import { ExellixGraphErrorCode } from '../errors/exellixGraphErrorCodes.js';
+/**
+ * Resolves skillKey from a node. 5.x reads only the canonical `node.skillKey`.
+ * Legacy aliases on `node.data.skillKey` / `node.metadata.skillKey` are rejected
+ * by `assertCanonicalGraphDocument` before execution.
+ */
+export function resolveTaskKey(node, options = {}, context) {
+    const { allowFallbackToNodeId = false, fallbackPrefix = 'tasks/', aliases = {}, } = options;
+    if (node.skillKey) {
+        return applyAlias(node.skillKey, aliases);
+    }
+    if (allowFallbackToNodeId) {
+        return `${fallbackPrefix}${node.id}`;
+    }
+    throw new ExellixGraphError(ExellixGraphErrorCode.NODE_SKILLKEY_MISSING, `Node ${node.id} does not specify a skillKey. Set node.skillKey in graph JSON.`, {
+        jobId: context?.jobId,
+        graphId: context?.graphId,
+        nodeId: node.id,
+        nodeType: node.type,
+    });
+}
+/**
+ * Applies alias mapping if present
+ */
+function applyAlias(skillKey, aliases) {
+    return aliases[skillKey] || skillKey;
+}

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

@@ -0,0 +1,25 @@
+import type { TaskNode } from '../types/refs.js';
+import { type ExecutionVariableBuckets } from './executionVariableBuckets.js';
+/**
+ * Resolves `node.taskVariable` into concrete values for `RunTaskRequest.input`.
+ * `$path` refs resolve against the matching execution bucket only (no cross-bucket merge).
+ */
+export declare function resolveTaskNodeTaskVariableForRunTask(args: {
+    node: TaskNode;
+    buckets: ExecutionVariableBuckets;
+}): Record<string, unknown>;
+/**
+ * Resolves runtime payload bindings from `node.inputsConfig` only (plus deprecated aliases).
+ */
+export declare function resolveTaskNodeInputBindingsForRunTask(args: {
+    node: TaskNode;
+    execution: Record<string, unknown>;
+}): Record<string, unknown>;
+/**
+ * Resolves task-node model input for MAIN `RunTaskRequest.input`:
+ * `taskVariable` plus execution-memory bindings (separate buckets, no merge).
+ */
+export declare function resolveTaskNodeInputsForRunTask(args: {
+    node: TaskNode;
+    execution: Record<string, unknown>;
+}): Record<string, unknown>;