@exellix/graph-engine 7.5.1 → 7.7.0

package/dist/src/errors/exellixGraphErrorCodes.d.ts

@@ -13,6 +13,8 @@ export declare enum ExellixGraphErrorCode {
     INVALID_GRAPH = "INVALID_GRAPH",
     /** Graph JSON has forbidden top-level keys; document metadata must be under `metadata` only. */
     NON_CANONICAL_GRAPH_DOCUMENT = "NON_CANONICAL_GRAPH_DOCUMENT",
+    /** Runtime object carries forbidden model / llmCall overrides (graph document only since 7.7). */
+    NON_CANONICAL_GRAPH_RUNTIME = "NON_CANONICAL_GRAPH_RUNTIME",
     /**
      * A task node uses a legacy authoring alias that 5.x rejects at load time.
      * Examples: `node.data.skillKey`, `node.metadata.skillKey`, `node.data.variables`,

package/dist/src/errors/exellixGraphErrorCodes.js

@@ -14,6 +14,8 @@ export var ExellixGraphErrorCode;
     ExellixGraphErrorCode["INVALID_GRAPH"] = "INVALID_GRAPH";
     /** Graph JSON has forbidden top-level keys; document metadata must be under `metadata` only. */
     ExellixGraphErrorCode["NON_CANONICAL_GRAPH_DOCUMENT"] = "NON_CANONICAL_GRAPH_DOCUMENT";
+    /** Runtime object carries forbidden model / llmCall overrides (graph document only since 7.7). */
+    ExellixGraphErrorCode["NON_CANONICAL_GRAPH_RUNTIME"] = "NON_CANONICAL_GRAPH_RUNTIME";
     /**
      * A task node uses a legacy authoring alias that 5.x rejects at load time.
      * Examples: `node.data.skillKey`, `node.metadata.skillKey`, `node.data.variables`,

package/dist/src/index.d.ts

@@ -39,7 +39,7 @@ export type { PathSegment } from './runtime/pathExpr.js';
 export { evaluateStructuredDataFilters, evaluateDataFilterPredicate, getStructuredDataFilterPathViolations, isStructuredDataFiltersV1, } from './runtime/dataFiltersEvaluation.js';
 export { evaluateTaskNodeConditions, evaluateConditionWhen, applyConditionNegate, } from './runtime/taskNodeConditionsEvaluation.js';
 export type { TaskNodeConditionsEvalDeps, TaskNodeConditionsEvalResult, TaskNodeConditionEvalContext, } from './runtime/taskNodeConditionsEvaluation.js';
-export { resolveModelConfigForNode, resolveGraphAiModelConfig, toRunTaskModelConfigForPhase, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './runtime/resolveModelConfigForNode.js';
+export { resolveModelConfigForNode, resolveGraphAiModelConfig, toRunTaskModelConfig, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './runtime/resolveModelConfigForNode.js';
 export { looksLikeConcreteModelId, isGraphAiProfileName, assertGraphAiProfileNameString, type RunTaskModelConfigWire, type EngineModelPhase, } from './runtime/graphAiModelConfig.js';
 /** @deprecated Use {@link resolveGraphAiModelConfig}. */
 export { resolveGraphAiModelConfig as resolveGraphAiModelConfigAliases } from './runtime/graphAiModelConfig.js';
@@ -73,12 +73,13 @@ export { runTaskResponseSucceeded } from './runtime/runTaskResponse.js';
 export { buildTaskNodeRunTaskRequest, validateTaskNodeRunTaskConfig, validateTaskNodeRunTaskInvoke, analyzeTaskNodeRunTaskRequest, } from './runtime/taskNodeRunTaskPreflight.js';
 export type { BuildTaskNodeRunTaskRequestArgs, BuildTaskNodeRunTaskRequestResult, TaskNodeRunTaskPreflightSkipReason, ValidateTaskNodeRunTaskConfigArgs, ValidateTaskNodeRunTaskConfigResult, ValidateTaskNodeRunTaskInvokeArgs, ValidateTaskNodeRunTaskInvokeResult, AnalyzeTaskNodeRunTaskRequestArgs, AnalyzeTaskNodeRunTaskRequestResult, } from './runtime/taskNodeRunTaskPreflight.js';
 /** Re-exported from `@exellix/ai-tasks` — preflight validation and analysis without `runTask`. */
-export { validateRunTaskConfig, validateRunTaskInvoke, analyzeExpectedRunTaskInput, checkExpectedInputAgainstRequest, collectSmartInputValidationIssues, buildRunTaskValidationContext, analyzeRunTaskRequest, validateParsedOutput, analyzeSkillRequest, buildSkillRequestAnalysisPacket, formatSkillRequestAnalysisMarkdown, listTokens, analyzeTemplateResolution, renderSmartInput, extractTokenNamesFromStrings, getSkillTokens, getSkillContent, } from '@exellix/ai-tasks';
+export { validateRunTaskConfig, validateRunTaskInvoke, analyzeExpectedRunTaskInput, checkExpectedInputAgainstRequest, collectSmartInputValidationIssues, buildRunTaskValidationContext, analyzeRunTaskRequest, validateParsedOutput, buildSkillRequestAnalysisPacket, formatSkillRequestAnalysisMarkdown, listTokens, analyzeTemplateResolution, renderSmartInput, extractTokenNamesFromStrings, getSkillTokens, getSkillContent, } from '@exellix/ai-tasks';
 export type { RunTaskValidationIssue, RunTaskValidationResult, RunTaskInvokeValidationResult, ExpectedRunTaskInputPath, AnalyzeExpectedRunTaskInputResult, ValidateRunTaskInvokeParams, RunTaskTemplateResolver, AnalyzeRunTaskRequestOptions, AnalyzeRunTaskRequestResult, AnalyzeSkillRequestOptions, AnalyzeSkillRequestResult, SkillRequestAnalysisReport, OutputValidationResult, } from '@exellix/ai-tasks';
 export { buildExellixGraphRuntimeObjects, setRuntimeObjectsLastJobId, summarizeRuntimeObjectsForPlayground, EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME, EXELLIX_AI_TASKS_PACKAGE_NAME, } from './runtime/runtimeObjects.js';
 export type { ActivixQueryableClient, LogxerQueryableClient, LogxerLogLine, PackageRuntimeObjects, RuntimeObjects, BuildExellixGraphRuntimeObjectsInput, RuntimeObjectsObservabilitySummary, } from './runtime/runtimeObjects.js';
 export type { GetJobLogsInput, GetJobLogsResult, QueryableLogLine } from '@x12i/logxer';
 export { assertCanonicalGraphDocument, assertCanonicalTaskNode, getCanonicalGraphDocumentViolations, CANONICAL_GRAPH_TOP_LEVEL_KEYS, } from './runtime/validateCanonicalGraphDocument.js';
+export { assertCanonicalGraphRuntimeObject } from './runtime/validateCanonicalGraphRuntime.js';
 export { GRAPH_ENTRY_STUDIO_ONLY_KEYS, GRAPH_METADATA_STUDIO_ONLY_KEYS, stripGraphModelStudioFields, primaryRuntimeInputFromStudioDocument, getGraphEntryStudioOnlyKeyViolations, getGraphMetadataStudioOnlyKeyViolations, getGraphEntryEmptyInputPathViolations, } from './runtime/graphModelStudioSeparation.js';
 export type { GraphStudioDocument } from './runtime/graphModelStudioSeparation.js';
 export { computeGraphDocumentContentSha256, stableStringifyGraphDocument, } from './runtime/graphDocumentFingerprint.js';

package/dist/src/index.js

@@ -29,7 +29,7 @@ export { mergeMemory } from './runtime/memory.js';
 export { selectByPath, writeByPath, parsePath } from './runtime/pathExpr.js';
 export { evaluateStructuredDataFilters, evaluateDataFilterPredicate, getStructuredDataFilterPathViolations, isStructuredDataFiltersV1, } from './runtime/dataFiltersEvaluation.js';
 export { evaluateTaskNodeConditions, evaluateConditionWhen, applyConditionNegate, } from './runtime/taskNodeConditionsEvaluation.js';
-export { resolveModelConfigForNode, resolveGraphAiModelConfig, toRunTaskModelConfigForPhase, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './runtime/resolveModelConfigForNode.js';
+export { resolveModelConfigForNode, resolveGraphAiModelConfig, toRunTaskModelConfig, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './runtime/resolveModelConfigForNode.js';
 export { looksLikeConcreteModelId, isGraphAiProfileName, assertGraphAiProfileNameString, } from './runtime/graphAiModelConfig.js';
 /** @deprecated Use {@link resolveGraphAiModelConfig}. */
 export { resolveGraphAiModelConfig as resolveGraphAiModelConfigAliases } from './runtime/graphAiModelConfig.js';
@@ -56,9 +56,10 @@ export { resolveNarrixForTaskNode } from './runtime/resolveNarrixForTaskNode.js'
 export { runTaskResponseSucceeded } from './runtime/runTaskResponse.js';
 export { buildTaskNodeRunTaskRequest, validateTaskNodeRunTaskConfig, validateTaskNodeRunTaskInvoke, analyzeTaskNodeRunTaskRequest, } from './runtime/taskNodeRunTaskPreflight.js';
 /** Re-exported from `@exellix/ai-tasks` — preflight validation and analysis without `runTask`. */
-export { validateRunTaskConfig, validateRunTaskInvoke, analyzeExpectedRunTaskInput, checkExpectedInputAgainstRequest, collectSmartInputValidationIssues, buildRunTaskValidationContext, analyzeRunTaskRequest, validateParsedOutput, analyzeSkillRequest, buildSkillRequestAnalysisPacket, formatSkillRequestAnalysisMarkdown, listTokens, analyzeTemplateResolution, renderSmartInput, extractTokenNamesFromStrings, getSkillTokens, getSkillContent, } from '@exellix/ai-tasks';
+export { validateRunTaskConfig, validateRunTaskInvoke, analyzeExpectedRunTaskInput, checkExpectedInputAgainstRequest, collectSmartInputValidationIssues, buildRunTaskValidationContext, analyzeRunTaskRequest, validateParsedOutput, buildSkillRequestAnalysisPacket, formatSkillRequestAnalysisMarkdown, listTokens, analyzeTemplateResolution, renderSmartInput, extractTokenNamesFromStrings, getSkillTokens, getSkillContent, } from '@exellix/ai-tasks';
 export { buildExellixGraphRuntimeObjects, setRuntimeObjectsLastJobId, summarizeRuntimeObjectsForPlayground, EXELLIX_GRAPH_RUNTIME_PACKAGE_NAME, EXELLIX_AI_TASKS_PACKAGE_NAME, } from './runtime/runtimeObjects.js';
 export { assertCanonicalGraphDocument, assertCanonicalTaskNode, getCanonicalGraphDocumentViolations, CANONICAL_GRAPH_TOP_LEVEL_KEYS, } from './runtime/validateCanonicalGraphDocument.js';
+export { assertCanonicalGraphRuntimeObject } from './runtime/validateCanonicalGraphRuntime.js';
 export { GRAPH_ENTRY_STUDIO_ONLY_KEYS, GRAPH_METADATA_STUDIO_ONLY_KEYS, stripGraphModelStudioFields, primaryRuntimeInputFromStudioDocument, getGraphEntryStudioOnlyKeyViolations, getGraphMetadataStudioOnlyKeyViolations, getGraphEntryEmptyInputPathViolations, } from './runtime/graphModelStudioSeparation.js';
 export { computeGraphDocumentContentSha256, stableStringifyGraphDocument, } from './runtime/graphDocumentFingerprint.js';
 export { migrateLegacyGraphResponse, migrateLegacyGraphResponseDefinition, } from './runtime/graphResponseMigration.js';

package/dist/src/inspection/graphModelSelection.d.ts

@@ -16,8 +16,8 @@ export type GraphModelSelectionInspection = {
     /** Graph-level default profile aliases (undefined when the graph declares none). */
     graphDefaultProfiles?: GraphAiModelConfig;
     nodes: NodeModelSelection[];
-    /** Distinct profile alias names referenced anywhere in the model (for `runtime.aliasConfig` wiring). */
-    aliasesUsed: string[];
+    /** Distinct profile alias names referenced anywhere in the graph model document. */
+    profileNamesUsed: string[];
 };
 /**
  * Static, runtime-free view of which model-profile aliases each node would use.
@@ -28,6 +28,6 @@ export type GraphModelSelectionInspection = {
  *
  * Only the unconditional (`when`-less) default case is reported per tier; `conditionalCaseCount`
  * flags nodes whose effective model may change at runtime via gated cases. Alias → concrete
- * provider id still happens at runtime through `runtime.aliasConfig`.
+ * provider id resolution happens inside `@exellix/ai-tasks`.
  */
 export declare function inspectGraphModelSelection(graph: Graph): GraphModelSelectionInspection;

package/dist/src/inspection/graphModelSelection.js

@@ -33,7 +33,7 @@ function finalizerUsesModel(node) {
  *
  * Only the unconditional (`when`-less) default case is reported per tier; `conditionalCaseCount`
  * flags nodes whose effective model may change at runtime via gated cases. Alias → concrete
- * provider id still happens at runtime through `runtime.aliasConfig`.
+ * provider id resolution happens inside `@exellix/ai-tasks`.
  */
 export function inspectGraphModelSelection(graph) {
     const graphDefaultProfiles = defaultCaseProfiles(graph.modelConfig);
@@ -103,6 +103,6 @@ export function inspectGraphModelSelection(graph) {
     return {
         graphDefaultProfiles,
         nodes,
-        aliasesUsed: [...aliases].sort(),
+        profileNamesUsed: [...aliases].sort(),
     };
 }

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

@@ -1,12 +1,11 @@
 import type { GraphEngineFactory } from "./GraphEngine.js";
 import type { ExecutionStep } from "@exellix/ai-tasks";
-import type { Graph, GraphModelObject, GraphNode, GraphAiModelConfig, GraphModelAliasConfig, TaskNodeRuntimeObject } from "../types/refs.js";
+import type { Graph, GraphModelObject, GraphNode, GraphAiModelConfig, TaskNodeRuntimeObject } from "../types/refs.js";
 import type { RunLogEntry } from "../types/runLog.js";
 import type { RunTaskDiagnostics } from "../types/options.js";
 import type { ExecutionStepOption, HostExecuteGraphRunOptions, SkillKeyResolutionOptions } from "../types/options.js";
 import type { PlaygroundReporter } from "../playground/PlaygroundReporter.js";
 import type { CreateRunxOptions, RunxClient } from "@x12i/runx";
-import type { ModelConfigSelection } from "../types/refs.js";
 import { type EventEmitter } from "./events.js";
 import type { NodeTraceEntry } from "../types/results.js";
 import type { ExecuteGraphStepResponse } from "../types/results.js";
@@ -89,15 +88,7 @@ export interface GraphRuntimeObject extends HostExecuteGraphRunOptions {
     jobVariables?: Record<string, unknown>;
     /** Task-scoped overrides for the active node → `executionMemory.taskVariables`. */
     taskVariables?: Record<string, unknown>;
-    /** Runtime default model selection (`cases`); overrides GraphModelObject.modelConfig. */
-    modelConfig?: ModelConfigSelection;
-    /** Profile aliases for xynthesis when runtime.modelConfig is host-resolved concrete ids. */
-    aiProfiles?: GraphAiModelConfig;
-    /**
-     * @deprecated Unused since 7.1 — profile aliases pass through to downstream resolution.
-     */
-    aliasConfig?: GraphModelAliasConfig;
-    /** Task-node runtime overrides keyed by node id. */
+    /** Task-node runtime bag keyed by node id (no model overrides since 7.7). */
     nodes?: Record<string, TaskNodeRuntimeObject>;
     mode?: "forward" | "backward" | "hybrid";
     goalNodeId?: string;
@@ -197,9 +188,8 @@ export declare function createExellixGraphRuntime(opts: ExellixGraphRuntimeOptio
     executeGraph: (input: ExecuteGraphInput) => Promise<ExecuteGraphResult>;
     executeNode: (input: {
         graphId: string;
+        /** Graph document for standalone {@link executeNode} — resolves {@link modelConfig} from the model when omitted. */
         graph?: Graph;
-        /** Same UUID for every `runTask` in this `executeGraph` invocation; omitted → new UUID per direct `executeNode` call. */
-        graphRunTaskId?: string;
         node: any;
         job: any;
         jobMemory?: any;
@@ -210,11 +200,10 @@ export declare function createExellixGraphRuntime(opts: ExellixGraphRuntimeOptio
         /** Per-node task-scope overrides → `executionMemory.taskVariables`. */
         taskVariables?: Record<string, unknown>;
         prevNodeId?: string;
-        /** Overrides graph-level / runtime default for this node only. */
+        /** Resolved graph model profiles; omitted when {@link graph} is supplied (resolved from the model document). */
         modelConfig?: GraphAiModelConfig;
-        /** Profile aliases for xynthesis PRE/POST when modelConfig is host-resolved concrete ids. */
-        aiProfiles?: GraphAiModelConfig;
-        llmCall?: Record<string, unknown>;
+        /** Same UUID for every `runTask` in this `executeGraph` invocation; omitted → new UUID per direct `executeNode` call. */
+        graphRunTaskId?: string;
         runTaskIdentity?: Record<string, unknown>;
         runTaskExecutionMode?: "default" | "trace";
         runTaskDiagnostics?: RunTaskDiagnostics;

package/dist/src/runtime/ExellixGraphRuntime.js

@@ -17,11 +17,12 @@ import { assertFinalizerRequiredReadsResolvable, validateGraphFinalizer, } from
 import { executeDeterministicFinalizer, executeSynthesizeFinalizer } from "./finalizers/executeFinalizer.js";
 import { createFinalizerError } from "./finalizers/errors.js";
 import { assertCanonicalGraphDocument } from "./validateCanonicalGraphDocument.js";
+import { assertCanonicalGraphRuntimeObject } from "./validateCanonicalGraphRuntime.js";
 import { applyGraphResponseDefinition } from "./graphResponseMapping.js";
 import { migrateLegacyGraphResponse } from "./graphResponseMigration.js";
 import { computeGraphDocumentContentSha256 } from "./graphDocumentFingerprint.js";
 import { buildAiTasksObservabilityRecord } from "./aiTasksObservability.js";
-import { buildRunTaskIdentityEnvelope, mergeDefinedLlmCallParts, shouldForwardRunTaskTraceMode, } from "./runTaskAugments.js";
+import { buildMainLlmCallForRunTask, buildRunTaskIdentityEnvelope, shouldForwardRunTaskTraceMode, } from "./runTaskAugments.js";
 import { buildRunLog, extractLogxerCorrelationFromMetadata, extractTaskRunLogFromMetadata, resolveRunLogLimits, } from "./buildRunLog.js";
 import { setRuntimeObjectsLastJobId, summarizeRuntimeObjectsForPlayground } from "./runtimeObjects.js";
 import { DebugLogAbstract, bindGraphEngineRunLogxer, clearGraphEngineRunLogxer, createGraphEngineLogxer, ensureGraphEngineLogxerOnRuntimeObjects, logGraphEngineErrorCode, patchGraphNodeLogContext, runGraphWithLogContext, traceExecutionMemory, } from "./graphEngineLogxer.js";
@@ -36,10 +37,13 @@ import { evaluateGraphPredicate } from "./predicates.js";
 import { evaluateStructuredDataFilters } from "./dataFiltersEvaluation.js";
 import { evaluateTaskNodeConditions } from "./taskNodeConditionsEvaluation.js";
 import { resolveModelConfigForNode } from "./resolveModelConfigForNode.js";
-import { toRunTaskModelConfigForPhase } from "./graphAiModelConfig.js";
+import { toRunTaskModelConfig } from "./graphAiModelConfig.js";
+import { isGraphAiModelConfig } from "./modelConfigSelection.js";
+import { createClient } from "@x12i/funcx";
 import { createRunx } from "@x12i/runx";
 import { selectByPath } from "./pathExpr.js";
 import { createGraphStartEvent, createGraphCompleteEvent, createGraphFailEvent, createNodeStartEvent, createNodeCompleteEvent, createNodeFailEvent, } from "./events.js";
+import { ExellixGraphError } from "../errors/ExellixGraphError.js";
 import { ExellixGraphErrorCode } from "../errors/exellixGraphErrorCodes.js";
 const NODE_LIFECYCLE_EMITTED = "__exellixNodeLifecycleEmitted";
 function skippedByConditionsOutput(skipReason) {
@@ -183,12 +187,6 @@ function mergeExecutionUpdate(current, next, base) {
     applyExecutionDelta(merged, next, isPlainRecord(base) ? base : {});
     return merged;
 }
-function readRuntimeNodeConfig(nodes, nodeId) {
-    if (nodes == null || typeof nodeId !== "string" || nodeId.length === 0)
-        return undefined;
-    const candidate = nodes[nodeId];
-    return isPlainRecord(candidate) ? candidate : undefined;
-}
 function taskNodeNeedsRunxClient(conditions) {
     return conditions?.jsConditionFunction != null || conditions?.aiCondition != null;
 }
@@ -197,9 +195,7 @@ function modelConfigSelectionNeedsRunx(sel) {
         return false;
     return sel.cases.some((c) => c.when?.jsConditionFunction != null || c.when?.aiCondition != null);
 }
-function graphNeedsRunxClient(graph, runtimeModelConfig) {
-    if (modelConfigSelectionNeedsRunx(runtimeModelConfig))
-        return true;
+function graphNeedsRunxClient(graph) {
     if (modelConfigSelectionNeedsRunx(graph.modelConfig))
         return true;
     for (const n of graph.nodes ?? []) {
@@ -339,7 +335,37 @@ export function createExellixGraphRuntime(opts) {
         const graphRunTaskId = input.graphRunTaskId ?? newGraphRunTaskId();
         const runTaskJobIdStr = String(input.job?.jobId ?? input.job?.id ?? "");
         const lifecycleJobId = runTaskJobIdStr || String(input.job?.jobId ?? input.job?.id ?? "standalone-job");
-        const effectiveLlmCall = mergeDefinedLlmCallParts((input.llmCall ?? opts.llmCall), input.node?.taskConfiguration?.llmCall);
+        let executionSeed = input.execution;
+        if (executionSeed == null || typeof executionSeed !== "object")
+            executionSeed = {};
+        const executionRecSeed = executionSeed;
+        const dataFiltersRecordSeed = isPlainRecord(executionRecSeed.input)
+            ? executionRecSeed.input
+            : {};
+        let effectiveModelConfig = input.modelConfig;
+        if (!isGraphAiModelConfig(effectiveModelConfig)) {
+            if (input.graph == null) {
+                throw new ExellixGraphError(ExellixGraphErrorCode.MODEL_CONFIG_INCOMPLETE, "executeNode requires modelConfig or graph for model resolution from the graph document", { graphId: input.graphId, nodeId: String(input.node?.id ?? "") });
+            }
+            effectiveModelConfig = await resolveModelConfigForNode({
+                nodeModelConfig: input.node?.taskConfiguration?.modelConfig,
+                graphModelConfig: input.graph.modelConfig,
+                conditionCtx: buildPredicateEvalContextForNode({
+                    executionMemory: executionRecSeed,
+                    jobMemory: input.jobMemory,
+                    taskMemory: input.taskMemory,
+                    node: input.node,
+                    runtimeTaskVariables: input.taskVariables,
+                }),
+                executionInput: dataFiltersRecordSeed,
+                runx: opts.runx,
+                graphId: input.graphId,
+                nodeId: String(input.node?.id ?? ""),
+                jobId: lifecycleJobId,
+            });
+        }
+        const wireModelConfig = toRunTaskModelConfig(effectiveModelConfig);
+        const effectiveLlmCall = buildMainLlmCallForRunTask(wireModelConfig, input.node?.taskConfiguration?.llmCall);
         const forwardRunTaskTrace = shouldForwardRunTaskTraceMode({
             runTaskExecutionMode: input.runTaskExecutionMode ?? opts.runTaskExecutionMode,
         });
@@ -394,12 +420,8 @@ export function createExellixGraphRuntime(opts) {
                                     : {}),
                                 kind: "finalizer",
                             },
-                            ...(input.modelConfig != null
-                                ? {
-                                    modelConfig: toRunTaskModelConfigForPhase(input.modelConfig, 'pre', input.aiProfiles),
-                                }
-                                : {}),
-                            ...(effectiveLlmCall != null ? { llmCall: effectiveLlmCall } : {}),
+                            modelConfig: wireModelConfig,
+                            llmCall: effectiveLlmCall,
                             ...(forwardRunTaskTrace ? { executionMode: "trace" } : {}),
                             ...((input.runTaskDiagnostics ?? opts.runTaskDiagnostics) != null
                                 ? { diagnostics: input.runTaskDiagnostics ?? opts.runTaskDiagnostics }
@@ -607,10 +629,6 @@ export function createExellixGraphRuntime(opts) {
         if (input.eventEmitter) {
             input.eventEmitter.emit(createNodeStartEvent(lifecycleJobId, input.graphId, graphRunTaskId, input.node, skillKey, undefined, input.jobCorrelation));
         }
-        const effectiveModelConfig = input.modelConfig;
-        const mainRunTaskModelConfig = effectiveModelConfig != null
-            ? toRunTaskModelConfigForPhase(effectiveModelConfig, 'main', input.aiProfiles)
-            : undefined;
         // DEBUG: Verify execution object before sending
         traceExecutionMemory('executeNode', 'Node execution object before runTask', {
             nodeId: input.node?.id,
@@ -720,8 +738,6 @@ export function createExellixGraphRuntime(opts) {
                 jobContext,
                 prevNodeId: input.prevNodeId,
                 modelConfig: effectiveModelConfig,
-                aiProfiles: input.aiProfiles,
-                llmCall: effectiveLlmCall,
                 runTaskIdentity: runTaskIdentityBase,
                 nodeTaskConfiguration: input.node?.taskConfiguration,
                 forwardRunTaskTrace,
@@ -840,7 +856,7 @@ export function createExellixGraphRuntime(opts) {
                 ? input.node.taskConfiguration.aiTasksOutputValidation
                 : undefined,
             diagnostics: (input.runTaskDiagnostics ?? opts.runTaskDiagnostics),
-            modelConfig: mainRunTaskModelConfig,
+            modelConfig: wireModelConfig,
             llmCall: effectiveLlmCall,
             identity: buildRunTaskIdentityEnvelope({
                 base: runTaskIdentityBase,
@@ -1022,8 +1038,6 @@ export function createExellixGraphRuntime(opts) {
                 jobContext,
                 prevNodeId: input.prevNodeId,
                 modelConfig: effectiveModelConfig,
-                aiProfiles: input.aiProfiles,
-                llmCall: effectiveLlmCall,
                 runTaskIdentity: runTaskIdentityBase,
                 nodeTaskConfiguration: input.node?.taskConfiguration,
                 forwardRunTaskTrace,
@@ -1162,15 +1176,21 @@ export function createExellixGraphRuntime(opts) {
             bindGraphEngineRunLogxer(runLogxer);
             try {
                 assertCanonicalGraphDocument(graph, { jobId, graphId: resolvedGraphId });
+                assertCanonicalGraphRuntimeObject(runtime, { jobId, graphId: resolvedGraphId });
                 let runxClient = opts.runx;
-                if (graphNeedsRunxClient(graph, merged.modelConfig)) {
+                if (graphNeedsRunxClient(graph)) {
                     if (!runxClient) {
                         if (!opts.runxCreateOptions) {
                             const err = new Error("RUNX_REQUIRED: graph uses jsConditionFunction, aiCondition, or conditional modelConfig cases that require runx. Pass runx or runxCreateOptions on createExellixGraphRuntime.");
                             err.code = "RUNX_REQUIRED";
                             throw err;
                         }
-                        runxClient = await createRunx(opts.runxCreateOptions);
+                        const runxOpts = {
+                            ...opts.runxCreateOptions,
+                            funcx: opts.runxCreateOptions.funcx ??
+                                createClient((opts.runxCreateOptions.funcxCreateOptions ?? {})),
+                        };
+                        runxClient = await createRunx(runxOpts);
                         await runxClient.bootstrap();
                         await runxClient.reload();
                     }
@@ -1582,11 +1602,8 @@ export function createExellixGraphRuntime(opts) {
                                 context: { model: graph, runtime, graphId: resolvedGraphId, jobId, taskId: graphTaskId, node: node },
                             });
                             const nodeTaskMemory = isPlainRecord(currentTaskMemory) ? { ...currentTaskMemory } : currentTaskMemory;
-                            const runtimeNodeConfig = readRuntimeNodeConfig(merged.nodes, typeof node.id === "string" ? node.id : undefined);
                             const effectiveModelConfig = await resolveModelConfigForNode({
-                                runtimeNodeConfig,
                                 nodeModelConfig: node.taskConfiguration?.modelConfig,
-                                runtimeModelConfig: merged.modelConfig,
                                 graphModelConfig: graph.modelConfig,
                                 conditionCtx: buildPredicateEvalContextForNode({
                                     executionMemory: currentExecution,
@@ -1616,8 +1633,6 @@ export function createExellixGraphRuntime(opts) {
                                 variables: runtime.variables,
                                 taskVariables: runtime.taskVariables,
                                 modelConfig: effectiveModelConfig,
-                                aiProfiles: merged.aiProfiles,
-                                llmCall: merged.llmCall,
                                 runTaskIdentity: merged.runTaskIdentity,
                                 runTaskExecutionMode: merged.runTaskExecutionMode,
                                 runTaskDiagnostics: merged.runTaskDiagnostics,

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

@@ -25,11 +25,8 @@ export type RunEngineAiTasksStrategyPhaseArgs = {
     taskMemory?: unknown;
     jobContext?: Record<string, unknown>;
     prevNodeId?: string;
-    /** Resolved three-phase config; routed to the correct ai-tasks slot for this strategy phase. */
-    modelConfig?: GraphAiModelConfig;
-    /** Profile aliases for xynthesis slots when modelConfig is host-resolved concrete ids. */
-    aiProfiles?: GraphAiModelConfig;
-    llmCall?: RunTaskRequest['llmCall'];
+    /** Resolved three-phase graph model config (required). */
+    modelConfig: GraphAiModelConfig;
     runTaskIdentity?: Record<string, unknown>;
     /** Task node `taskConfiguration` (identity envelope merge). */
     nodeTaskConfiguration?: Record<string, unknown>;

package/dist/src/runtime/aiTasksStrategyPhases.js

@@ -1,4 +1,4 @@
-import { toRunTaskModelConfigForPhase } from './graphAiModelConfig.js';
+import { toRunTaskModelConfig } from './graphAiModelConfig.js';
 import { buildAiTasksRunTaskRequest } from './buildAiTasksRunTaskRequest.js';
 import { buildRunTaskIdentityEnvelope } from './runTaskAugments.js';
 import { runTaskResponseSucceeded } from './runTaskResponse.js';
@@ -54,10 +54,7 @@ export async function runEngineAiTasksStrategyPhase(args) {
         prevNodeId: args.prevNodeId,
         executionPipeline: [{ phase: 'main', type: 'direct' }],
         executionStrategies: [],
-        modelConfig: args.modelConfig != null
-            ? toRunTaskModelConfigForPhase(args.modelConfig, args.phase, args.aiProfiles)
-            : undefined,
-        llmCall: args.llmCall ?? undefined,
+        modelConfig: toRunTaskModelConfig(args.modelConfig),
         identity,
         ...(args.forwardRunTaskTrace ? { executionMode: 'trace' } : {}),
         ...(args.runTaskDiagnostics != null && { diagnostics: args.runTaskDiagnostics }),

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

@@ -46,8 +46,8 @@ export type BuildAiTasksRunTaskRequestArgs = {
     narrix?: ResolvedNarrixWirePayload;
     outputValidation?: RunTaskRequest['outputValidation'];
     diagnostics?: RunTaskRequest['diagnostics'];
-    /** Resolved ai-tasks slot pair (`xynthesisModel` / `skillModel`) for this runTask phase. */
-    modelConfig?: RunTaskModelConfigWire;
+    /** Required on every `runTask` (@exellix/ai-tasks 8.4+). */
+    modelConfig: RunTaskModelConfigWire;
     llmCall?: LlmCallConfig;
     identity?: Record<string, unknown>;
     executionMode?: 'default' | 'trace';

package/dist/src/runtime/buildAiTasksRunTaskRequest.js

@@ -146,7 +146,7 @@ export function buildAiTasksRunTaskRequest(args) {
         ...(args.narrix != null ? { narrix: args.narrix } : {}),
         ...(args.outputValidation != null ? { outputValidation: args.outputValidation } : {}),
         ...(args.diagnostics != null ? { diagnostics: args.diagnostics } : {}),
-        ...(args.modelConfig != null ? { modelConfig: args.modelConfig } : {}),
+        modelConfig: args.modelConfig,
         ...(args.llmCall != null ? { llmCall: args.llmCall } : {}),
         ...(args.identity != null ? { identity: args.identity } : {}),
         ...(args.executionMode != null ? { executionMode: args.executionMode } : {}),

package/dist/src/runtime/canonicalModelUsed.js

@@ -18,8 +18,7 @@ export function resolveCanonicalModelUsed(response) {
                 rawConfig.model ??
                 rawConfig.skillModel ??
                 rawConfig.preActionModel ??
-                rawConfig.postActionModel ??
-                rawConfig.xynthesisModel;
+                rawConfig.postActionModel;
             if (typeof fromRaw === 'string' && fromRaw.trim() !== '')
                 return fromRaw.trim();
         }

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

@@ -1,8 +1,9 @@
 import type { GraphAiModelConfig } from '../types/refs.js';
-/** Wire shape expected by `@exellix/ai-tasks` `RunTaskRequest.modelConfig`. */
+/** Wire shape for `@exellix/ai-tasks` `RunTaskRequest.modelConfig` (8.4+). */
 export type RunTaskModelConfigWire = {
-    xynthesisModel: string;
+    preActionModel: string;
     skillModel: string;
+    postActionModel: string;
 };
 /** Profile alias names used when no modelConfig tier resolves. */
 export declare const DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG: GraphAiModelConfig;
@@ -28,17 +29,12 @@ export declare function looksLikeConcreteModelId(value: string): boolean;
 export declare function isGraphAiProfileName(value: unknown): value is string;
 export declare function assertGraphAiProfileNameString(value: unknown, path: string, context?: GraphAiModelConfigResolveContext): asserts value is string;
 /**
- * Validates and normalizes graph/runtime {@link GraphAiModelConfig}.
- * Profile aliases and host-resolved concrete ids pass through unchanged for downstream resolution.
+ * Validates and normalizes graph {@link GraphAiModelConfig} (profile alias names).
  */
 export declare function resolveGraphAiModelConfig(modelConfig: GraphAiModelConfig | undefined, context?: GraphAiModelConfigResolveContext): Promise<GraphAiModelConfig>;
 export type EngineModelPhase = 'pre' | 'main' | 'post';
 /**
- * Maps three-phase graph config to ai-tasks slot pair for a single runTask phase.
- * Values are forwarded as-is (profile aliases or concrete ids).
- *
- * When {@link aiProfiles} is set (studio/playground host pattern), xynthesis slots use profile
- * aliases so PRE synthesis inside ai-tasks resolves via ai-profiles even when {@link config}
- * carries host-resolved concrete provider ids on `runtime.modelConfig`.
+ * Maps graph three-phase config to ai-tasks `RunTaskRequest.modelConfig` (8.4+ triplet).
+ * Values are profile alias names from the graph document; ai-tasks resolves and routes slots per phase.
  */
-export declare function toRunTaskModelConfigForPhase(config: GraphAiModelConfig, phase: EngineModelPhase, aiProfiles?: GraphAiModelConfig): RunTaskModelConfigWire;
+export declare function toRunTaskModelConfig(config: GraphAiModelConfig): RunTaskModelConfigWire;

package/dist/src/runtime/graphAiModelConfig.js

@@ -66,8 +66,7 @@ function normalizeModelSlot(slot, context) {
     return trimmed;
 }
 /**
- * Validates and normalizes graph/runtime {@link GraphAiModelConfig}.
- * Profile aliases and host-resolved concrete ids pass through unchanged for downstream resolution.
+ * Validates and normalizes graph {@link GraphAiModelConfig} (profile alias names).
  */
 export async function resolveGraphAiModelConfig(modelConfig, context) {
     if (!isGraphAiModelConfig(modelConfig)) {
@@ -79,37 +78,14 @@ export async function resolveGraphAiModelConfig(modelConfig, context) {
         postActionModel: normalizeModelSlot(modelConfig.postActionModel, context),
     };
 }
-function xynthesisSlotForWire(config, phase, aiProfiles) {
-    if (aiProfiles != null) {
-        return phase === 'post' ? aiProfiles.postActionModel : aiProfiles.preActionModel;
-    }
-    return phase === 'post' ? config.postActionModel : config.preActionModel;
-}
 /**
- * Maps three-phase graph config to ai-tasks slot pair for a single runTask phase.
- * Values are forwarded as-is (profile aliases or concrete ids).
- *
- * When {@link aiProfiles} is set (studio/playground host pattern), xynthesis slots use profile
- * aliases so PRE synthesis inside ai-tasks resolves via ai-profiles even when {@link config}
- * carries host-resolved concrete provider ids on `runtime.modelConfig`.
+ * Maps graph three-phase config to ai-tasks `RunTaskRequest.modelConfig` (8.4+ triplet).
+ * Values are profile alias names from the graph document; ai-tasks resolves and routes slots per phase.
  */
-export function toRunTaskModelConfigForPhase(config, phase, aiProfiles) {
-    const xynthesisModel = xynthesisSlotForWire(config, phase, aiProfiles);
-    switch (phase) {
-        case 'pre':
-            return {
-                xynthesisModel,
-                skillModel: xynthesisModel,
-            };
-        case 'main':
-            return {
-                xynthesisModel,
-                skillModel: config.skillModel,
-            };
-        case 'post':
-            return {
-                xynthesisModel,
-                skillModel: xynthesisModel,
-            };
-    }
+export function toRunTaskModelConfig(config) {
+    return {
+        preActionModel: config.preActionModel,
+        skillModel: config.skillModel,
+        postActionModel: config.postActionModel,
+    };
 }

package/dist/src/runtime/mergeExellixGraphRuntimeInvocation.js

@@ -15,11 +15,7 @@ export function mergeExellixGraphRuntimeInvocation(input, opts) {
         executionPipeline: input.executionPipeline ?? opts.executionPipeline,
         playgroundMeta: input.playgroundMeta ?? opts.playgroundMeta,
         clearSynthesizedContextPerNode: input.clearSynthesizedContextPerNode ?? opts.clearSynthesizedContextPerNode,
-        modelConfig: input.modelConfig ?? opts.modelConfig,
-        aiProfiles: input.aiProfiles ?? opts.aiProfiles,
-        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,

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

@@ -1,11 +1,9 @@
 import type { RunxClient } from '@x12i/runx';
-import type { GraphAiModelConfig, ModelConfigSelection, TaskNodeRuntimeObject } from '../types/refs.js';
+import type { GraphAiModelConfig, ModelConfigSelection } 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;
     conditionCtx: TaskNodeConditionEvalContext;
     executionInput: Record<string, unknown>;
@@ -15,10 +13,9 @@ export type ResolveModelConfigForNodeArgs = {
     jobId?: string;
 };
 /**
- * Resolves effective model config for a task node (precedence + conditional cases).
- * Returns profile aliases (or host-resolved concrete ids from runtime overrides) for
- * {@link toRunTaskModelConfigForPhase} / ai-tasks wire. Alias → model resolution is downstream.
+ * Resolves effective model config for a task node from the graph document only.
+ * Precedence: `node.taskConfiguration.modelConfig` → `graph.modelConfig` → engine default profiles.
  */
 export declare function resolveModelConfigForNode(args: ResolveModelConfigForNodeArgs): Promise<GraphAiModelConfig>;
 export { conditionWhenSignature, isEmptyConditionWhen };
-export { resolveGraphAiModelConfig, toRunTaskModelConfigForPhase, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './graphAiModelConfig.js';
+export { resolveGraphAiModelConfig, toRunTaskModelConfig, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './graphAiModelConfig.js';

package/dist/src/runtime/resolveModelConfigForNode.js

@@ -34,16 +34,11 @@ async function resolveTier(value, ctx, executionInput, runx) {
     return undefined;
 }
 /**
- * Resolves effective model config for a task node (precedence + conditional cases).
- * Returns profile aliases (or host-resolved concrete ids from runtime overrides) for
- * {@link toRunTaskModelConfigForPhase} / ai-tasks wire. Alias → model resolution is downstream.
+ * Resolves effective model config for a task node from the graph document only.
+ * Precedence: `node.taskConfiguration.modelConfig` → `graph.modelConfig` → engine default profiles.
  */
 export async function resolveModelConfigForNode(args) {
-    const staticHost = args.runtimeNodeConfig?.modelConfig;
-    if (isGraphAiModelConfig(staticHost)) {
-        return staticHost;
-    }
-    const tiers = [args.nodeModelConfig, args.runtimeModelConfig, args.graphModelConfig];
+    const tiers = [args.nodeModelConfig, args.graphModelConfig];
     for (const tier of tiers) {
         const selected = await resolveTier(tier, args.conditionCtx, args.executionInput, args.runx);
         if (selected != null) {
@@ -53,4 +48,4 @@ export async function resolveModelConfigForNode(args) {
     return DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG;
 }
 export { conditionWhenSignature, isEmptyConditionWhen };
-export { resolveGraphAiModelConfig, toRunTaskModelConfigForPhase, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './graphAiModelConfig.js';
+export { resolveGraphAiModelConfig, toRunTaskModelConfig, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './graphAiModelConfig.js';

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

@@ -1,7 +1,14 @@
 /**
  * Shared pieces for assembling `@exellix/ai-tasks` requests from graph-engine (llmCall merge, identity, trace mode).
  */
+import type { LlmCallConfig } from '@exellix/ai-tasks';
+import type { RunTaskModelConfigWire } from './graphAiModelConfig.js';
 export declare function mergeDefinedLlmCallParts(...parts: Array<Record<string, unknown> | undefined | null>): Record<string, unknown> | undefined;
+/**
+ * MAIN-only `llmCall` for ai-tasks 8.4+: `model` is always {@link RunTaskModelConfigWire.skillModel};
+ * node `taskConfiguration.llmCall` may supply caps/options but not override the skill slot model.
+ */
+export declare function buildMainLlmCallForRunTask(modelConfig: RunTaskModelConfigWire, ...parts: Array<Record<string, unknown> | undefined | null>): LlmCallConfig;
 /** Whether to send `executionMode: "trace"` on `runTask` (ai-tasks 5.6+). */
 export declare function shouldForwardRunTaskTraceMode(opts: {
     debugMode?: boolean;

package/dist/src/runtime/runTaskAugments.js

@@ -1,6 +1,3 @@
-/**
- * Shared pieces for assembling `@exellix/ai-tasks` requests from graph-engine (llmCall merge, identity, trace mode).
- */
 export function mergeDefinedLlmCallParts(...parts) {
     const out = {};
     for (const p of parts) {
@@ -13,6 +10,18 @@ export function mergeDefinedLlmCallParts(...parts) {
     }
     return Object.keys(out).length > 0 ? out : undefined;
 }
+/**
+ * MAIN-only `llmCall` for ai-tasks 8.4+: `model` is always {@link RunTaskModelConfigWire.skillModel};
+ * node `taskConfiguration.llmCall` may supply caps/options but not override the skill slot model.
+ */
+export function buildMainLlmCallForRunTask(modelConfig, ...parts) {
+    const merged = mergeDefinedLlmCallParts(...parts) ?? {};
+    const { model: _ignored, ...rest } = merged;
+    return {
+        ...rest,
+        model: modelConfig.skillModel,
+    };
+}
 /** Whether to send `executionMode: "trace"` on `runTask` (ai-tasks 5.6+). */
 export function shouldForwardRunTaskTraceMode(opts) {
     if (opts.runTaskExecutionMode === 'trace')

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

@@ -5,7 +5,7 @@
 import type { Catalox } from '@x12i/catalox';
 import type { RunTaskRequest } from '@exellix/ai-tasks';
 import { type AnalyzeRunTaskRequestOptions, type AnalyzeRunTaskRequestResult, type RunTaskInvokeValidationResult, type RunTaskValidationResult, type ValidateRunTaskInvokeParams } from '@exellix/ai-tasks';
-import type { GraphAiModelConfig, GraphModelAliasConfig, Job, TaskNode } from '../types/refs.js';
+import type { GraphAiModelConfig, Job, TaskNode } from '../types/refs.js';
 import type { ExecutionStepOption, RunTaskDiagnostics, SkillKeyResolutionOptions } from '../types/options.js';
 export type TaskNodeRunTaskPreflightSkipReason = 'local_skill' | 'finalizer';
 export type BuildTaskNodeRunTaskRequestResult = {
@@ -30,13 +30,8 @@ export type BuildTaskNodeRunTaskRequestArgs = {
     graphRunTaskId?: string;
     /** Host job id on `job.jobId` / `job.id`; defaults from `job` when omitted. */
     runTaskJobId?: string;
-    /** Profile aliases or host-resolved concrete ids; forwarded unchanged on the ai-tasks wire. */
-    modelConfig?: GraphAiModelConfig;
-    /** @deprecated Unused since 7.1. */
-    aliasConfig?: GraphModelAliasConfig;
-    llmCall?: Record<string, unknown>;
-    /** Runtime default merged with per-node `taskConfiguration.llmCall`. */
-    runtimeLlmCall?: Record<string, unknown>;
+    /** Resolved graph model profiles (required for runnable MAIN). */
+    modelConfig: GraphAiModelConfig;
     runTaskIdentity?: Record<string, unknown>;
     runTaskExecutionMode?: 'default' | 'trace';
     runTaskDiagnostics?: RunTaskDiagnostics;

package/dist/src/runtime/taskNodeRunTaskPreflight.js

@@ -1,5 +1,5 @@
 import { analyzeRunTaskRequest, validateRunTaskConfig, validateRunTaskInvoke, } from '@exellix/ai-tasks';
-import { toRunTaskModelConfigForPhase } from './graphAiModelConfig.js';
+import { toRunTaskModelConfig } from './graphAiModelConfig.js';
 import { resolveTaskKey } from './resolveTaskKey.js';
 import { isLocalSkillKey } from './localSkills/index.js';
 import { buildAiTasksRunTaskRequest, extractRunTaskStrategyOverrides, } from './buildAiTasksRunTaskRequest.js';
@@ -12,7 +12,7 @@ import { xynthesizedOutboundForNode } from './graphRunExecutionSeed.js';
 import { buildTaskNodeJobContext } from './buildTaskNodeJobContext.js';
 import { resolveNarrixForTaskNode } from './resolveNarrixForTaskNode.js';
 import { normalizeSynthesizedContextConfig } from './synthesizedContextPipeline.js';
-import { buildRunTaskIdentityEnvelope, mergeDefinedLlmCallParts, shouldForwardRunTaskTraceMode, } from './runTaskAugments.js';
+import { buildMainLlmCallForRunTask, buildRunTaskIdentityEnvelope, shouldForwardRunTaskTraceMode, } from './runTaskAugments.js';
 import { mirrorTaskVariablesOnExecution, readExecutionVariableBuckets, } from './executionVariableBuckets.js';
 import { newGraphRunTaskId } from './graphRunIdentity.js';
 function isPlainRecord(v) {
@@ -115,13 +115,13 @@ export async function buildTaskNodeRunTaskRequest(args) {
     mirrorStructuredInputOntoExecutionMemory(executionForTask, taskInput);
     const runTaskJobMemory = mergeKnowledgePatchIntoRunTaskMemory(args.jobMemory, args.jobKnowledgePatch);
     const runTaskTaskMemory = mergeKnowledgePatchIntoRunTaskMemory(args.taskMemory, args.taskKnowledgePatch);
-    const effectiveLlmCall = mergeDefinedLlmCallParts(args.runtimeLlmCall, args.llmCall, node.taskConfiguration?.llmCall);
+    const wireModelConfig = toRunTaskModelConfig(args.modelConfig);
+    const effectiveLlmCall = buildMainLlmCallForRunTask(wireModelConfig, node.taskConfiguration?.llmCall);
     const forwardRunTaskTrace = shouldForwardRunTaskTraceMode({
         runTaskExecutionMode: args.runTaskExecutionMode,
     });
     const metaStrats = node.taskConfiguration?.executionStrategies;
     const ov = node.taskConfiguration?.aiTasksOutputValidation;
-    const mainRunTaskModelConfig = args.modelConfig != null ? toRunTaskModelConfigForPhase(args.modelConfig, 'main') : undefined;
     const request = buildAiTasksRunTaskRequest({
         skillKey,
         job: args.job,
@@ -146,7 +146,7 @@ export async function buildTaskNodeRunTaskRequest(args) {
             ? ov
             : undefined,
         diagnostics: args.runTaskDiagnostics,
-        modelConfig: mainRunTaskModelConfig,
+        modelConfig: wireModelConfig,
         llmCall: effectiveLlmCall,
         identity: buildRunTaskIdentityEnvelope({
             base: args.runTaskIdentity,

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

@@ -0,0 +1,16 @@
+/** Minimal runtime shape validated at `executeGraph` entry (avoids circular import with ExellixGraphRuntime). */
+export type CanonicalGraphRuntimeShape = {
+    modelConfig?: unknown;
+    aiProfiles?: unknown;
+    aliasConfig?: unknown;
+    llmCall?: unknown;
+    nodes?: Record<string, unknown>;
+};
+/**
+ * Rejects runtime-layer AI model selection and `llmCall` overrides (7.7+).
+ * Profile aliases and `modelConfig` cases belong on {@link GraphModelObject} / task nodes only.
+ */
+export declare function assertCanonicalGraphRuntimeObject(runtime: CanonicalGraphRuntimeShape, context?: {
+    jobId?: string;
+    graphId?: string;
+}): void;

package/dist/src/runtime/validateCanonicalGraphRuntime.js

@@ -0,0 +1,35 @@
+import { ExellixGraphError } from '../errors/ExellixGraphError.js';
+import { ExellixGraphErrorCode } from '../errors/exellixGraphErrorCodes.js';
+const FORBIDDEN_RUNTIME_ROOT_KEYS = [
+    'modelConfig',
+    'aiProfiles',
+    'aliasConfig',
+    'llmCall',
+];
+const FORBIDDEN_RUNTIME_NODE_KEYS = ['modelConfig', 'aliasConfig'];
+function isPlainObject(v) {
+    return v != null && typeof v === 'object' && !Array.isArray(v);
+}
+/**
+ * Rejects runtime-layer AI model selection and `llmCall` overrides (7.7+).
+ * Profile aliases and `modelConfig` cases belong on {@link GraphModelObject} / task nodes only.
+ */
+export function assertCanonicalGraphRuntimeObject(runtime, context) {
+    for (const key of FORBIDDEN_RUNTIME_ROOT_KEYS) {
+        if (runtime[key] !== undefined) {
+            throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_GRAPH_RUNTIME, `runtime.${key} was removed in 7.7; configure model profiles on graph.modelConfig and node.taskConfiguration.modelConfig only.`, context);
+        }
+    }
+    const nodes = runtime.nodes;
+    if (nodes == null || typeof nodes !== 'object' || Array.isArray(nodes))
+        return;
+    for (const [nodeId, nodeCfg] of Object.entries(nodes)) {
+        if (!isPlainObject(nodeCfg))
+            continue;
+        for (const key of FORBIDDEN_RUNTIME_NODE_KEYS) {
+            if (nodeCfg[key] !== undefined) {
+                throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_GRAPH_RUNTIME, `runtime.nodes["${nodeId}"].${key} was removed in 7.7; use graph / task node modelConfig on the model document.`, context);
+            }
+        }
+    }
+}

package/dist/src/types/options.d.ts

@@ -1,7 +1,7 @@
 import type { Activix } from '@x12i/activix';
 import type { StackLoggingOptions } from '@x12i/logxer';
-import type { LlmCallConfig, RunTaskRequest as AiTasksRunTaskRequest, RunTaskResponse as AiTasksRunTaskResponse } from '@exellix/ai-tasks';
-import type { GraphAiModelConfig, GraphModelAliasConfig, ModelConfigSelection, TaskNodeRuntimeObject } from './refs.js';
+import type { RunTaskRequest as AiTasksRunTaskRequest, RunTaskResponse as AiTasksRunTaskResponse } from '@exellix/ai-tasks';
+import type { TaskNodeRuntimeObject } from './refs.js';
 import type { RuntimeObjects } from '../runtime/runtimeObjects.js';
 /**
  * NOTE: `@exellix/ai-tasks` 5.5+ removed the exported `RunTaskDiagnostics` type.
@@ -62,15 +62,7 @@ export interface HostExecuteGraphRunOptions {
     executionPipeline?: ExecutionStepOption[];
     playgroundMeta?: Record<string, unknown>;
     clearSynthesizedContextPerNode?: boolean;
-    modelConfig?: ModelConfigSelection;
-    /**
-     * Profile aliases for xynthesis PRE/POST when {@link modelConfig} carries host-resolved concrete ids.
-     * MAIN `skillModel` still comes from resolved `modelConfig`; xynthesis slots prefer these aliases.
-     */
-    aiProfiles?: GraphAiModelConfig;
-    aliasConfig?: GraphModelAliasConfig;
     nodes?: Record<string, TaskNodeRuntimeObject>;
-    llmCall?: LlmCallConfig;
     runTaskIdentity?: Record<string, unknown>;
     runTaskExecutionMode?: 'default' | 'trace';
     runLogMode?: import('./runLog.js').RunLogMode;

package/dist/src/types/refs.d.ts

@@ -14,8 +14,7 @@ export type TaskNodeExecutionPipelineStep = {
  */
 /**
  * Three-phase AI model selection on graph model / node `modelConfig`.
- * Values are profile alias names (`cheap`, `balanced`, `deep`, …) in graph JSON,
- * or host-resolved concrete provider ids on runtime overrides. Alias resolution is downstream.
+ * Values are profile alias names (`cheap`, `balanced`, `deep`, …) in graph JSON only.
  */
 export type GraphAiModelConfig = {
     preActionModel: string;
@@ -26,12 +25,8 @@ export type GraphAiModelConfig = {
  * @deprecated Legacy alias map — no longer required for execute. Hosts may omit `runtime.aliasConfig`.
  */
 export type GraphModelAliasConfig = Record<string, string>;
-/** Runtime overrides for a single task node, stored at GraphRuntimeObject.nodes[nodeId]. */
-export type TaskNodeRuntimeObject = {
-    modelConfig?: GraphAiModelConfig;
-    /** @deprecated Unused since 7.1 — profile aliases pass through to downstream resolution. */
-    aliasConfig?: GraphModelAliasConfig;
-};
+/** Per-node runtime bag (extensible). Model selection is graph-only since 7.7. */
+export type TaskNodeRuntimeObject = Record<string, unknown>;
 /** Backwards-readable alias for per-node runtime overrides keyed by task node id. */
 export type GraphRuntimeNodeConfig = TaskNodeRuntimeObject;
 /** Schema version for structured record gates on `conditions.dataFilters` (and optional `graphEntry.dataFilters`). */
@@ -701,8 +696,7 @@ export interface GraphModelObject {
     /** Optional static model version for authoring, storage, and replay/audit tooling. */
     version?: string;
     /**
-     * Graph-level default AI model selection. Runtime aliases are resolved from
-     * GraphRuntimeObject.aliasConfig / nodes[nodeId].aliasConfig before runTask.
+     * Graph-level default AI model selection (profile alias names per slot).
      */
     modelConfig?: ModelConfigSelection;
     /**

package/dist/testkit/index.d.ts

@@ -1,5 +1,5 @@
 export { InMemoryGraphLoader } from './inMemoryGraphLoader.js';
 export { DepGraphEngineFactory } from './depGraphEngineFactory.js';
 export { RealTasksClient } from './RealTasksClient.js';
-export { buildTestAliasConfig, withTestAliasRuntime, createTestExellixGraphRuntime, } from './testModelAliasRuntime.js';
+export { createTestExellixGraphRuntime } from './testModelAliasRuntime.js';
 export { tryLoadExellixAiTasksRuntimeSubtree, loadExellixGraphRuntimeObjects, } from './exellixRuntimeObjects.js';

package/dist/testkit/index.js

@@ -1,5 +1,5 @@
 export { InMemoryGraphLoader } from './inMemoryGraphLoader.js';
 export { DepGraphEngineFactory } from './depGraphEngineFactory.js';
 export { RealTasksClient } from './RealTasksClient.js';
-export { buildTestAliasConfig, withTestAliasRuntime, createTestExellixGraphRuntime, } from './testModelAliasRuntime.js';
+export { createTestExellixGraphRuntime } from './testModelAliasRuntime.js';
 export { tryLoadExellixAiTasksRuntimeSubtree, loadExellixGraphRuntimeObjects, } from './exellixRuntimeObjects.js';

package/dist/testkit/testModelAliasRuntime.d.ts

@@ -1,14 +1,7 @@
-import type { Graph } from '../src/types/refs.js';
-import { createExellixGraphRuntime, type GraphRuntimeObject } from '../src/runtime/ExellixGraphRuntime.js';
+import { createExellixGraphRuntime } from '../src/runtime/ExellixGraphRuntime.js';
 type CreateOpts = Parameters<typeof createExellixGraphRuntime>[0];
 /**
- * Testkit runtime for graphs using profile aliases (no `runtime.aliasConfig` required).
+ * Testkit runtime for graphs using profile aliases on the graph document.
  */
 export declare function createTestExellixGraphRuntime(opts: CreateOpts): ReturnType<typeof createExellixGraphRuntime>;
-/** @deprecated Alias map test helper removed in 7.1 — profile aliases pass through to ai-tasks. */
-export declare function buildTestAliasConfig(_graph: Pick<Graph, 'modelConfig' | 'nodes'>, runtimePartial?: Pick<GraphRuntimeObject, 'modelConfig' | 'nodes'> & {
-    aliasConfig?: Record<string, string>;
-}): Record<string, string>;
-/** @deprecated No-op — `runtime.aliasConfig` is not required in 7.1. */
-export declare function withTestAliasRuntime(_graph: Pick<Graph, 'id' | 'modelConfig' | 'nodes'>, runtime: Partial<GraphRuntimeObject> & Pick<GraphRuntimeObject, 'jobId' | 'job'>): GraphRuntimeObject;
 export {};

package/dist/testkit/testModelAliasRuntime.js

@@ -1,6 +1,6 @@
 import { createExellixGraphRuntime, } from '../src/runtime/ExellixGraphRuntime.js';
 /**
- * Testkit runtime for graphs using profile aliases (no `runtime.aliasConfig` required).
+ * Testkit runtime for graphs using profile aliases on the graph document.
  */
 export function createTestExellixGraphRuntime(opts) {
     const runtime = createExellixGraphRuntime(opts);
@@ -20,11 +20,3 @@ export function createTestExellixGraphRuntime(opts) {
     };
     return runtime;
 }
-/** @deprecated Alias map test helper removed in 7.1 — profile aliases pass through to ai-tasks. */
-export function buildTestAliasConfig(_graph, runtimePartial) {
-    return { ...(runtimePartial?.aliasConfig ?? {}) };
-}
-/** @deprecated No-op — `runtime.aliasConfig` is not required in 7.1. */
-export function withTestAliasRuntime(_graph, runtime) {
-    return runtime;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exellix/graph-engine",
-  "version": "7.5.1",
+  "version": "7.7.0",
   "type": "module",
   "description": "Graph executor SDK",
   "main": "dist/src/index.js",
@@ -52,18 +52,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@exellix/ai-tasks": "^8.2.9",
+    "@exellix/ai-tasks": "^8.4.3",
     "@x12i/activix": "8.5.0",
     "@x12i/catalox": "5.1.3",
     "@x12i/env": "4.0.1",
-    "@x12i/funcx": "4.3.0",
+    "@x12i/funcx": "4.3.3",
     "@x12i/graphenix": "2.5.0",
     "@x12i/graphenix-format": "2.0.0",
     "@x12i/logxer": "^4.6.0",
     "@x12i/memorix-descriptors": "1.6.0",
     "@x12i/memorix-retrieval": "1.11.2",
     "@x12i/memorix-writer": "1.0.0",
-    "@x12i/optimixer": "^2.4.4",
     "@x12i/rendrix": "4.3.0",
     "@x12i/runx": "1.3.0"
   },