@exellix/graph-engine 7.0.1 → 7.2.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 7.1.2
+
+### Fixed
+
+- **Step retry token bump:** Reads `llmCall.maxTokensCap` (ai-tasks v8) before legacy `maxTokens` / `max_tokens`, and writes bumps back as `maxTokensCap` on retry.
+- **Dependency workaround:** `postinstall` patches `@exellix/ai-tasks@8.0.7` broken re-export of `MODEL_CAPABILITIES` from `@exellix/xynthesis` (removed in xynthesis 4.x) until upstream publishes a fix.
+
+## 7.1.0
+
+### Breaking
+
+- **Three-phase `GraphAiModelConfig`:** `{ preActionModel, skillModel, postActionModel }` replaces `{ xynthesisModel, skillModel }`. `postActionModel` is required; POST utilities no longer reuse `skillModel`.
+- **AI profile resolution:** Graph JSON profile names resolve via `@x12i/ai-profiles` (bundled registry). `runtime.aliasConfig` is no longer required.
+- **Phase routing:** PRE / MAIN / POST `runTask` calls receive independent models on the ai-tasks wire (`toRunTaskModelConfigForPhase`).
+- **Preflight async:** `buildTaskNodeRunTaskRequest` and `validateTaskNodeRunTaskConfig` are async.
+
+### Added
+
+- Dependency `@x12i/ai-profiles`.
+- Exports: `resolveGraphAiModelConfig`, `toRunTaskModelConfigForPhase`, `DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG`, `isGraphAiProfileName`, `MODEL_CONFIG_INCOMPLETE`, `MODEL_PROFILE_UNRESOLVED`.
+
+## 7.0.3
+
+### Added
+
+- **Default model ids (JSON-serializable):** `DEFAULT_GRAPH_AI_MODEL_IDS` (`google/gemma-4-31b-it` synthesis, `deepseek/deepseek-r1` skills), `DEFAULT_RUNTIME_ALIAS_CONFIG`, and `DEFAULT_SYNTHESIS_MODEL_ALIAS` / `DEFAULT_SKILL_MODEL_ALIAS` for implicit fallback (`default-xynthesis`, `default-skill`). Testkit `buildTestAliasConfig` merges `DEFAULT_RUNTIME_ALIAS_CONFIG` automatically.
+
 ## 7.0.0
 
 ### Breaking

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

@@ -28,10 +28,14 @@ export declare enum ExellixGraphErrorCode {
     GRAPH_ENTRY_DATA_FILTERS_REJECTED = "GRAPH_ENTRY_DATA_FILTERS_REJECTED",
     /** MAIN readiness guard rejected empty execution input or synthesis context before runTask. */
     MAIN_READINESS_FAILED = "MAIN_READINESS_FAILED",
-    /** `executeGraph` called without a non-empty `runtime.aliasConfig`. */
+    /** @deprecated Legacy alias map — unused since 7.1. */
     MODEL_ALIAS_CONFIG_REQUIRED = "MODEL_ALIAS_CONFIG_REQUIRED",
-    /** Selected model alias has no concrete model in the merged runtime alias map. */
+    /** @deprecated Legacy alias map — unused since 7.1. */
     MODEL_ALIAS_UNRESOLVED = "MODEL_ALIAS_UNRESOLVED",
-    /** Graph JSON `modelConfig` contains a provider model id instead of an alias name. */
-    NON_CANONICAL_MODEL_CONFIG = "NON_CANONICAL_MODEL_CONFIG"
+    /** Graph JSON `modelConfig` contains a provider model id instead of an AI profile name. */
+    NON_CANONICAL_MODEL_CONFIG = "NON_CANONICAL_MODEL_CONFIG",
+    /** `modelConfig` is missing or not exactly `{ preActionModel, skillModel, postActionModel }`. */
+    MODEL_CONFIG_INCOMPLETE = "MODEL_CONFIG_INCOMPLETE",
+    /** An AI profile name could not be resolved via `@x12i/ai-profiles`. */
+    MODEL_PROFILE_UNRESOLVED = "MODEL_PROFILE_UNRESOLVED"
 }

package/dist/src/errors/exellixGraphErrorCodes.js

@@ -29,10 +29,14 @@ export var ExellixGraphErrorCode;
     ExellixGraphErrorCode["GRAPH_ENTRY_DATA_FILTERS_REJECTED"] = "GRAPH_ENTRY_DATA_FILTERS_REJECTED";
     /** MAIN readiness guard rejected empty execution input or synthesis context before runTask. */
     ExellixGraphErrorCode["MAIN_READINESS_FAILED"] = "MAIN_READINESS_FAILED";
-    /** `executeGraph` called without a non-empty `runtime.aliasConfig`. */
+    /** @deprecated Legacy alias map — unused since 7.1. */
     ExellixGraphErrorCode["MODEL_ALIAS_CONFIG_REQUIRED"] = "MODEL_ALIAS_CONFIG_REQUIRED";
-    /** Selected model alias has no concrete model in the merged runtime alias map. */
+    /** @deprecated Legacy alias map — unused since 7.1. */
     ExellixGraphErrorCode["MODEL_ALIAS_UNRESOLVED"] = "MODEL_ALIAS_UNRESOLVED";
-    /** Graph JSON `modelConfig` contains a provider model id instead of an alias name. */
+    /** Graph JSON `modelConfig` contains a provider model id instead of an AI profile name. */
     ExellixGraphErrorCode["NON_CANONICAL_MODEL_CONFIG"] = "NON_CANONICAL_MODEL_CONFIG";
+    /** `modelConfig` is missing or not exactly `{ preActionModel, skillModel, postActionModel }`. */
+    ExellixGraphErrorCode["MODEL_CONFIG_INCOMPLETE"] = "MODEL_CONFIG_INCOMPLETE";
+    /** An AI profile name could not be resolved via `@x12i/ai-profiles`. */
+    ExellixGraphErrorCode["MODEL_PROFILE_UNRESOLVED"] = "MODEL_PROFILE_UNRESOLVED";
 })(ExellixGraphErrorCode || (ExellixGraphErrorCode = {}));

package/dist/src/index.d.ts

@@ -38,8 +38,14 @@ 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, resolveGraphAiModelConfigAliases, mergeAliasConfigs, } from './runtime/resolveModelConfigForNode.js';
-export { DEFAULT_MODEL_ALIAS, DEFAULT_GRAPH_AI_MODEL_ALIAS_CONFIG, isModelAliasString, looksLikeConcreteModelId, assertGraphModelAliasString, collectModelAliasesUsedInGraph, assertRuntimeAliasConfigPresent, assertRuntimeAliasConfigCoversGraph, } from './runtime/modelAliasContract.js';
+export { resolveModelConfigForNode, resolveGraphAiModelConfig, toRunTaskModelConfigForPhase, 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';
+/** @deprecated Use {@link isGraphAiProfileName}. */
+export { isGraphAiProfileName as isModelAliasString } from './runtime/graphAiModelConfig.js';
+/** @deprecated Use {@link assertGraphAiProfileNameString}. */
+export { assertGraphAiProfileNameString as assertGraphModelAliasString } from './runtime/graphAiModelConfig.js';
 export { isGraphAiModelConfig, isModelConfigSelection, isEmptyConditionWhen, conditionWhenSignature, countDefaultModelConfigCases, } from './runtime/modelConfigSelection.js';
 export { GRAPH_ENGINE_MEMORY_PATH_ROOTS, splitGraphEngineMemoryPath, isAllowedGraphEngineMemoryPath, graphEngineMemoryPathValidationMessage, } from './runtime/graphEngineMemoryPaths.js';
 export { buildRunTaskMainInput, extractCallerInputsBag, buildGraphEngineMemoryResolutionRoot, buildGraphEngineMemoryResolutionRootFromWorkingMemory, resolveGraphEngineMemoryPathValue, } from './runtime/resolveGraphEngineMemoryPaths.js';

package/dist/src/index.js

@@ -28,8 +28,14 @@ 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, resolveGraphAiModelConfigAliases, mergeAliasConfigs, } from './runtime/resolveModelConfigForNode.js';
-export { DEFAULT_MODEL_ALIAS, DEFAULT_GRAPH_AI_MODEL_ALIAS_CONFIG, isModelAliasString, looksLikeConcreteModelId, assertGraphModelAliasString, collectModelAliasesUsedInGraph, assertRuntimeAliasConfigPresent, assertRuntimeAliasConfigCoversGraph, } from './runtime/modelAliasContract.js';
+export { resolveModelConfigForNode, resolveGraphAiModelConfig, toRunTaskModelConfigForPhase, 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';
+/** @deprecated Use {@link isGraphAiProfileName}. */
+export { isGraphAiProfileName as isModelAliasString } from './runtime/graphAiModelConfig.js';
+/** @deprecated Use {@link assertGraphAiProfileNameString}. */
+export { assertGraphAiProfileNameString as assertGraphModelAliasString } from './runtime/graphAiModelConfig.js';
 export { isGraphAiModelConfig, isModelConfigSelection, isEmptyConditionWhen, conditionWhenSignature, countDefaultModelConfigCases, } from './runtime/modelConfigSelection.js';
 export { GRAPH_ENGINE_MEMORY_PATH_ROOTS, splitGraphEngineMemoryPath, isAllowedGraphEngineMemoryPath, graphEngineMemoryPathValidationMessage, } from './runtime/graphEngineMemoryPaths.js';
 export { buildRunTaskMainInput, extractCallerInputsBag, buildGraphEngineMemoryResolutionRoot, buildGraphEngineMemoryResolutionRootFromWorkingMemory, resolveGraphEngineMemoryPathValue, } from './runtime/resolveGraphEngineMemoryPaths.js';

package/dist/src/inspection/contractInspection.js

@@ -293,9 +293,19 @@ function buildOutputContract(node) {
     const tc = task.taskConfiguration;
     const webCfg = tc?.aiTaskProfile;
     const webScoping = webCfg?.webScoping;
+    const narrixCfg = tc?.narrix;
     const webWrites = [];
-    if (webScoping && webScoping.enabled === true) {
-        webWrites.push({ path: 'webContext', source: 'taskConfiguration.aiTaskProfile.webScoping → executeNode (runtime-known)' });
+    if (narrixCfg?.enableWebScope === true) {
+        webWrites.push({
+            path: 'webContext',
+            source: 'taskConfiguration.narrix.enableWebScope → @exellix/ai-tasks (runtime-known)',
+        });
+    }
+    else if (webScoping && webScoping.enabled === true) {
+        webWrites.push({
+            path: 'webContext',
+            source: 'taskConfiguration.aiTaskProfile.webScoping → executeNode (runtime-known)',
+        });
     }
     const synthWrites = [];
     const inputSynth = webCfg?.inputSynthesis;

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

@@ -91,7 +91,9 @@ export interface GraphRuntimeObject extends HostExecuteGraphRunOptions {
     taskVariables?: Record<string, unknown>;
     /** Runtime default model selection (`cases`); overrides GraphModelObject.modelConfig. */
     modelConfig?: ModelConfigSelection;
-    /** Runtime alias map used to resolve modelConfig values before runTask. */
+    /**
+     * @deprecated Unused since 7.1 — model profiles resolve via `@x12i/ai-profiles`.
+     */
     aliasConfig?: GraphModelAliasConfig;
     /** Task-node runtime overrides keyed by node id. */
     nodes?: Record<string, TaskNodeRuntimeObject>;

package/dist/src/runtime/ExellixGraphRuntime.js

@@ -34,7 +34,7 @@ import { evaluateGraphPredicate } from "./predicates.js";
 import { evaluateStructuredDataFilters } from "./dataFiltersEvaluation.js";
 import { evaluateTaskNodeConditions } from "./taskNodeConditionsEvaluation.js";
 import { resolveModelConfigForNode } from "./resolveModelConfigForNode.js";
-import { assertRuntimeAliasConfigCoversGraph } from "./modelAliasContract.js";
+import { toRunTaskModelConfigForPhase } from "./graphAiModelConfig.js";
 import { createRunx } from "@x12i/runx";
 import { selectByPath } from "./pathExpr.js";
 import { createGraphStartEvent, createGraphCompleteEvent, createGraphFailEvent, createNodeStartEvent, createNodeCompleteEvent, createNodeFailEvent, } from "./events.js";
@@ -393,7 +393,11 @@ export function createExellixGraphRuntime(opts) {
                                     : {}),
                                 kind: "finalizer",
                             },
-                            ...(input.modelConfig != null ? { modelConfig: input.modelConfig } : {}),
+                            ...(input.modelConfig != null
+                                ? {
+                                    modelConfig: toRunTaskModelConfigForPhase(input.modelConfig, 'pre'),
+                                }
+                                : {}),
                             ...(effectiveLlmCall != null ? { llmCall: effectiveLlmCall } : {}),
                             ...(forwardRunTaskTrace ? { executionMode: "trace" } : {}),
                             ...((input.runTaskDiagnostics ?? opts.runTaskDiagnostics) != null
@@ -603,6 +607,9 @@ export function createExellixGraphRuntime(opts) {
             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')
+            : undefined;
         // DEBUG: Verify execution object before sending
         if (process.env.DEBUG_EXECUTION_MEMORY === 'true') {
             console.log(`[DEBUG] Node ${input.node?.id}: execution object =`, JSON.stringify(input.execution, null, 2));
@@ -830,7 +837,7 @@ export function createExellixGraphRuntime(opts) {
                 ? input.node.taskConfiguration.aiTasksOutputValidation
                 : undefined,
             diagnostics: (input.runTaskDiagnostics ?? opts.runTaskDiagnostics),
-            modelConfig: effectiveModelConfig ?? undefined,
+            modelConfig: mainRunTaskModelConfig,
             llmCall: effectiveLlmCall,
             identity: buildRunTaskIdentityEnvelope({
                 base: runTaskIdentityBase,
@@ -1152,7 +1159,6 @@ export function createExellixGraphRuntime(opts) {
         }
         const resolvedGraphId = String(resolvedGraphIdRaw);
         assertCanonicalGraphDocument(graph, { jobId, graphId: resolvedGraphId });
-        assertRuntimeAliasConfigCoversGraph(graph, merged.aliasConfig, { modelConfig: merged.modelConfig, nodes: merged.nodes }, { jobId, graphId: resolvedGraphId });
         let runxClient = opts.runx;
         if (graphNeedsRunxClient(graph, merged.modelConfig)) {
             if (!runxClient) {
@@ -1569,7 +1575,6 @@ export function createExellixGraphRuntime(opts) {
                         nodeModelConfig: node.taskConfiguration?.modelConfig,
                         runtimeModelConfig: merged.modelConfig,
                         graphModelConfig: graph.modelConfig,
-                        runtimeAliasConfig: merged.aliasConfig,
                         conditionCtx: buildPredicateEvalContextForNode({
                             executionMemory: currentExecution,
                             jobMemory: currentJobMemory,

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

@@ -25,6 +25,7 @@ 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;
     llmCall?: RunTaskRequest['llmCall'];
     runTaskIdentity?: Record<string, unknown>;

package/dist/src/runtime/aiTasksStrategyPhases.js

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

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

@@ -9,7 +9,8 @@
  */
 import type { LlmCallConfig, RunTaskRequest } from '@exellix/ai-tasks';
 import type { SmartInputConfig, XynthesizedMemory } from '../types/aiTasksDerivedTypes.js';
-import type { GraphAiModelConfig, Job } from '../types/refs.js';
+import type { Job } from '../types/refs.js';
+import type { RunTaskModelConfigWire } from './graphAiModelConfig.js';
 import type { ExecutionStepOption } from '../types/options.js';
 import type { ResolvedNarrixWirePayload } from '../types/narrix.js';
 /** Reads task-node `taskConfiguration` keys forwarded to `@exellix/ai-tasks` `RunTaskRequest` (runtime strategy / Narrix wiring). */
@@ -45,7 +46,8 @@ export type BuildAiTasksRunTaskRequestArgs = {
     narrix?: ResolvedNarrixWirePayload;
     outputValidation?: RunTaskRequest['outputValidation'];
     diagnostics?: RunTaskRequest['diagnostics'];
-    modelConfig?: GraphAiModelConfig;
+    /** Resolved ai-tasks slot pair (`xynthesisModel` / `skillModel`) for this runTask phase. */
+    modelConfig?: RunTaskModelConfigWire;
     llmCall?: LlmCallConfig;
     identity?: Record<string, unknown>;
     executionMode?: 'default' | 'trace';

package/dist/src/runtime/canonicalModelUsed.js

@@ -14,7 +14,12 @@ export function resolveCanonicalModelUsed(response) {
             return direct.trim();
         const rawConfig = meta.rawConfig;
         if (isPlainObject(rawConfig)) {
-            const fromRaw = rawConfig.modelUsed ?? rawConfig.model ?? rawConfig.skillModel ?? rawConfig.xynthesisModel;
+            const fromRaw = rawConfig.modelUsed ??
+                rawConfig.model ??
+                rawConfig.skillModel ??
+                rawConfig.preActionModel ??
+                rawConfig.postActionModel ??
+                rawConfig.xynthesisModel;
             if (typeof fromRaw === 'string' && fromRaw.trim() !== '')
                 return fromRaw.trim();
         }

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

@@ -0,0 +1,37 @@
+import type { GraphAiModelConfig } from '../types/refs.js';
+/** Wire shape expected by `@exellix/ai-tasks` `RunTaskRequest.modelConfig`. */
+export type RunTaskModelConfigWire = {
+    xynthesisModel: string;
+    skillModel: string;
+};
+/** Profile names used when no modelConfig tier resolves. */
+export declare const DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG: GraphAiModelConfig;
+/**
+ * Canonical default concrete provider model ids (JSON-serializable).
+ * Derived from bundled `@x12i/ai-profiles` defaults for {@link DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG}.
+ */
+export declare const DEFAULT_GRAPH_AI_MODEL_IDS: GraphAiModelConfig;
+export type GraphAiModelConfigResolveContext = {
+    jobId?: string;
+    graphId?: string;
+    nodeId?: string;
+};
+/**
+ * True when a value looks like a concrete provider model id (host-resolved / post profile resolution).
+ */
+export declare function looksLikeConcreteModelId(value: string): boolean;
+/**
+ * True when a string is a valid graph-authored AI profile name (not a provider model id).
+ */
+export declare function isGraphAiProfileName(value: unknown): value is string;
+export declare function assertGraphAiProfileNameString(value: unknown, path: string, context?: GraphAiModelConfigResolveContext): asserts value is string;
+/**
+ * Resolves graph/runtime {@link GraphAiModelConfig} to concrete provider model ids.
+ * Profile names resolve via bundled `@x12i/ai-profiles`; concrete ids pass through unchanged.
+ */
+export declare function resolveGraphAiModelConfig(modelConfig: GraphAiModelConfig | undefined, context?: GraphAiModelConfigResolveContext): Promise<GraphAiModelConfig>;
+export type EngineModelPhase = 'pre' | 'main' | 'post';
+/**
+ * Maps resolved three-phase graph config to ai-tasks slot pair for a single runTask phase.
+ */
+export declare function toRunTaskModelConfigForPhase(config: GraphAiModelConfig, phase: EngineModelPhase): RunTaskModelConfigWire;

package/dist/src/runtime/graphAiModelConfig.js

@@ -0,0 +1,119 @@
+import { resolveAIProfile } from '@x12i/ai-profiles';
+import { ExellixGraphError } from '../errors/ExellixGraphError.js';
+import { ExellixGraphErrorCode } from '../errors/exellixGraphErrorCodes.js';
+import { isGraphAiModelConfig } from './modelConfigSelection.js';
+/** Profile names used when no modelConfig tier resolves. */
+export const DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG = {
+    preActionModel: 'cheap',
+    skillModel: 'balanced',
+    postActionModel: 'cheap',
+};
+/**
+ * Canonical default concrete provider model ids (JSON-serializable).
+ * Derived from bundled `@x12i/ai-profiles` defaults for {@link DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG}.
+ */
+export const DEFAULT_GRAPH_AI_MODEL_IDS = {
+    preActionModel: 'google/gemini-2.5-flash-lite',
+    skillModel: 'openai/gpt-5.4',
+    postActionModel: 'google/gemini-2.5-flash-lite',
+};
+const CONCRETE_MODEL_PREFIXES = [
+    'openrouter/',
+    'anthropic/',
+    'openai/',
+    'google/',
+    'x-ai/',
+    'meta-llama/',
+    'mistral/',
+    'cohere/',
+    'deepseek/',
+    'groq/',
+];
+/**
+ * True when a value looks like a concrete provider model id (host-resolved / post profile resolution).
+ */
+export function looksLikeConcreteModelId(value) {
+    const trimmed = value.trim();
+    if (trimmed === '')
+        return false;
+    if (trimmed.includes('/'))
+        return true;
+    const lower = trimmed.toLowerCase();
+    return CONCRETE_MODEL_PREFIXES.some((p) => lower.startsWith(p));
+}
+/**
+ * True when a string is a valid graph-authored AI profile name (not a provider model id).
+ */
+export function isGraphAiProfileName(value) {
+    if (typeof value !== 'string')
+        return false;
+    const trimmed = value.trim();
+    if (trimmed === '')
+        return false;
+    return !looksLikeConcreteModelId(trimmed);
+}
+export function assertGraphAiProfileNameString(value, path, context) {
+    if (!isGraphAiProfileName(value)) {
+        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_MODEL_CONFIG, `${path} must be an AI profile name (non-empty string without "/" or provider prefixes); got ${JSON.stringify(value)}`, context);
+    }
+}
+function formatResolvedModelId(provider, modelId) {
+    const mid = modelId.trim();
+    if (mid.includes('/'))
+        return mid;
+    const prov = provider.trim();
+    return prov ? `${prov}/${mid}` : mid;
+}
+async function resolveModelSlot(slot, context) {
+    const trimmed = slot.trim();
+    if (trimmed === '') {
+        throw new ExellixGraphError(ExellixGraphErrorCode.MODEL_CONFIG_INCOMPLETE, 'modelConfig slot must be a non-empty string', context);
+    }
+    if (looksLikeConcreteModelId(trimmed))
+        return trimmed;
+    try {
+        const resolved = await resolveAIProfile(trimmed, { source: 'bundled' });
+        return formatResolvedModelId(resolved.provider, resolved.modelId);
+    }
+    catch (err) {
+        const code = err?.code ?? 'UNKNOWN_PROFILE';
+        throw new ExellixGraphError(ExellixGraphErrorCode.MODEL_PROFILE_UNRESOLVED, `Unresolved AI profile "${trimmed}" (${String(code)})`, { ...context, profile: trimmed });
+    }
+}
+/**
+ * Resolves graph/runtime {@link GraphAiModelConfig} to concrete provider model ids.
+ * Profile names resolve via bundled `@x12i/ai-profiles`; concrete ids pass through unchanged.
+ */
+export async function resolveGraphAiModelConfig(modelConfig, context) {
+    if (!isGraphAiModelConfig(modelConfig)) {
+        throw new ExellixGraphError(ExellixGraphErrorCode.MODEL_CONFIG_INCOMPLETE, 'modelConfig must be { preActionModel: string, skillModel: string, postActionModel: string } with non-empty values', context);
+    }
+    const [preActionModel, skillModel, postActionModel] = await Promise.all([
+        resolveModelSlot(modelConfig.preActionModel, context),
+        resolveModelSlot(modelConfig.skillModel, context),
+        resolveModelSlot(modelConfig.postActionModel, context),
+    ]);
+    return { preActionModel, skillModel, postActionModel };
+}
+/**
+ * Maps resolved three-phase graph config to ai-tasks slot pair for a single runTask phase.
+ */
+export function toRunTaskModelConfigForPhase(config, phase) {
+    switch (phase) {
+        case 'pre':
+            return {
+                xynthesisModel: config.preActionModel,
+                skillModel: config.preActionModel,
+            };
+        case 'main':
+            return {
+                xynthesisModel: config.preActionModel,
+                skillModel: config.skillModel,
+            };
+        case 'post':
+            return {
+                xynthesisModel: config.postActionModel,
+                skillModel: config.postActionModel,
+            };
+    }
+}

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

@@ -1,46 +1,10 @@
-import type { Graph, GraphAiModelConfig, GraphModelAliasConfig, ModelConfigSelection } from '../types/refs.js';
-/** Fallback alias pair when no modelConfig tier resolves. */
-export declare const DEFAULT_MODEL_ALIAS = "default";
-export declare const DEFAULT_GRAPH_AI_MODEL_ALIAS_CONFIG: GraphAiModelConfig;
 /**
- * True when a string is a valid graph-authored model alias (not a provider model id).
+ * @deprecated Legacy alias-map exports removed in 7.1. Use {@link graphAiModelConfig.js} and `@x12i/ai-profiles`.
  */
-export declare function isModelAliasString(value: unknown): value is string;
-/** True when a value looks like a concrete provider model id (forbidden in graph JSON). */
-export declare function looksLikeConcreteModelId(value: string): boolean;
-export declare function assertGraphModelAliasString(value: unknown, path: string, context?: {
-    jobId?: string;
-    graphId?: string;
-    nodeId?: string;
-}): asserts value is string;
-export declare function mergeAliasConfigs(root?: GraphModelAliasConfig, node?: GraphModelAliasConfig): GraphModelAliasConfig;
-/**
- * Collects every alias name referenced by graph + optional runtime overrides (before resolution).
- * Always includes `default` because resolution may fall back to it.
- */
-export declare function collectModelAliasesUsedInGraph(graph: Pick<Graph, 'modelConfig' | 'nodes'>, runtime?: {
-    modelConfig?: ModelConfigSelection;
-    nodes?: Record<string, {
-        modelConfig?: GraphAiModelConfig;
-        aliasConfig?: GraphModelAliasConfig;
-    }>;
-}): Set<string>;
-export declare function assertRuntimeAliasConfigPresent(aliasConfig: GraphModelAliasConfig | undefined, context?: {
-    jobId?: string;
-    graphId?: string;
-}): asserts aliasConfig is GraphModelAliasConfig;
-/**
- * Ensures merged runtime alias map covers every alias used by the graph (+ runtime overrides).
- */
-export declare function assertRuntimeAliasConfigCoversGraph(graph: Pick<Graph, 'id' | 'modelConfig' | 'nodes'>, aliasConfig: GraphModelAliasConfig | undefined, runtime?: Parameters<typeof collectModelAliasesUsedInGraph>[1], context?: {
-    jobId?: string;
-    graphId?: string;
-}): void;
-/**
- * Resolves alias-only {@link GraphAiModelConfig} to concrete provider model ids via runtime map.
- */
-export declare function resolveGraphAiModelConfigAliases(modelConfig: GraphAiModelConfig | undefined, aliasConfig: GraphModelAliasConfig | undefined, context?: {
-    jobId?: string;
-    graphId?: string;
-    nodeId?: string;
-}): GraphAiModelConfig | undefined;
+export { DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, looksLikeConcreteModelId, isGraphAiProfileName, assertGraphAiProfileNameString, resolveGraphAiModelConfig, toRunTaskModelConfigForPhase, type RunTaskModelConfigWire, type EngineModelPhase, type GraphAiModelConfigResolveContext, } from './graphAiModelConfig.js';
+/** @deprecated Use {@link isGraphAiProfileName}. */
+export { isGraphAiProfileName as isModelAliasString } from './graphAiModelConfig.js';
+/** @deprecated Use {@link assertGraphAiProfileNameString}. */
+export { assertGraphAiProfileNameString as assertGraphModelAliasString } from './graphAiModelConfig.js';
+/** @deprecated Use {@link resolveGraphAiModelConfig}. */
+export { resolveGraphAiModelConfig as resolveGraphAiModelConfigAliases } from './graphAiModelConfig.js';

package/dist/src/runtime/modelAliasContract.js

@@ -1,129 +1,10 @@
-import { ExellixGraphError } from '../errors/ExellixGraphError.js';
-import { ExellixGraphErrorCode } from '../errors/exellixGraphErrorCodes.js';
-import { isGraphAiModelConfig, isModelConfigSelection } from './modelConfigSelection.js';
-/** Fallback alias pair when no modelConfig tier resolves. */
-export const DEFAULT_MODEL_ALIAS = 'default';
-export const DEFAULT_GRAPH_AI_MODEL_ALIAS_CONFIG = {
-    xynthesisModel: DEFAULT_MODEL_ALIAS,
-    skillModel: DEFAULT_MODEL_ALIAS,
-};
-const CONCRETE_MODEL_PREFIXES = ['openrouter/', 'anthropic/', 'openai/', 'google/', 'x-ai/', 'meta-llama/'];
 /**
- * True when a string is a valid graph-authored model alias (not a provider model id).
+ * @deprecated Legacy alias-map exports removed in 7.1. Use {@link graphAiModelConfig.js} and `@x12i/ai-profiles`.
  */
-export function isModelAliasString(value) {
-    if (typeof value !== 'string')
-        return false;
-    const trimmed = value.trim();
-    if (trimmed === '')
-        return false;
-    return !looksLikeConcreteModelId(trimmed);
-}
-/** True when a value looks like a concrete provider model id (forbidden in graph JSON). */
-export function looksLikeConcreteModelId(value) {
-    const trimmed = value.trim();
-    if (trimmed.includes('/'))
-        return true;
-    const lower = trimmed.toLowerCase();
-    return CONCRETE_MODEL_PREFIXES.some((p) => lower.startsWith(p));
-}
-export function assertGraphModelAliasString(value, path, context) {
-    if (!isModelAliasString(value)) {
-        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_MODEL_CONFIG, `${path} must be a model alias name (non-empty string without "/" or provider prefixes); got ${JSON.stringify(value)}`, context);
-    }
-}
-export function mergeAliasConfigs(root, node) {
-    const aliases = {};
-    for (const source of [root, node]) {
-        if (source == null || typeof source !== 'object' || Array.isArray(source))
-            continue;
-        for (const [alias, model] of Object.entries(source)) {
-            if (alias.trim() !== '' && typeof model === 'string' && model.trim() !== '') {
-                aliases[alias] = model;
-            }
-        }
-    }
-    return aliases;
-}
-function collectAliasesFromGraphAiModelConfig(config, out) {
-    if (!isGraphAiModelConfig(config))
-        return;
-    out.add(config.xynthesisModel.trim());
-    out.add(config.skillModel.trim());
-}
-function collectAliasesFromModelConfigSelection(selection, out) {
-    if (!isModelConfigSelection(selection))
-        return;
-    for (const c of selection.cases) {
-        collectAliasesFromGraphAiModelConfig(c.modelConfig, out);
-    }
-}
-/**
- * Collects every alias name referenced by graph + optional runtime overrides (before resolution).
- * Always includes `default` because resolution may fall back to it.
- */
-export function collectModelAliasesUsedInGraph(graph, runtime) {
-    const out = new Set([DEFAULT_MODEL_ALIAS]);
-    collectAliasesFromModelConfigSelection(graph.modelConfig, out);
-    for (const node of graph.nodes ?? []) {
-        const tn = node;
-        if (tn.type === 'finalizer')
-            continue;
-        collectAliasesFromModelConfigSelection(tn.taskConfiguration?.modelConfig, out);
-    }
-    if (runtime != null) {
-        collectAliasesFromModelConfigSelection(runtime.modelConfig, out);
-        if (runtime.nodes != null && typeof runtime.nodes === 'object') {
-            for (const nodeRuntime of Object.values(runtime.nodes)) {
-                if (nodeRuntime == null || typeof nodeRuntime !== 'object')
-                    continue;
-                collectAliasesFromGraphAiModelConfig(nodeRuntime.modelConfig, out);
-            }
-        }
-    }
-    return out;
-}
-export function assertRuntimeAliasConfigPresent(aliasConfig, context) {
-    if (aliasConfig == null ||
-        typeof aliasConfig !== 'object' ||
-        Array.isArray(aliasConfig) ||
-        Object.keys(aliasConfig).length === 0) {
-        throw new ExellixGraphError(ExellixGraphErrorCode.MODEL_ALIAS_CONFIG_REQUIRED, 'runtime.aliasConfig is required and must be a non-empty map of alias name → concrete model id', context);
-    }
-}
-/**
- * Ensures merged runtime alias map covers every alias used by the graph (+ runtime overrides).
- */
-export function assertRuntimeAliasConfigCoversGraph(graph, aliasConfig, runtime, context) {
-    assertRuntimeAliasConfigPresent(aliasConfig, context);
-    const needed = collectModelAliasesUsedInGraph(graph, runtime);
-    const missing = [];
-    for (const alias of needed) {
-        const concrete = aliasConfig[alias];
-        if (typeof concrete !== 'string' || concrete.trim() === '') {
-            missing.push(alias);
-        }
-    }
-    if (missing.length > 0) {
-        throw new ExellixGraphError(ExellixGraphErrorCode.MODEL_ALIAS_UNRESOLVED, `runtime.aliasConfig is missing concrete models for alias(es): ${missing.join(', ')}`, { ...context, graphId: context?.graphId ?? graph.id, missingAliases: missing });
-    }
-}
-function resolveModelAliasStrict(alias, aliasConfig, context) {
-    const concrete = aliasConfig[alias];
-    if (typeof concrete !== 'string' || concrete.trim() === '') {
-        throw new ExellixGraphError(ExellixGraphErrorCode.MODEL_ALIAS_UNRESOLVED, `Unresolved model alias "${alias}" — add it to runtime.aliasConfig (and runtime.nodes[nodeId].aliasConfig when scoped per node)`, { ...context, alias });
-    }
-    return concrete.trim();
-}
-/**
- * Resolves alias-only {@link GraphAiModelConfig} to concrete provider model ids via runtime map.
- */
-export function resolveGraphAiModelConfigAliases(modelConfig, aliasConfig, context) {
-    if (!isGraphAiModelConfig(modelConfig))
-        return undefined;
-    assertRuntimeAliasConfigPresent(aliasConfig, context);
-    return {
-        xynthesisModel: resolveModelAliasStrict(modelConfig.xynthesisModel, aliasConfig, context),
-        skillModel: resolveModelAliasStrict(modelConfig.skillModel, aliasConfig, context),
-    };
-}
+export { DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, looksLikeConcreteModelId, isGraphAiProfileName, assertGraphAiProfileNameString, resolveGraphAiModelConfig, toRunTaskModelConfigForPhase, } from './graphAiModelConfig.js';
+/** @deprecated Use {@link isGraphAiProfileName}. */
+export { isGraphAiProfileName as isModelAliasString } from './graphAiModelConfig.js';
+/** @deprecated Use {@link assertGraphAiProfileNameString}. */
+export { assertGraphAiProfileNameString as assertGraphModelAliasString } from './graphAiModelConfig.js';
+/** @deprecated Use {@link resolveGraphAiModelConfig}. */
+export { resolveGraphAiModelConfig as resolveGraphAiModelConfigAliases } from './graphAiModelConfig.js';

package/dist/src/runtime/modelConfigSelection.js

@@ -3,13 +3,16 @@ export function isGraphAiModelConfig(value) {
         return false;
     const o = value;
     const keys = Object.keys(o);
-    return (keys.length === 2 &&
-        keys.includes('xynthesisModel') &&
+    return (keys.length === 3 &&
+        keys.includes('preActionModel') &&
         keys.includes('skillModel') &&
-        typeof o.xynthesisModel === 'string' &&
-        o.xynthesisModel.trim() !== '' &&
+        keys.includes('postActionModel') &&
+        typeof o.preActionModel === 'string' &&
+        o.preActionModel.trim() !== '' &&
         typeof o.skillModel === 'string' &&
-        o.skillModel.trim() !== '');
+        o.skillModel.trim() !== '' &&
+        typeof o.postActionModel === 'string' &&
+        o.postActionModel.trim() !== '');
 }
 export function isEmptyConditionWhen(when) {
     if (when == null)

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

@@ -1,5 +1,5 @@
 import type { RunxClient } from '@x12i/runx';
-import type { GraphAiModelConfig, GraphModelAliasConfig, ModelConfigSelection, TaskNodeRuntimeObject } from '../types/refs.js';
+import type { GraphAiModelConfig, ModelConfigSelection, TaskNodeRuntimeObject } from '../types/refs.js';
 import { conditionWhenSignature, isEmptyConditionWhen } from './modelConfigSelection.js';
 import { type TaskNodeConditionEvalContext } from './taskNodeConditionsEvaluation.js';
 export type ResolveModelConfigForNodeArgs = {
@@ -7,7 +7,6 @@ export type ResolveModelConfigForNodeArgs = {
     nodeModelConfig?: unknown;
     runtimeModelConfig?: ModelConfigSelection;
     graphModelConfig?: ModelConfigSelection;
-    runtimeAliasConfig?: GraphModelAliasConfig;
     conditionCtx: TaskNodeConditionEvalContext;
     executionInput: Record<string, unknown>;
     runx?: RunxClient;
@@ -16,9 +15,11 @@ export type ResolveModelConfigForNodeArgs = {
     jobId?: string;
 };
 /**
- * Resolves effective model config for a task node (precedence + conditional cases + strict alias resolution).
- * Returns concrete provider model ids for `RunTaskRequest.modelConfig`.
+ * Resolves effective model config for a task node (precedence + conditional cases).
+ * Returns profile names (or host-resolved concrete ids from runtime overrides) for
+ * {@link toRunTaskModelConfigForPhase} / ai-tasks wire — not pre-resolved provider ids.
+ * Use {@link resolveGraphAiModelConfig} when concrete ids are required (observability, docs).
  */
 export declare function resolveModelConfigForNode(args: ResolveModelConfigForNodeArgs): Promise<GraphAiModelConfig>;
 export { conditionWhenSignature, isEmptyConditionWhen };
-export { resolveGraphAiModelConfigAliases, mergeAliasConfigs } from './modelAliasContract.js';
+export { resolveGraphAiModelConfig, toRunTaskModelConfigForPhase, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './graphAiModelConfig.js';

package/dist/src/runtime/resolveModelConfigForNode.js

@@ -1,6 +1,6 @@
 import { conditionWhenSignature, isEmptyConditionWhen, isGraphAiModelConfig, isModelConfigSelection, } from './modelConfigSelection.js';
 import { evaluateConditionWhen } from './taskNodeConditionsEvaluation.js';
-import { DEFAULT_GRAPH_AI_MODEL_ALIAS_CONFIG, mergeAliasConfigs, resolveGraphAiModelConfigAliases, } from './modelAliasContract.js';
+import { DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './graphAiModelConfig.js';
 async function selectFromCases(selection, ctx, executionInput, runx) {
     const cases = selection.cases;
     if (!Array.isArray(cases) || cases.length === 0)
@@ -34,24 +34,24 @@ async function resolveTier(value, ctx, executionInput, runx) {
     return undefined;
 }
 /**
- * Resolves effective model config for a task node (precedence + conditional cases + strict alias resolution).
- * Returns concrete provider model ids for `RunTaskRequest.modelConfig`.
+ * Resolves effective model config for a task node (precedence + conditional cases).
+ * Returns profile names (or host-resolved concrete ids from runtime overrides) for
+ * {@link toRunTaskModelConfigForPhase} / ai-tasks wire — not pre-resolved provider ids.
+ * Use {@link resolveGraphAiModelConfig} when concrete ids are required (observability, docs).
  */
 export async function resolveModelConfigForNode(args) {
-    const aliasConfig = mergeAliasConfigs(args.runtimeAliasConfig, args.runtimeNodeConfig?.aliasConfig);
-    const resolveCtx = { graphId: args.graphId, nodeId: args.nodeId, jobId: args.jobId };
     const staticHost = args.runtimeNodeConfig?.modelConfig;
     if (isGraphAiModelConfig(staticHost)) {
-        return resolveGraphAiModelConfigAliases(staticHost, aliasConfig, resolveCtx);
+        return staticHost;
     }
     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, resolveCtx);
+            return selected;
         }
     }
-    return resolveGraphAiModelConfigAliases(DEFAULT_GRAPH_AI_MODEL_ALIAS_CONFIG, aliasConfig, resolveCtx);
+    return DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG;
 }
 export { conditionWhenSignature, isEmptyConditionWhen };
-export { resolveGraphAiModelConfigAliases, mergeAliasConfigs } from './modelAliasContract.js';
+export { resolveGraphAiModelConfig, toRunTaskModelConfigForPhase, DEFAULT_GRAPH_AI_MODEL_IDS, DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG, } from './graphAiModelConfig.js';

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

@@ -4,6 +4,11 @@ import type { TaskNode } from '../types/refs.js';
 import type { StepAttemptRecord } from '../types/results.js';
 export type ResolvedStepRetryPolicy = Required<Pick<StepRetryPolicy, 'maxAttempts' | 'retryOnTimeout' | 'retryOnTokenLimit' | 'tokenBumpMultiplier' | 'tokenBumpCap' | 'baseMaxTokensFallback'>>;
 export declare function resolveStepRetryPolicy(graphPolicy: StepRetryPolicy | undefined, node: Pick<TaskNode, 'taskConfiguration'> | undefined): ResolvedStepRetryPolicy;
+/**
+ * Reads the effective completion cap from outbound `llmCall`.
+ * ai-tasks v8 canonical field is `maxTokensCap`; legacy `maxTokens` / `max_tokens` still honored.
+ */
+export declare function readMaxTokensFromRunTaskRequest(req: RunTaskRequest): number | undefined;
 export type RunTaskWithRetryResult = {
     response: RunTaskResponse;
     attempts: StepAttemptRecord[];

package/dist/src/runtime/stepRetry.js

@@ -25,9 +25,14 @@ export function resolveStepRetryPolicy(graphPolicy, node) {
 function readNum(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
 }
-function readMaxTokensFromRequest(req) {
+/**
+ * Reads the effective completion cap from outbound `llmCall`.
+ * ai-tasks v8 canonical field is `maxTokensCap`; legacy `maxTokens` / `max_tokens` still honored.
+ */
+export function readMaxTokensFromRunTaskRequest(req) {
     const llm = req.llmCall;
-    return (readNum(llm?.maxTokens) ??
+    return (readNum(llm?.maxTokensCap) ??
+        readNum(llm?.maxTokens) ??
         readNum(llm?.max_tokens));
 }
 function shallowCloneRunTaskRequest(req) {
@@ -45,12 +50,13 @@ function shallowCloneRunTaskRequest(req) {
     };
 }
 function applyTokenBump(workingReq, policy) {
-    const current = readMaxTokensFromRequest(workingReq) ?? policy.baseMaxTokensFallback;
+    const current = readMaxTokensFromRunTaskRequest(workingReq) ?? policy.baseMaxTokensFallback;
     const after = Math.min(policy.tokenBumpCap, Math.floor(current * policy.tokenBumpMultiplier));
-    workingReq.llmCall =
-        workingReq.llmCall != null && typeof workingReq.llmCall === 'object' && !Array.isArray(workingReq.llmCall)
-            ? { ...workingReq.llmCall, maxTokens: after }
-            : { maxTokens: after };
+    const bumped = workingReq.llmCall != null && typeof workingReq.llmCall === 'object' && !Array.isArray(workingReq.llmCall)
+        ? { ...workingReq.llmCall }
+        : {};
+    bumped.maxTokensCap = after;
+    workingReq.llmCall = bumped;
     return { before: current, after };
 }
 function classifyThrownError(err) {
@@ -134,7 +140,7 @@ export async function runRunTaskWithRetry(args) {
         }
         const endedAt = Date.now();
         const durationMs = endedAt - startedAt;
-        const maxTok = readMaxTokensFromRequest(workingReq);
+        const maxTok = readMaxTokensFromRunTaskRequest(workingReq);
         if (thrown != null) {
             const c = classifyThrownError(thrown);
             attempts.push({
@@ -171,7 +177,7 @@ export async function runRunTaskWithRetry(args) {
                     nodeId,
                     skillKey,
                     level: 'info',
-                    message: `step retry ${attemptIndex + 2}/${policy.maxAttempts}: token-limit bump maxTokens ${before} -> ${after}`,
+                    message: `step retry ${attemptIndex + 2}/${policy.maxAttempts}: token-limit bump maxTokensCap ${before} -> ${after}`,
                     data: { classification: c, maxTokensBefore: before, maxTokensAfter: after, attempt: attemptIndex + 1 },
                 });
             }
@@ -226,7 +232,7 @@ export async function runRunTaskWithRetry(args) {
                 nodeId,
                 skillKey,
                 level: 'info',
-                message: `step retry ${attemptIndex + 2}/${policy.maxAttempts}: token-limit bump maxTokens ${before} -> ${after}`,
+                message: `step retry ${attemptIndex + 2}/${policy.maxAttempts}: token-limit bump maxTokensCap ${before} -> ${after}`,
                 data: { classification: c, maxTokensBefore: before, maxTokensAfter: after, attempt: attemptIndex + 1 },
             });
         }

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

@@ -30,9 +30,9 @@ export type BuildTaskNodeRunTaskRequestArgs = {
     graphRunTaskId?: string;
     /** Host job id on `job.jobId` / `job.id`; defaults from `job` when omitted. */
     runTaskJobId?: string;
-    /** Alias-only selection; resolved via `aliasConfig` before building the request. */
+    /** Resolved or profile-name selection; resolved via `@x12i/ai-profiles` when building the request. */
     modelConfig?: GraphAiModelConfig;
-    /** Required when resolving `modelConfig` aliases for preflight (mirrors `runtime.aliasConfig`). */
+    /** @deprecated Unused since 7.1. */
     aliasConfig?: GraphModelAliasConfig;
     llmCall?: Record<string, unknown>;
     /** Runtime default merged with per-node `taskConfiguration.llmCall`. */
@@ -50,7 +50,7 @@ export type BuildTaskNodeRunTaskRequestArgs = {
  * Materialize the outbound `RunTaskRequest` graph-engine would send for a task node
  * (mirrors `executeNode` request assembly; does not run PRE strategy phases or `runTask`).
  */
-export declare function buildTaskNodeRunTaskRequest(args: BuildTaskNodeRunTaskRequestArgs): BuildTaskNodeRunTaskRequestResult;
+export declare function buildTaskNodeRunTaskRequest(args: BuildTaskNodeRunTaskRequestArgs): Promise<BuildTaskNodeRunTaskRequestResult>;
 export type ValidateTaskNodeRunTaskConfigArgs = BuildTaskNodeRunTaskRequestArgs;
 export type ValidateTaskNodeRunTaskConfigResult = {
     skipped: true;
@@ -62,7 +62,7 @@ export type ValidateTaskNodeRunTaskConfigResult = {
     request: RunTaskRequest;
 } & RunTaskValidationResult);
 /** Static ai-tasks validation on the graph-built {@link RunTaskRequest}. */
-export declare function validateTaskNodeRunTaskConfig(args: ValidateTaskNodeRunTaskConfigArgs): ValidateTaskNodeRunTaskConfigResult;
+export declare function validateTaskNodeRunTaskConfig(args: ValidateTaskNodeRunTaskConfigArgs): Promise<ValidateTaskNodeRunTaskConfigResult>;
 export type ValidateTaskNodeRunTaskInvokeArgs = BuildTaskNodeRunTaskRequestArgs & Omit<ValidateRunTaskInvokeParams, 'request'>;
 export type ValidateTaskNodeRunTaskInvokeResult = {
     skipped: true;

package/dist/src/runtime/taskNodeRunTaskPreflight.js

@@ -1,5 +1,5 @@
 import { analyzeRunTaskRequest, validateRunTaskConfig, validateRunTaskInvoke, } from '@exellix/ai-tasks';
-import { resolveGraphAiModelConfigAliases } from './modelAliasContract.js';
+import { toRunTaskModelConfigForPhase } from './graphAiModelConfig.js';
 import { resolveTaskKey } from './resolveTaskKey.js';
 import { isLocalSkillKey } from './localSkills/index.js';
 import { buildAiTasksRunTaskRequest, extractRunTaskStrategyOverrides, } from './buildAiTasksRunTaskRequest.js';
@@ -35,7 +35,7 @@ function mergeKnowledgePatchIntoRunTaskMemory(memory, patch) {
  * Materialize the outbound `RunTaskRequest` graph-engine would send for a task node
  * (mirrors `executeNode` request assembly; does not run PRE strategy phases or `runTask`).
  */
-export function buildTaskNodeRunTaskRequest(args) {
+export async function buildTaskNodeRunTaskRequest(args) {
     const node = args.node;
     if (node.type === 'finalizer') {
         return { runnable: false, skillKey: 'finalizer', reason: 'finalizer' };
@@ -122,13 +122,7 @@ export function buildTaskNodeRunTaskRequest(args) {
     });
     const metaStrats = node.taskConfiguration?.executionStrategies;
     const ov = node.taskConfiguration?.aiTasksOutputValidation;
-    const resolvedModelConfig = args.modelConfig != null && args.aliasConfig != null
-        ? resolveGraphAiModelConfigAliases(args.modelConfig, args.aliasConfig, {
-            graphId: args.graphId,
-            nodeId: String(node.id),
-            jobId: lifecycleJobId,
-        })
-        : args.modelConfig;
+    const mainRunTaskModelConfig = args.modelConfig != null ? toRunTaskModelConfigForPhase(args.modelConfig, 'main') : undefined;
     const request = buildAiTasksRunTaskRequest({
         skillKey,
         job: args.job,
@@ -153,7 +147,7 @@ export function buildTaskNodeRunTaskRequest(args) {
             ? ov
             : undefined,
         diagnostics: args.runTaskDiagnostics,
-        modelConfig: resolvedModelConfig ?? undefined,
+        modelConfig: mainRunTaskModelConfig,
         llmCall: effectiveLlmCall,
         identity: buildRunTaskIdentityEnvelope({
             base: args.runTaskIdentity,
@@ -173,8 +167,8 @@ export function buildTaskNodeRunTaskRequest(args) {
     return { runnable: true, skillKey, request };
 }
 /** Static ai-tasks validation on the graph-built {@link RunTaskRequest}. */
-export function validateTaskNodeRunTaskConfig(args) {
-    const built = buildTaskNodeRunTaskRequest(args);
+export async function validateTaskNodeRunTaskConfig(args) {
+    const built = await buildTaskNodeRunTaskRequest(args);
     if (!built.runnable) {
         return { skipped: true, skillKey: built.skillKey, reason: built.reason };
     }
@@ -183,7 +177,7 @@ export function validateTaskNodeRunTaskConfig(args) {
 }
 /** Config + payload + template path validation via ai-tasks {@link validateRunTaskInvoke}. */
 export async function validateTaskNodeRunTaskInvoke(args) {
-    const built = buildTaskNodeRunTaskRequest(args);
+    const built = await buildTaskNodeRunTaskRequest(args);
     if (!built.runnable) {
         return { skipped: true, skillKey: built.skillKey, reason: built.reason };
     }
@@ -203,7 +197,7 @@ export async function validateTaskNodeRunTaskInvoke(args) {
 }
 /** Catalox-backed skill request analysis on the graph-built {@link RunTaskRequest}. */
 export async function analyzeTaskNodeRunTaskRequest(args) {
-    const built = buildTaskNodeRunTaskRequest(args);
+    const built = await buildTaskNodeRunTaskRequest(args);
     if (!built.runnable) {
         return { skipped: true, skillKey: built.skillKey, reason: built.reason };
     }

package/dist/src/runtime/validateCanonicalGraphDocument.js

@@ -4,7 +4,7 @@ import { ExellixGraphErrorCode } from '../errors/exellixGraphErrorCodes.js';
 import { EXELLIX_VIRTUAL_BOUNDARY_NODE_METADATA_KEY } from '../inspection/types.js';
 import { getStructuredDataFilterPathViolations } from './dataFiltersEvaluation.js';
 import { conditionWhenSignature, countDefaultModelConfigCases, isEmptyConditionWhen, isGraphAiModelConfig, isModelConfigSelection, } from './modelConfigSelection.js';
-import { assertGraphModelAliasString } from './modelAliasContract.js';
+import { assertGraphAiProfileNameString } from './graphAiModelConfig.js';
 /** Top-level keys permitted on a canonical exellix-graph executable graph JSON document. */
 export const CANONICAL_GRAPH_TOP_LEVEL_KEYS = [
     'id',
@@ -279,7 +279,7 @@ function assertModelConfigSelection(value, path, context) {
         ? ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE
         : ExellixGraphErrorCode.NON_CANONICAL_GRAPH_DOCUMENT;
     if (isGraphAiModelConfig(value)) {
-        throw new ExellixGraphError(code, `${path}: flat { xynthesisModel, skillModel } was removed. Use { cases: [{ modelConfig: { xynthesisModel, skillModel } }] } (one case with no \`when\` for a single default).`, context);
+        throw new ExellixGraphError(code, `${path}: flat modelConfig was removed. Use { cases: [{ modelConfig: { preActionModel, skillModel, postActionModel } }] } (one case with no \`when\` for a single default).`, context);
     }
     if (!isModelConfigSelection(value)) {
         throw new ExellixGraphError(code, `${path} must be { cases: ModelConfigCase[] } where each case has modelConfig and optional when.`, context);
@@ -297,10 +297,11 @@ function assertModelConfigSelection(value, path, context) {
             throw new ExellixGraphError(code, `${casePath} must be a plain object.`, context);
         }
         if (!isGraphAiModelConfig(c.modelConfig)) {
-            throw new ExellixGraphError(code, `${casePath}.modelConfig must be { xynthesisModel: string, skillModel: string } with non-empty alias values.`, context);
+            throw new ExellixGraphError(code, `${casePath}.modelConfig must be { preActionModel: string, skillModel: string, postActionModel: string } with non-empty AI profile names.`, context);
         }
-        assertGraphModelAliasString(c.modelConfig.xynthesisModel, `${casePath}.modelConfig.xynthesisModel`, context);
-        assertGraphModelAliasString(c.modelConfig.skillModel, `${casePath}.modelConfig.skillModel`, context);
+        assertGraphAiProfileNameString(c.modelConfig.preActionModel, `${casePath}.modelConfig.preActionModel`, context);
+        assertGraphAiProfileNameString(c.modelConfig.skillModel, `${casePath}.modelConfig.skillModel`, context);
+        assertGraphAiProfileNameString(c.modelConfig.postActionModel, `${casePath}.modelConfig.postActionModel`, context);
         if (isEmptyConditionWhen(c.when)) {
             continue;
         }
@@ -321,10 +322,8 @@ function assertOptionalRuntimeFlatModelConfig(value, path, context) {
     if (value === undefined)
         return;
     if (!isGraphAiModelConfig(value)) {
-        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE, `${path} must be exactly { xynthesisModel: string, skillModel: string } alias names (runtime host override does not use cases).`, context);
+        throw new ExellixGraphError(ExellixGraphErrorCode.NON_CANONICAL_TASK_NODE, `${path} must be exactly { preActionModel: string, skillModel: string, postActionModel: string } (runtime host override may use concrete provider ids or profile names).`, context);
     }
-    assertGraphModelAliasString(value.xynthesisModel, `${path}.xynthesisModel`, context);
-    assertGraphModelAliasString(value.skillModel, `${path}.skillModel`, context);
 }
 function assertContextualKnowledgeScope(scope, nodeId, context) {
     if (scope === undefined)

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

@@ -37,8 +37,8 @@ export interface StepRetryPolicy {
     /** Upper bound for `maxTokens` after bump (default **16000**). */
     tokenBumpCap?: number;
     /**
-     * Used when neither `llmCall.maxTokens` nor `llmCall.max_tokens` is set on the outbound request
-     * (default **2000**). `modelConfig` is reserved for model selection.
+     * Used when `llmCall.maxTokensCap` (or legacy `maxTokens` / `max_tokens`) is unset on the outbound request
+     * before the first token-limit retry bump (default **2000**).
      */
     baseMaxTokensFallback?: number;
 }

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

@@ -13,18 +13,23 @@ export type TaskNodeExecutionPipelineStep = {
  * Type references for graph execution
  */
 /**
- * Alias-only AI model slot selection on graph model / node `modelConfig`.
- * Concrete provider model ids are supplied only via {@link GraphModelAliasConfig} at execution.
+ * Three-phase AI model selection on graph model / node `modelConfig`.
+ * Values are `@x12i/ai-profiles` profile names (`cheap`, `balanced`, `deep`, …) in graph JSON,
+ * or host-resolved concrete provider ids on runtime overrides.
  */
 export type GraphAiModelConfig = {
-    xynthesisModel: string;
+    preActionModel: string;
     skillModel: string;
+    postActionModel: string;
 };
-/** Runtime map: alias name → concrete provider model id (required on every `executeGraph`). */
+/**
+ * @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 resolution uses `@x12i/ai-profiles`. */
     aliasConfig?: GraphModelAliasConfig;
 };
 /** Backwards-readable alias for per-node runtime overrides keyed by task node id. */

package/dist/testkit/RealTasksClient.js

@@ -82,7 +82,11 @@ export class RealTasksClient {
             if (process.env.DEBUG_AI_PROVIDER === 'true') {
                 const mc = aiTasksRequest.modelConfig;
                 const effective = mc
-                    ? { xynthesisModel: mc.xynthesisModel, skillModel: mc.skillModel }
+                    ? {
+                        preActionModel: mc.preActionModel ?? mc.xynthesisModel,
+                        skillModel: mc.skillModel,
+                        postActionModel: mc.postActionModel ?? mc.skillModel,
+                    }
                     : aiTasksRequest.config
                         ? {
                             provider: aiTasksRequest.config.provider,

package/dist/testkit/testModelAliasRuntime.d.ts

@@ -1,14 +1,14 @@
 import type { Graph } from '../src/types/refs.js';
 import { createExellixGraphRuntime, type GraphRuntimeObject } from '../src/runtime/ExellixGraphRuntime.js';
-/** Maps every alias used by a graph (plus `default`) to `openrouter/<alias>` for unit tests. */
-export declare function buildTestAliasConfig(graph: Pick<Graph, 'modelConfig' | 'nodes'>, runtimePartial?: Pick<GraphRuntimeObject, 'modelConfig' | 'nodes'> & {
-    aliasConfig?: Record<string, string>;
-}): Record<string, string>;
-/** Merges test alias bindings into a runtime object (required for executeGraph in 7.x). */
-export declare function withTestAliasRuntime(graph: Pick<Graph, 'id' | 'modelConfig' | 'nodes'>, runtime: Partial<GraphRuntimeObject> & Pick<GraphRuntimeObject, 'jobId' | 'job'>): GraphRuntimeObject;
 type CreateOpts = Parameters<typeof createExellixGraphRuntime>[0];
 /**
- * Testkit runtime that auto-injects `runtime.aliasConfig` on every `executeGraph` call.
+ * Testkit runtime for graphs using `@x12i/ai-profiles` (no `runtime.aliasConfig` required).
  */
 export declare function createTestExellixGraphRuntime(opts: CreateOpts): ReturnType<typeof createExellixGraphRuntime>;
+/** @deprecated Alias map test helper removed in 7.1 — profiles resolve via `@x12i/ai-profiles`. */
+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,24 +1,6 @@
 import { createExellixGraphRuntime, } from '../src/runtime/ExellixGraphRuntime.js';
-import { collectModelAliasesUsedInGraph } from '../src/runtime/modelAliasContract.js';
-/** Maps every alias used by a graph (plus `default`) to `openrouter/<alias>` for unit tests. */
-export function buildTestAliasConfig(graph, runtimePartial) {
-    const needed = collectModelAliasesUsedInGraph(graph, runtimePartial);
-    const map = {};
-    for (const alias of needed) {
-        map[alias] = `openrouter/${alias}`;
-    }
-    return { ...map, ...(runtimePartial?.aliasConfig ?? {}) };
-}
-/** Merges test alias bindings into a runtime object (required for executeGraph in 7.x). */
-export function withTestAliasRuntime(graph, runtime) {
-    const aliasConfig = buildTestAliasConfig(graph, runtime);
-    return {
-        ...runtime,
-        aliasConfig,
-    };
-}
 /**
- * Testkit runtime that auto-injects `runtime.aliasConfig` on every `executeGraph` call.
+ * Testkit runtime for graphs using `@x12i/ai-profiles` (no `runtime.aliasConfig` required).
  */
 export function createTestExellixGraphRuntime(opts) {
     const runtime = createExellixGraphRuntime(opts);
@@ -33,8 +15,16 @@ export function createTestExellixGraphRuntime(opts) {
             : { agentId: 'test-agent', jobType: 'unit-test' };
         return executeGraph({
             ...input,
-            runtime: withTestAliasRuntime(input.model, { ...base, jobId, job }),
+            runtime: { ...base, jobId, job },
         });
     };
     return runtime;
 }
+/** @deprecated Alias map test helper removed in 7.1 — profiles resolve via `@x12i/ai-profiles`. */
+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.0.1",
+  "version": "7.2.0",
   "type": "module",
   "description": "Graph executor SDK",
   "main": "dist/src/index.js",
@@ -18,6 +18,7 @@
   },
   "files": [
     "dist/**",
+    "scripts/patch-ai-tasks-xynthesis-export.mjs",
     ".env.example",
     "CHANGELOG.md",
     "README.md"
@@ -25,11 +26,12 @@
   "scripts": {
     "prebuild": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true, maxRetries: 10, retryDelay: 100 })\"",
     "build": "tsc",
-    "test": "npm run build && npm run check:no-legacy && node --test --test-force-exit tests/model-alias-contract.test.ts tests/reports-fixtures-pre-synthesis.test.ts tests/passthrough-parity.test.ts",
-    "test:full": "npm run build && npm run check:no-legacy && tsx --test --test-force-exit tests/graph-engine.test.ts tests/passthrough-parity.test.ts tests/task-node-run-task-preflight.test.ts tests/reports-fixtures-pre-synthesis.test.ts tests/model-alias-contract.test.ts",
+    "test": "npm run build && npm run check:no-legacy && node scripts/patch-ai-tasks-xynthesis-export.mjs && node --test --test-force-exit tests/model-alias-contract.test.ts tests/reports-fixtures-pre-synthesis.test.ts tests/passthrough-parity.test.ts tests/step-retry-llm-call.test.ts",
+    "test:full": "npm run build && npm run check:no-legacy && node scripts/patch-ai-tasks-xynthesis-export.mjs && tsx --test --test-force-exit tests/graph-engine.test.ts tests/passthrough-parity.test.ts tests/task-node-run-task-preflight.test.ts tests/reports-fixtures-pre-synthesis.test.ts tests/model-alias-contract.test.ts tests/step-retry-llm-call.test.ts",
     "run:pre-synthesis": "npm run build && node --env-file=.env scripts/run-pre-synthesis-graph.mjs",
     "check:no-legacy": "node scripts/check-no-legacy.mjs",
     "lint": "eslint src testkit --ext .ts",
+    "postinstall": "node scripts/patch-ai-tasks-xynthesis-export.mjs",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -49,11 +51,12 @@
     "access": "public"
   },
   "dependencies": {
-    "@exellix/ai-tasks": "^8.0.0",
-    "@x12i/activix": "^7.1.0",
+    "@exellix/ai-tasks": "^8.0.7",
+    "@x12i/activix": "^8.0.0",
+    "@x12i/ai-profiles": "^1.2.0",
     "@x12i/catalox": "^5.1.1",
     "@x12i/env": "^4.0.1",
-    "@x12i/funcx": "^4.0.2",
+    "@x12i/funcx": "^4.2.0",
     "@x12i/graphenix": "^2.5.0",
     "@x12i/graphenix-format": "^2.0.0",
     "@x12i/logxer": "^4.3.6",

package/scripts/patch-ai-tasks-xynthesis-export.mjs

@@ -0,0 +1,22 @@
+/**
+ * Workaround: @exellix/ai-tasks@8.0.7 re-exports MODEL_CAPABILITIES from @exellix/xynthesis,
+ * but xynthesis 4.0.x removed that export (capabilities come from getModelCapabilities / ai-profiles).
+ * Remove the broken re-export so graph-engine and tests can import @exellix/ai-tasks.
+ */
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const aiTasksRoot = join(process.cwd(), 'node_modules', '@exellix', 'ai-tasks', 'dist');
+const broken =
+  'export { buildInvokeAttemptSummary, ACTION_OUTPUT_DEFAULTS, MODEL_CAPABILITIES } from "@exellix/xynthesis";';
+const fixed =
+  'export { buildInvokeAttemptSummary, ACTION_OUTPUT_DEFAULTS } from "@exellix/xynthesis";';
+
+for (const file of ['index.js', 'index.d.ts']) {
+  const path = join(aiTasksRoot, file);
+  if (!existsSync(path)) continue;
+  const text = readFileSync(path, 'utf8');
+  if (!text.includes(broken)) continue;
+  writeFileSync(path, text.replace(broken, fixed), 'utf8');
+  console.log(`[patch-ai-tasks-xynthesis-export] patched ${file}`);
+}