@exellix/graph-engine 8.0.0 → 8.0.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 8.0.1
+
+### Changed
+
+- **Zero local compile workarounds:** removed local migration/finalizer patches; `compileExellixExecutablePlan` uses `@x12i/graphenix-authoring-format` ≥1.0.2 and `@x12i/graphenix-plan-compiler` ≥1.0.1 only.
+- Re-export `migrateLegacyGraphModelObjectToGraphenixExecutable` from authoring-format (upstream name; no exellix alias).
+- **Docs / layout:** compile helper lives under `src/compile/`; execute path no longer runs response migration (compile-only).
+
 ## 8.0.0
 
 ### Breaking
@@ -11,7 +19,7 @@
 ### Added
 
 - **`@x12i/graphenix-*` integration:** plan validation, deferred gates, trace events (`ExecuteGraphResult.trace`), and exports for `ExecutableGraphPlanV2`.
-- **`compileExellixExecutablePlan`**, **`migrateExellixGraphModelToAuthoring`** — host compile helpers for legacy exellix `GraphModelObject`.
+- **`compileExellixExecutablePlan`**, **`migrateLegacyGraphModelObjectToGraphenixExecutable`** (re-export from `@x12i/graphenix-authoring-format`) — host compile helpers for legacy exellix `GraphModelObject`.
 - **`buildAuthoringStudioGraphExecutionRequest`** re-export from `@x12i/graphenix-execute-envelope`.
 
 See [`BREAKING-CHANGES.md`](BREAKING-CHANGES.md) §8.0.0.

package/README.md

@@ -43,7 +43,7 @@ The **`runTask`** wire contract (identity, canonical **`input`**, optional extra
 
 An executable graph model object may have **only** these **top-level** keys: `id`, `version`, `modelConfig`, `jobKnowledge`, `nodes`, `edges`, `variables`, `response`, `metadata`. The required root **`response`** is the single executable final response contract used to build `ExecuteGraphResult.finalOutput`. Document-model and authoring fields (`name`, `description`, `exellixContractTarget`, `graphExecution`, `graphEntry`, `catalogRequests`, and similar) belong **under `metadata`** only. Node-scoped `taskKnowledge` belongs under each task node, not at the model root. Runtime state (`input`, `jobMemory`, `taskMemory`, `executionMemory`, `outputsMemory`, per-run options) belongs under the execution request’s **`runtime`** object and is rejected on the model. **`runtime.modelConfig`**, **`runtime.aliasConfig`**, and **`runtime.nodes[id].modelConfig`** were removed in **7.7** — model profiles belong on the graph document only.
 
-`metadata.graphExecution` can document graph execution defaults and labels, including `mode: 'forward' | 'backward' | 'hybrid'`, optional `goalNodeId`, optional `dimension`, `outputMode: 'mappedAggregation' | 'lastExitNode'`, `coreObjective`, optional `nodesResponses`, and metadata-only `flowOutline: 'linearSequence' | 'convergingParallelFlow'`. Planner mode still comes from `executeGraph({ model, runtime }).runtime.mode`; `outputMode` does not decide the returned `finalOutput`.
+`metadata.graphExecution` can document graph execution defaults and labels, including `mode: 'forward' | 'backward' | 'hybrid'`, optional `goalNodeId`, optional `dimension`, `outputMode: 'mappedAggregation' | 'lastExitNode'`, `coreObjective`, optional `nodesResponses`, and metadata-only `flowOutline: 'linearSequence' | 'convergingParallelFlow'`. Planner mode comes from `plan.schedulingPolicy.mode` or `runtime.mode`; `outputMode` does not decide the returned `finalOutput`.
 
 Enforcement: `executeGraph`, `createExellixGraphRuntime().executeGraph`, `executeNode` when a graph is passed in context, `inspectGraph`, `inspectGraphContracts`, `validateCatalogPlanning`, and Catalox graph validators call this check. Failures throw `ExellixGraphError` with code `NON_CANONICAL_GRAPH_DOCUMENT`. For CI or custom loaders, call **`assertCanonicalGraphDocument`** (exported from the package root) on parsed JSON before execution. **`loadGraph`** returns whatever the loader parsed; validation runs when you execute or inspect, not necessarily on load.
 
@@ -57,7 +57,7 @@ npm install @exellix/graph-engine
 
 ### Execution matrix hosts (`@exellix/exellix-runtime`) — documentation only for the engine
 
-Matrix **claim**, **rows**, and **retry policy** live outside this package. If your host wires **matrix → graph run**, see [.docs/execution-matrix-handoff.md](.docs/execution-matrix-handoff.md) for how **you** should inject `runtime.executeGraph`, resolve **`metadata.graphEntry` per model**, seed **`runtime.executionMemory`**, and pass **`runtime.jobId`** (see [Run identity](#run-identity-host-jobid-and-engine-taskid) below). Helpers such as **`buildMatrixJobForGraphRun`** align **`id`** and **`job.jobId`** on the `job` object so you can call **`runtime.executeGraph({ model, runtime: { jobId: job.jobId, job, … } })`**. Those exports are **optional helpers for callers**; they do **not** expand graph-engine’s role beyond **executing the single run** when invoked.
+Matrix **claim**, **rows**, and **retry policy** live outside this package. If your host wires **matrix → graph run**, see [.docs/execution-matrix-handoff.md](.docs/execution-matrix-handoff.md) for how **you** should inject `runtime.executeGraph`, compile **`GraphModelObject` → plan**, resolve **`metadata.graphEntry` per model**, seed **`runtime.executionMemory`**, and pass **`runtime.jobId`**. Helpers such as **`buildMatrixJobForGraphRun`** align **`id`** and **`job.jobId`** on the `job` object so you can call **`runtime.executeGraph({ plan, runtime: { jobId: job.jobId, job, … } })`**. Those exports are **optional helpers for callers**; they do **not** expand graph-engine’s role beyond **executing the single run** when invoked.
 
 ### Configuration (`.env`)
 
@@ -213,10 +213,11 @@ interface ExecuteGraphResult {
   runLogOmittedCount?: number;
   logxerCorrelationId?: string;
   debug?: { nodes: NodeTraceEntry[] }; // populated only when debugMode: true
-  graphAudit?: {
-    source: 'model';
-    contentSha256: string; // stable JSON + SHA-256 of supplied model (audit / matrix persistence)
+  planAudit?: {
+    planHash: string;
+    source: string;
   };
+  trace?: unknown;
 }
 ```
 
@@ -237,13 +238,11 @@ const runtime = createExellixGraphRuntime({
   playgroundReporter,
 });
 
+const plan = compileExellixExecutablePlan(graphModel, graphRuntime);
+
 await runtime.executeGraph({
-  model,
-  runtime: {
-    jobId: 'job-123',
-    job,
-    input,
-  },
+  plan,
+  runtime: graphRuntime,
 });
 
 // Inspect full node request/response payloads in memory.

package/dist/src/{adapters → compile}/compileExellixExecutablePlan.d.ts

@@ -3,6 +3,7 @@ import type { Graph, GraphModelObject } from '../types/refs.js';
 import type { GraphRuntimeObject } from '../runtime/ExellixGraphRuntime.js';
 export type CompileExellixExecutablePlanOptions = CompileExecutablePlanV2Options;
 /**
- * Host/test helper: exellix graph model + runtime → validated v2 executable plan.
+ * Host/test helper: exellix {@link GraphModelObject} + runtime → validated v2 executable plan.
+ * Migration and plan compilation live in `@x12i/graphenix-*`; graph-engine does not duplicate format logic.
  */
 export declare function compileExellixExecutablePlan(model: Graph | GraphModelObject, runtime: GraphRuntimeObject, options?: CompileExellixExecutablePlanOptions): ExecutableGraphPlanV2;

package/dist/src/compile/compileExellixExecutablePlan.js

@@ -0,0 +1,24 @@
+import { migrateLegacyGraphModelObjectToGraphenixExecutable, } from '@x12i/graphenix-authoring-format';
+import { compileExecutablePlanV2 } from '@x12i/graphenix-plan-compiler';
+import { validateExecutablePlan } from '@x12i/graphenix-plan-format';
+import { EXELLIX_STRUCTURED_DATA_FILTERS_V1 } from '../types/refs.js';
+import { migrateLegacyGraphResponse } from '../runtime/graphResponseMigration.js';
+/** Exellix host hooks passed into upstream {@link migrateLegacyGraphModelObjectToGraphenixExecutable}. */
+const EXELLIX_LEGACY_MIGRATE_OPTIONS = {
+    preprocessLegacy: (legacy) => migrateLegacyGraphResponse(legacy).graph,
+    structuredDataFiltersVersion: EXELLIX_STRUCTURED_DATA_FILTERS_V1,
+};
+/**
+ * Host/test helper: exellix {@link GraphModelObject} + runtime → validated v2 executable plan.
+ * Migration and plan compilation live in `@x12i/graphenix-*`; graph-engine does not duplicate format logic.
+ */
+export function compileExellixExecutablePlan(model, runtime, options) {
+    const authoring = migrateLegacyGraphModelObjectToGraphenixExecutable(model, EXELLIX_LEGACY_MIGRATE_OPTIONS);
+    const plan = compileExecutablePlanV2(authoring, runtime, options);
+    const validation = validateExecutablePlan(plan);
+    if (!validation.valid) {
+        const summary = validation.errors.map((e) => `${e.path}: ${e.message}`).join('; ');
+        throw new Error(`compileExellixExecutablePlan: invalid plan: ${summary}`);
+    }
+    return plan;
+}

package/dist/src/index.d.ts

@@ -91,9 +91,10 @@ export type { MigrateGraphResponseResult } from './runtime/graphResponseMigratio
 export { applyAiTaskProfileWebScopingToNarrix, mapAiTaskProfileQuestionsToWebScopeQuestions, } from './runtime/applyAiTaskProfileWebScopingToNarrix.js';
 export { createExellixGraphRuntime } from './runtime/ExellixGraphRuntime.js';
 export type { ExecutableGraphPlanV2, NodeExecutionPlan, ExecutionUnitPlanV2, } from '@x12i/graphenix-executable-contracts';
-export { compileExellixExecutablePlan } from './adapters/compileExellixExecutablePlan.js';
-export type { CompileExellixExecutablePlanOptions } from './adapters/compileExellixExecutablePlan.js';
-export { migrateExellixGraphModelToAuthoring } from './adapters/migrateExellixGraphModelToAuthoring.js';
+export { compileExellixExecutablePlan } from './compile/compileExellixExecutablePlan.js';
+export type { CompileExellixExecutablePlanOptions } from './compile/compileExellixExecutablePlan.js';
+export { migrateLegacyGraphModelObjectToGraphenixExecutable, } from '@x12i/graphenix-authoring-format';
+export type { LegacyGraphModelObject, MigrateLegacyGraphModelOptions, } from '@x12i/graphenix-authoring-format';
 export { buildGraphExecutionRequestFromStudioExecute as buildAuthoringStudioGraphExecutionRequest } from '@x12i/graphenix-execute-envelope';
 export type { RunTaskRequest, RunTaskResponse, TasksClientLike, GraphLoader as RuntimeGraphLoader, ExecuteGraphInput, GraphExecutionRequest, GraphRuntimeObject, GraphKnowledgeResolver, GraphKnowledgeResolverContext, ExecuteGraphResult, ExellixGraphRuntimeOptions, } from './runtime/ExellixGraphRuntime.js';
 export type { PlanStatus, GraphPlan, GraphEngine, GraphEngineFactory, } from './runtime/GraphEngine.js';

package/dist/src/index.js

@@ -67,8 +67,8 @@ export { migrateLegacyGraphResponse, migrateLegacyGraphResponseDefinition, } fro
 export { applyAiTaskProfileWebScopingToNarrix, mapAiTaskProfileQuestionsToWebScopeQuestions, } from './runtime/applyAiTaskProfileWebScopingToNarrix.js';
 // New runtime with injection seam
 export { createExellixGraphRuntime } from './runtime/ExellixGraphRuntime.js';
-export { compileExellixExecutablePlan } from './adapters/compileExellixExecutablePlan.js';
-export { migrateExellixGraphModelToAuthoring } from './adapters/migrateExellixGraphModelToAuthoring.js';
+export { compileExellixExecutablePlan } from './compile/compileExellixExecutablePlan.js';
+export { migrateLegacyGraphModelObjectToGraphenixExecutable, } from '@x12i/graphenix-authoring-format';
 export { buildGraphExecutionRequestFromStudioExecute as buildAuthoringStudioGraphExecutionRequest } from '@x12i/graphenix-execute-envelope';
 // Testkit (in-memory loader, dep engine, recording client — sample NARRIX tasks: `@exellix/graph-engine/testkit`)
 export { InMemoryGraphLoader, DepGraphEngineFactory } from '../testkit/index.js';

package/dist/src/runtime/ExellixGraphRuntime.js

@@ -25,7 +25,6 @@ import { executeDeterministicFinalizer, executeSynthesizeFinalizer } from "./fin
 import { createFinalizerError } from "./finalizers/errors.js";
 import { assertCanonicalGraphRuntimeObject } from "./validateCanonicalGraphRuntime.js";
 import { applyGraphResponseDefinition } from "./graphResponseMapping.js";
-import { migrateLegacyGraphResponse } from "./graphResponseMigration.js";
 import { buildAiTasksObservabilityRecord } from "./aiTasksObservability.js";
 import { buildMainLlmCallForRunTask, buildRunTaskIdentityEnvelope, shouldForwardRunTaskTraceMode, } from "./runTaskAugments.js";
 import { buildRunLog, extractLogxerCorrelationFromMetadata, extractTaskRunLogFromMetadata, resolveRunLogLimits, } from "./buildRunLog.js";
@@ -1160,7 +1159,7 @@ export function createExellixGraphRuntime(opts) {
         const { plan: suppliedPlan, runtime } = input;
         const { plan } = preparePlanExecuteEntry(suppliedPlan, runtime);
         const materialized = embeddedGraphToExellixGraph(plan);
-        const graph = migrateLegacyGraphResponse(materialized).graph;
+        const graph = materialized;
         const merged = mergeExellixGraphRuntimeInvocation(runtime, opts);
         const scheduling = plan.schedulingPolicy;
         const plannerMode = scheduling?.mode ?? runtime.mode;

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

@@ -2,7 +2,7 @@
  * Host helpers for execution-matrix style orchestrators (e.g. `@exellix/exellix-runtime`).
  *
  * Graph-engine does not call matrix claim APIs; the host injects `executeGraph` and supplies
- * a `{ model, runtime }` request with per-graph `GraphEntryContract` + seeded
+ * a `{ plan, runtime }` request with per-graph `GraphEntryContract` + seeded
  * `runtime.executionMemory` objects built here.
  */
 import type { Graph, GraphEntryContract, GraphEntryExecutionInputSpec, Job } from '../types/refs.js';

package/dist/src/runtime/executionMatrixHost.js

@@ -2,10 +2,10 @@
  * Host helpers for execution-matrix style orchestrators (e.g. `@exellix/exellix-runtime`).
  *
  * Graph-engine does not call matrix claim APIs; the host injects `executeGraph` and supplies
- * a `{ model, runtime }` request with per-graph `GraphEntryContract` + seeded
+ * a `{ plan, runtime }` request with per-graph `GraphEntryContract` + seeded
  * `runtime.executionMemory` objects built here.
  */
-import { compileExellixExecutablePlan } from '../adapters/compileExellixExecutablePlan.js';
+import { compileExellixExecutablePlan } from '../compile/compileExellixExecutablePlan.js';
 import { mergeGraphDocumentModel } from '../types/refs.js';
 import { createExellixGraphRuntime } from './ExellixGraphRuntime.js';
 import { selectByPath, writeByPath } from './pathExpr.js';

package/dist/src/runtime/studioGraphExecuteRequest.js

@@ -1,4 +1,4 @@
-import { compileExellixExecutablePlan } from '../adapters/compileExellixExecutablePlan.js';
+import { compileExellixExecutablePlan } from '../compile/compileExellixExecutablePlan.js';
 import { ExellixGraphError } from '../errors/ExellixGraphError.js';
 import { ExellixGraphErrorCode } from '../errors/exellixGraphErrorCodes.js';
 /**

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

@@ -680,7 +680,7 @@ export interface GraphDocumentMetadata {
     graphResponse?: GraphResponseContract;
     /**
      * Graph execution defaults and labels.
-     * Planner mode is still selected by `executeGraph({ model, runtime }).runtime.mode` and defaults to `forward`;
+     * Planner mode is still selected by `executeGraph({ plan, runtime }).runtime.mode` (or plan.schedulingPolicy) and defaults to `forward`;
      * output labels in this block shape `stepsResponses`, not `ExecuteGraphResult.finalOutput`.
      */
     graphExecution?: GraphExecutionDefaults;

package/dist/testkit/buildExecuteGraphInput.js

@@ -1,4 +1,4 @@
-import { compileExellixExecutablePlan } from '../src/adapters/compileExellixExecutablePlan.js';
+import { compileExellixExecutablePlan } from '../src/compile/compileExellixExecutablePlan.js';
 /** Builds `{ plan, runtime }` for tests and hosts that still author exellix GraphModelObject JSON. */
 export function buildExecuteGraphInput(model, runtime) {
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exellix/graph-engine",
-  "version": "8.0.0",
+  "version": "8.0.1",
   "type": "module",
   "description": "Graph executor SDK",
   "main": "dist/src/index.js",
@@ -58,11 +58,13 @@
     "@x12i/env": "4.0.1",
     "@x12i/funcx": "4.4.4",
     "@x12i/graphenix": "2.5.0",
+    "@x12i/graphenix-authoring-format": "^1.0.2",
     "@x12i/graphenix-executable-contracts": "^1.0.0",
+    "@x12i/graphenix-executable-format": "^2.0.1",
     "@x12i/graphenix-execute-envelope": "^1.0.0",
     "@x12i/graphenix-format": "2.0.0",
+    "@x12i/graphenix-plan-compiler": "^1.0.1",
     "@x12i/graphenix-plan-format": "^1.0.0",
-    "@x12i/graphenix-plan-compiler": "^1.0.0",
     "@x12i/graphenix-trace-format": "^1.0.0",
     "@x12i/logxer": "^4.6.0",
     "@x12i/memorix-descriptors": "1.6.0",
@@ -73,7 +75,6 @@
   },
   "devDependencies": {
     "@types/node": "25.9.1",
-    "@x12i/graphenix-authoring-format": "^1.0.1",
     "tsx": "4.22.3",
     "typescript": "6.0.3"
   }

package/dist/src/adapters/compileExellixExecutablePlan.js

@@ -1,18 +0,0 @@
-import { compileExecutablePlanV2 } from '@x12i/graphenix-plan-compiler';
-import { validateExecutablePlan } from '@x12i/graphenix-plan-format';
-import { migrateExellixGraphModelToAuthoring } from './migrateExellixGraphModelToAuthoring.js';
-import { patchFinalizerPlansOnExecutablePlan } from './patchFinalizerPlans.js';
-/**
- * Host/test helper: exellix graph model + runtime → validated v2 executable plan.
- */
-export function compileExellixExecutablePlan(model, runtime, options) {
-    const authoring = migrateExellixGraphModelToAuthoring(model);
-    const compiled = compileExecutablePlanV2(authoring, runtime, options);
-    const plan = patchFinalizerPlansOnExecutablePlan(compiled, runtime);
-    const validation = validateExecutablePlan(plan);
-    if (!validation.valid) {
-        const summary = validation.errors.map((e) => `${e.path}: ${e.message}`).join('; ');
-        throw new Error(`compileExellixExecutablePlan: invalid plan: ${summary}`);
-    }
-    return plan;
-}

package/dist/src/adapters/migrateExellixGraphModelToAuthoring.d.ts

@@ -1,6 +0,0 @@
-import { type AuthoringGraphDocument } from '@x12i/graphenix-executable-contracts';
-import type { Graph, GraphModelObject } from '../types/refs.js';
-/**
- * Converts exellix {@link GraphModelObject} to graphenix {@link AuthoringGraphDocument} for plan compilation.
- */
-export declare function migrateExellixGraphModelToAuthoring(model: Graph | GraphModelObject): AuthoringGraphDocument;

package/dist/src/adapters/migrateExellixGraphModelToAuthoring.js

@@ -1,273 +0,0 @@
-import { GRAPHENIX_FORMAT_VERSION } from '@x12i/graphenix-core';
-import { EXECUTABLE_PROFILE_NAMESPACE, EXECUTABLE_PROFILE_VERSION, FINALIZER_NODE_KIND, FINALIZER_NODE_PROFILE, TASK_NODE_KIND, TASK_NODE_PROFILE, } from '@x12i/graphenix-executable-contracts';
-import { EXELLIX_STRUCTURED_DATA_FILTERS_V1 } from '../types/refs.js';
-import { DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG } from '../runtime/graphAiModelConfig.js';
-import { migrateLegacyGraphResponse } from '../runtime/graphResponseMigration.js';
-function isPlainRecord(v) {
-    return v != null && typeof v === 'object' && !Array.isArray(v);
-}
-function aliasToProfileChoice(value) {
-    const trimmed = value.trim();
-    if (trimmed.includes('/'))
-        return { kind: 'profileChoice', key: trimmed };
-    const shortcuts = {
-        cheap: 'cheap/default',
-        balanced: 'vol/default',
-        deep: 'deep/openai_deep',
-        pro: 'pro/default',
-    };
-    const key = shortcuts[trimmed] ?? `${trimmed}/default`;
-    return { kind: 'profileChoice', key };
-}
-function exellixModelConfigToExecutable(modelConfig) {
-    if (!modelConfig?.cases?.length)
-        return undefined;
-    const cases = modelConfig.cases.map((c, index) => {
-        const mc = c.modelConfig;
-        const modelConfigOut = {};
-        if (mc.preActionModel != null && String(mc.preActionModel).trim() !== '') {
-            modelConfigOut.preActionModel = aliasToProfileChoice(String(mc.preActionModel));
-        }
-        if (mc.skillModel != null && String(mc.skillModel).trim() !== '') {
-            modelConfigOut.skillModel = aliasToProfileChoice(String(mc.skillModel));
-        }
-        if (mc.postActionModel != null && String(mc.postActionModel).trim() !== '') {
-            modelConfigOut.postActionModel = aliasToProfileChoice(String(mc.postActionModel));
-        }
-        return {
-            id: c.when == null ? 'default' : `case-${index}`,
-            ...(c.when != null ? { when: c.when } : {}),
-            modelConfig: modelConfigOut,
-        };
-    });
-    const hasPartialCase = cases.some((c) => !c.modelConfig.preActionModel ||
-        !c.modelConfig.skillModel ||
-        !c.modelConfig.postActionModel);
-    return {
-        version: 'graph-model-config/v1',
-        cases,
-        ...(hasPartialCase ? { inherit: true } : {}),
-    };
-}
-const DEFAULT_EXECUTABLE_FALLBACK_POLICY = {
-    enabled: true,
-    allowedTriggers: [
-        'nodeSlotMissing',
-        'nodeModelUnavailable',
-        'nodeModelUnsupported',
-        'nodeProviderNotConfigured',
-        'nodeModelRateLimited',
-        'nodeModelTransientFailure',
-    ],
-    maxAttemptsPerSlot: 1,
-};
-function defaultExecutableModelConfig() {
-    const mc = DEFAULT_GRAPH_AI_MODEL_PROFILE_CONFIG;
-    return {
-        version: 'graph-model-config/v1',
-        cases: [
-            {
-                id: 'default',
-                modelConfig: {
-                    preActionModel: aliasToProfileChoice(mc.preActionModel),
-                    skillModel: aliasToProfileChoice(mc.skillModel),
-                    postActionModel: aliasToProfileChoice(mc.postActionModel),
-                },
-            },
-        ],
-        fallbackPolicy: DEFAULT_EXECUTABLE_FALLBACK_POLICY,
-    };
-}
-function isStructuredExellixDataFilters(value) {
-    return (isPlainRecord(value) &&
-        value.version === EXELLIX_STRUCTURED_DATA_FILTERS_V1 &&
-        isPlainRecord(value.when));
-}
-function exellixGraphEntryToAuthoring(graphEntry) {
-    if (!isPlainRecord(graphEntry))
-        return graphEntry;
-    const next = structuredClone(graphEntry);
-    const dataFilters = next.dataFilters;
-    if (isStructuredExellixDataFilters(dataFilters)) {
-        next.dataFilters = [dataFilters.when];
-    }
-    return next;
-}
-/** Authoring validation requires jsonConditions as an array; exellix uses a CaseCondition object. */
-function exellixConditionsToAuthoring(conditions) {
-    if (Array.isArray(conditions)) {
-        return { runWhen: conditions };
-    }
-    const runWhenEntry = {};
-    if (conditions.jsonConditions != null) {
-        runWhenEntry.jsonConditions = structuredClone(conditions.jsonConditions);
-    }
-    if (conditions.jsConditionFunction != null) {
-        runWhenEntry.jsConditionFunction = structuredClone(conditions.jsConditionFunction);
-    }
-    if (conditions.aiCondition != null) {
-        runWhenEntry.aiCondition = structuredClone(conditions.aiCondition);
-    }
-    const out = {};
-    if (Object.keys(runWhenEntry).length > 0) {
-        out.runWhen = [runWhenEntry];
-    }
-    if (conditions.dataFilters != null) {
-        out.dataFilters = structuredClone(conditions.dataFilters);
-    }
-    if (conditions.narratives != null) {
-        out.narratives = structuredClone(conditions.narratives);
-    }
-    return out;
-}
-function defaultPorts(nodeId) {
-    return {
-        in: `in:${nodeId}`,
-        out: `out:${nodeId}`,
-    };
-}
-function exellixTaskNodeToExecutable(node) {
-    const ports = defaultPorts(String(node.id));
-    const params = {
-        profile: TASK_NODE_PROFILE,
-        nodeType: 'task',
-        skillKey: node.skillKey,
-    };
-    if (node.taskConfiguration != null)
-        params.taskConfiguration = structuredClone(node.taskConfiguration);
-    if (node.taskVariable != null)
-        params.taskVariable = structuredClone(node.taskVariable);
-    if (node.inputsConfig != null)
-        params.inputsConfig = structuredClone(node.inputsConfig);
-    if (node.executionMapping != null)
-        params.executionMapping = structuredClone(node.executionMapping);
-    if (node.conditions != null)
-        params.conditions = exellixConditionsToAuthoring(node.conditions);
-    if (Array.isArray(node.taskKnowledge)) {
-        params.taskKnowledge = exellixKnowledgeRefsToAuthoring(node.taskKnowledge);
-    }
-    if (node.variables != null)
-        params.variables = structuredClone(node.variables);
-    if (node.metadata != null)
-        params.metadata = structuredClone(node.metadata);
-    if (node.executionPipeline != null)
-        params.executionPipeline = structuredClone(node.executionPipeline);
-    if (node.jobContextMapping != null)
-        params.jobContextMapping = structuredClone(node.jobContextMapping);
-    if (node.scope != null)
-        params.scope = structuredClone(node.scope);
-    if (node.smartInput != null)
-        params.smartInput = exellixSmartInputToAuthoring(node.smartInput);
-    if (node.outputValidation != null)
-        params.outputValidation = structuredClone(node.outputValidation);
-    const nodeModelConfig = node.taskConfiguration?.modelConfig;
-    if (nodeModelConfig != null) {
-        const converted = exellixModelConfigToExecutable(nodeModelConfig);
-        if (converted) {
-            params.taskConfiguration = {
-                ...(isPlainRecord(params.taskConfiguration) ? params.taskConfiguration : {}),
-                modelConfig: converted,
-            };
-        }
-    }
-    return {
-        id: String(node.id),
-        kind: TASK_NODE_KIND,
-        inputs: [{ id: ports.in, direction: 'input', type: 'builtin:object', required: false }],
-        outputs: [{ id: ports.out, direction: 'output', type: 'builtin:object' }],
-        parameters: params,
-    };
-}
-function exellixSmartInputToAuthoring(smartInput) {
-    if (!isPlainRecord(smartInput))
-        return structuredClone(smartInput);
-    const next = structuredClone(smartInput);
-    if (Array.isArray(next.paths)) {
-        next.paths = next.paths.map((entry) => typeof entry === 'string' ? { path: entry } : entry);
-    }
-    return next;
-}
-function exellixKnowledgeRefsToAuthoring(refs) {
-    return refs.map((ref) => ({ id: ref }));
-}
-function exellixFinalizerToExecutable(node) {
-    const n = node;
-    const ports = defaultPorts(String(node.id));
-    return {
-        id: String(node.id),
-        kind: FINALIZER_NODE_KIND,
-        inputs: [{ id: ports.in, direction: 'input', type: 'builtin:object', required: false }],
-        outputs: [{ id: ports.out, direction: 'output', type: 'builtin:object' }],
-        parameters: {
-            profile: FINALIZER_NODE_PROFILE,
-            nodeType: 'finalizer',
-            finalizerType: n.finalizerType,
-            config: isPlainRecord(n.config) ? structuredClone(n.config) : {},
-            ...(n.inputs != null ? { inputs: structuredClone(n.inputs) } : {}),
-            ...(n.outputMapping != null ? { outputMapping: structuredClone(n.outputMapping) } : {}),
-        },
-    };
-}
-/**
- * Converts exellix {@link GraphModelObject} to graphenix {@link AuthoringGraphDocument} for plan compilation.
- */
-export function migrateExellixGraphModelToAuthoring(model) {
-    const legacyMigrated = migrateLegacyGraphResponse(structuredClone(model));
-    const source = legacyMigrated.graph;
-    const executableModelConfig = exellixModelConfigToExecutable(source.modelConfig) ?? defaultExecutableModelConfig();
-    const metadata = isPlainRecord(source.metadata) ? structuredClone(source.metadata) : {};
-    const extensions = isPlainRecord(metadata.extensions) ? { ...metadata.extensions } : {};
-    extensions[EXECUTABLE_PROFILE_NAMESPACE] = {
-        ...(isPlainRecord(extensions[EXECUTABLE_PROFILE_NAMESPACE])
-            ? extensions[EXECUTABLE_PROFILE_NAMESPACE]
-            : {}),
-        profileVersion: EXECUTABLE_PROFILE_VERSION,
-        modelConfig: executableModelConfig,
-    };
-    metadata.extensions = extensions;
-    if (metadata.graphEntry != null) {
-        metadata.graphEntry = exellixGraphEntryToAuthoring(metadata.graphEntry);
-    }
-    if (Array.isArray(source.jobKnowledge)) {
-        metadata.jobKnowledge = exellixKnowledgeRefsToAuthoring(source.jobKnowledge);
-    }
-    const nodes = (source.nodes ?? []).map((node) => {
-        const type = node.type ?? 'task';
-        if (type === 'finalizer')
-            return exellixFinalizerToExecutable(node);
-        return exellixTaskNodeToExecutable(node);
-    });
-    const portByNode = new Map();
-    for (const n of nodes)
-        portByNode.set(n.id, defaultPorts(n.id));
-    const edges = (source.edges ?? []).map((e, index) => {
-        const fromPorts = portByNode.get(e.from) ?? defaultPorts(e.from);
-        const toPorts = portByNode.get(e.to) ?? defaultPorts(e.to);
-        return {
-            id: `edge:${index}:${e.from}->${e.to}`,
-            from: { nodeId: e.from, portId: fromPorts.out },
-            to: { nodeId: e.to, portId: toPorts.in },
-            ...(e.when != null ? { when: e.when } : {}),
-        };
-    });
-    const graphResponse = isPlainRecord(source.response)
-        ? { shape: source.response.shape, ...source.response }
-        : undefined;
-    return {
-        formatVersion: GRAPHENIX_FORMAT_VERSION,
-        id: String(source.id),
-        revision: typeof source.version === 'string' ? source.version : '1.0.0',
-        name: typeof metadata.name === 'string' ? metadata.name : String(source.id),
-        graph: {
-            nodes,
-            edges,
-            inputs: [],
-            outputs: [],
-            metadata: {
-                ...metadata,
-                ...(graphResponse ? { graphResponse } : {}),
-                graphEntry: metadata.graphEntry,
-            },
-        },
-    };
-}

package/dist/src/adapters/patchFinalizerPlans.d.ts

@@ -1,7 +0,0 @@
-import type { ExecutableGraphPlanV2 } from '@x12i/graphenix-executable-contracts';
-import type { GraphRuntimeObject } from '../runtime/ExellixGraphRuntime.js';
-/**
- * `@x12i/graphenix-plan-compiler` v1.0.0 builds AI finalizer plans without resolved
- * `finalizerModel` slots. Rebuild finalizer plans using published compiler helpers.
- */
-export declare function patchFinalizerPlansOnExecutablePlan(plan: ExecutableGraphPlanV2, runtime: GraphRuntimeObject): ExecutableGraphPlanV2;

package/dist/src/adapters/patchFinalizerPlans.js

@@ -1,63 +0,0 @@
-import { getFinalizerNodeConfig, isExecutableFinalizerNode, } from '@x12i/graphenix-executable-contracts';
-import { buildFinalizerPlans, buildDeterministicCaseContext, resolveGraphModelConfig, } from '@x12i/graphenix-plan-compiler';
-const AI_FINALIZER_TYPES = new Set(['synthesize']);
-/**
- * `@x12i/graphenix-plan-compiler` v1.0.0 builds AI finalizer plans without resolved
- * `finalizerModel` slots. Rebuild finalizer plans using published compiler helpers.
- */
-export function patchFinalizerPlansOnExecutablePlan(plan, runtime) {
-    if (plan.normalizedGraph.mode !== 'embedded')
-        return plan;
-    const normalized = plan.normalizedGraph.graph;
-    const aiFinalizers = normalized.graph.nodes.filter(isExecutableFinalizerNode).filter((node) => {
-        const config = getFinalizerNodeConfig(node);
-        return config != null && AI_FINALIZER_TYPES.has(String(config.finalizerType));
-    });
-    if (aiFinalizers.length === 0)
-        return plan;
-    const context = buildDeterministicCaseContext(normalized, runtime);
-    const graphResolution = resolveGraphModelConfig(normalized, context);
-    const triplet = graphResolution.triplet;
-    if (triplet.preActionModel == null && triplet.skillModel == null && triplet.postActionModel == null) {
-        return plan;
-    }
-    const slotMeta = {
-        source: 'graphDefault',
-        inherited: true,
-        graphCaseId: graphResolution.caseId,
-    };
-    const resolvedFinalizerSlots = {};
-    for (const node of aiFinalizers) {
-        const finalizerSelection = triplet.postActionModel ?? triplet.skillModel ?? triplet.preActionModel;
-        if (finalizerSelection == null)
-            continue;
-        resolvedFinalizerSlots[node.id] = {
-            selection: finalizerSelection,
-            ...slotMeta,
-        };
-    }
-    const finalizerPlans = buildFinalizerPlans(normalized, resolvedFinalizerSlots);
-    for (const node of aiFinalizers) {
-        const entry = finalizerPlans[node.id];
-        if (!entry)
-            continue;
-        entry.modelSlots = {
-            ...(triplet.preActionModel != null
-                ? { preActionModel: { selection: triplet.preActionModel, ...slotMeta } }
-                : {}),
-            ...(triplet.skillModel != null
-                ? { skillModel: { selection: triplet.skillModel, ...slotMeta } }
-                : {}),
-            ...(triplet.postActionModel != null
-                ? { postActionModel: { selection: triplet.postActionModel, ...slotMeta } }
-                : {}),
-            ...(entry.modelSlots?.finalizerModel != null
-                ? { finalizerModel: entry.modelSlots.finalizerModel }
-                : {}),
-        };
-    }
-    return {
-        ...plan,
-        finalizerPlans,
-    };
-}