@exellix/graph-engine 8.0.1 → 8.1.1

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 8.1.0
+
+### Breaking
+
+- **`compileExellixExecutablePlan` input is `AuthoringGraphDocument` only** — removed `migrateLegacyGraphModelObjectToGraphenixExecutable` re-export and all legacy migration hooks. Compile = `validateAuthoringGraph` → `compileExecutablePlanV2` → `validateExecutablePlanV2`.
+- **`buildGraphExecutionRequest` (matrix host)** now takes `{ doc: AuthoringGraphDocument, runtime }` instead of `{ model: GraphModelObject, runtime }`.
+- Studio execute adapter delegates to `@x12i/graphenix-execute-envelope` ^1.1.0 (authoring graph on the wire).
+- **`@exellix/ai-tasks` ^9.0.0 — nodePlan-only wire:** every outbound `runTask` requires frozen `nodePlan` (from compiled `plan.nodePlans` or runtime synthesis). When `nodePlan` is set, graph-engine **does not** send root `modelConfig`, `executionPipeline`, `taskConfiguration`, `includeContextInPrompt`, or `llmCall`. Model slots live on `nodePlan.executionUnits[].modelSelection`; ai-tasks runs PRE/MAIN/POST units inside a **single** `runTask` per task node (graph-engine no longer loops strategy phases on the hot path).
+- **`buildTaskNodeRunTaskRequest` / preflight** mirror the execute path: synthesize or resolve `nodePlan`, pass `executionTrace`, forbid legacy wire fields.
+
+### Changed
+
+- Dependency floor: `@x12i/graphenix-authoring-format` ^1.2.0 (canonical model-config module: `readGraphJobModelDefaults`, `mergeEffectiveModelConfig`, `normalizeNodeOverrideForPersist`, validators), `@x12i/graphenix-executable-format` ^2.1.3 (transitive `@x12i/graphenix-authoring-analysis` ^1.2.0); `@x12i/graphenix-plan-compiler`, `executable-contracts`, `execute-envelope`, `plan-format` remain ^1.1.0.
+- Dependency: `@exellix/ai-tasks` ^9.0.0.
+- **Compile host post-patches** (upstream gaps until CRS items land): `patchEntryGatesFromGraphEntryDataFilters` lifts `metadata.graphEntry.dataFilters` into `plan.deferredGates.entryGates`; `patchInvokeContractReadPathsForExecutionMemory` prefixes bare `invokeContract.reads` paths with `executionMemory.` when the root is not allowlisted.
+- **Testkit:** `flatTestGraphToAuthoringDocument` bridges legacy flat test graphs to `AuthoringGraphDocument`; model-alias tests split for stable `tsx --test` execution.
+
+### Added
+
+- **`runTaskNodePlan` helpers:** `resolveRunTaskNodePlan`, `patchNodePlanMainModelFromWire`, `nodePlanFromFinalizerPlan`.
+- **Tests:** `compile-host-patches.test.ts`, split `model-alias-*` suites, `runTaskNodePlanAssertions` testkit helpers.
+
+See [`BREAKING-CHANGES.md`](BREAKING-CHANGES.md) §8.1.0 (ai-tasks 9).
+
+## 8.0.2
+
+### Changed
+
+- **No legacy compile fixups:** removed `preprocessLegacy` / `migrateLegacyGraphResponse`. `compileExellixExecutablePlan` runs `assertCanonicalGraphDocument` first; graphs must declare root `response` (fix in studio/CI, not at compile).
+
 ## 8.0.1
 
 ### Changed

package/README.md

@@ -366,7 +366,7 @@ Example:
 }
 ```
 
-`metadata.graphExecution.outputMode`, finalizer output, and legacy `metadata.graphResponse.responseMapping` are not final-output selectors for new graphs. Migrate legacy response mappings by copying `missing` and `shape` to root `response` and dropping `version`, `target`, `primaryResponsePaths`, `debugResponsePaths`, `notableExecutionPaths`, and `mappingPreset`.
+`metadata.graphExecution.outputMode`, finalizer output, and `metadata.graphResponse.responseMapping` are not final-output selectors. Graphs must declare root `graph.response` at persist time; graph-engine does not hoist or migrate legacy response sidecars at compile.
 
 `coreObjective` is resolved once from graph/run context, not from each node response. Supported `sourcePath` roots are `input.*`, `execution.*`, `variables.*` / `jobVariables.*`, `taskVariables.*`, `jobMemory.*`, `taskMemory.*`, and `job.*`.
 

package/dist/src/compile/authoringDocumentHelpers.d.ts

@@ -0,0 +1,9 @@
+import type { AuthoringGraphDocument } from '@x12i/graphenix-executable-contracts';
+import type { GraphEntryContract } from '../types/refs.js';
+/**
+ * Reads Layer 01 contract from a Graphenix 2.x {@link AuthoringGraphDocument}
+ * (`graph.metadata.graphEntry`). Host catalog loaders return this shape from studio.
+ */
+export declare function resolveGraphEntryFromAuthoringDocument(doc: AuthoringGraphDocument): GraphEntryContract | undefined;
+/** Canonical id on an authoring document (matrix claim `graphId` must match this). */
+export declare function authoringDocumentGraphId(doc: AuthoringGraphDocument): string;

package/dist/src/compile/authoringDocumentHelpers.js

@@ -0,0 +1,18 @@
+function isPlainRecord(v) {
+    return v != null && typeof v === 'object' && !Array.isArray(v);
+}
+/**
+ * Reads Layer 01 contract from a Graphenix 2.x {@link AuthoringGraphDocument}
+ * (`graph.metadata.graphEntry`). Host catalog loaders return this shape from studio.
+ */
+export function resolveGraphEntryFromAuthoringDocument(doc) {
+    const meta = doc.graph?.metadata;
+    if (!isPlainRecord(meta))
+        return undefined;
+    const graphEntry = meta.graphEntry;
+    return isPlainRecord(graphEntry) ? graphEntry : undefined;
+}
+/** Canonical id on an authoring document (matrix claim `graphId` must match this). */
+export function authoringDocumentGraphId(doc) {
+    return doc.id;
+}

package/dist/src/compile/compileExellixExecutablePlan.d.ts

@@ -1,9 +1,8 @@
-import type { CompileExecutablePlanV2Options, ExecutableGraphPlanV2 } from '@x12i/graphenix-executable-contracts';
-import type { Graph, GraphModelObject } from '../types/refs.js';
+import type { AuthoringGraphDocument, CompileExecutablePlanV2Options, ExecutableGraphPlanV2 } from '@x12i/graphenix-executable-contracts';
 import type { GraphRuntimeObject } from '../runtime/ExellixGraphRuntime.js';
 export type CompileExellixExecutablePlanOptions = CompileExecutablePlanV2Options;
 /**
- * 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.
+ * Host/test helper: canonical {@link AuthoringGraphDocument} + runtime → validated v2 executable plan.
+ * No legacy migration — graphs must already be Graphenix 2.x authoring shape.
  */
-export declare function compileExellixExecutablePlan(model: Graph | GraphModelObject, runtime: GraphRuntimeObject, options?: CompileExellixExecutablePlanOptions): ExecutableGraphPlanV2;
+export declare function compileExellixExecutablePlan(doc: AuthoringGraphDocument, runtime: GraphRuntimeObject, options?: CompileExellixExecutablePlanOptions): ExecutableGraphPlanV2;

package/dist/src/compile/compileExellixExecutablePlan.js

@@ -1,23 +1,74 @@
-import { migrateLegacyGraphModelObjectToGraphenixExecutable, } from '@x12i/graphenix-authoring-format';
+import { validateAuthoringGraph } from '@x12i/graphenix-authoring-format';
 import { compileExecutablePlanV2 } from '@x12i/graphenix-plan-compiler';
-import { validateExecutablePlan } from '@x12i/graphenix-plan-format';
+import { validateExecutablePlanV2 } from '@x12i/graphenix-plan-format';
+import { resolveGraphEntryFromAuthoringDocument } from './authoringDocumentHelpers.js';
 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,
-};
+function patchEntryGatesFromGraphEntryDataFilters(plan, doc) {
+    const graphEntry = resolveGraphEntryFromAuthoringDocument(doc);
+    const dataFilters = graphEntry?.dataFilters;
+    if (dataFilters == null ||
+        typeof dataFilters !== 'object' ||
+        Array.isArray(dataFilters) ||
+        dataFilters.version !== EXELLIX_STRUCTURED_DATA_FILTERS_V1) {
+        return plan;
+    }
+    const when = dataFilters.when;
+    if (when == null || typeof when !== 'object')
+        return plan;
+    const next = structuredClone(plan);
+    const entryGates = [...(next.deferredGates.entryGates ?? [])];
+    entryGates.push({
+        gateId: 'graph-entry:structured-data-filters',
+        condition: { condition: when, parameters: {} },
+        sourcePath: 'metadata.graphEntry.dataFilters',
+    });
+    next.deferredGates = { ...next.deferredGates, entryGates };
+    return next;
+}
+function patchInvokeContractReadPathsForExecutionMemory(plan) {
+    const allowedRoots = new Set([
+        'executionMemory',
+        'input',
+        'inputs',
+        'jobMemory',
+        'taskMemory',
+        'smartInput',
+        'xynthesized',
+        'runtime',
+        'response',
+    ]);
+    const next = structuredClone(plan);
+    for (const nodePlan of Object.values(next.nodePlans ?? {})) {
+        if (!nodePlan?.executionUnits)
+            continue;
+        for (const unit of nodePlan.executionUnits) {
+            const contract = unit.invokeContract;
+            if (!contract || !Array.isArray(contract.reads))
+                continue;
+            contract.reads = contract.reads.map((readPath) => {
+                if (typeof readPath !== 'string')
+                    return readPath;
+                const root = readPath.split('.')[0];
+                return allowedRoots.has(root) ? readPath : `executionMemory.${readPath}`;
+            });
+        }
+    }
+    return next;
+}
 /**
- * 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.
+ * Host/test helper: canonical {@link AuthoringGraphDocument} + runtime → validated v2 executable plan.
+ * No legacy migration — graphs must already be Graphenix 2.x authoring shape.
  */
-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('; ');
+export function compileExellixExecutablePlan(doc, runtime, options) {
+    const authoringValidation = validateAuthoringGraph(doc);
+    if (!authoringValidation.valid) {
+        const summary = authoringValidation.errors.map((e) => `${e.path}: ${e.message}`).join('; ');
+        throw new Error(`compileExellixExecutablePlan: invalid authoring graph: ${summary}`);
+    }
+    const plan = patchInvokeContractReadPathsForExecutionMemory(patchEntryGatesFromGraphEntryDataFilters(compileExecutablePlanV2(doc, runtime, options), doc));
+    const planValidation = validateExecutablePlanV2(plan);
+    if (!planValidation.valid) {
+        const summary = planValidation.errors.map((e) => `${e.path}: ${e.message}`).join('; ');
         throw new Error(`compileExellixExecutablePlan: invalid plan: ${summary}`);
     }
     return plan;

package/dist/src/index.d.ts

@@ -62,7 +62,7 @@ export { collectAiTasksNodeExtensionIssues, assertAiTasksNodeExtensionsValid, }
 export type { AiTasksNodeExtensionIssue } from './inspection/validateAiTasksNodeExtensions.js';
 export type { EvaluateStructuredDataFiltersResult, EvaluateStructuredDataFiltersOptions, } from './runtime/dataFiltersEvaluation.js';
 /** Execution-matrix host: resolve graph entry, seed execution, stable job ids, runtime binder. */
-export { resolveGraphEntryFromGraph, createResolveGraphEntryFromLoader, buildExecutionSeedFromGraphEntry, validateExecutionSeedPaths, buildStableMatrixJobId, buildMatrixJobForGraphRun, buildGraphExecutionRequest, isExecuteGraphResultFailed, createMatrixHostGraphExecutor, } from './runtime/executionMatrixHost.js';
+export { resolveGraphEntryFromGraph, resolveGraphEntryFromAuthoringDocument, authoringDocumentGraphId, createResolveGraphEntryFromLoader, buildExecutionSeedFromGraphEntry, validateExecutionSeedPaths, buildStableMatrixJobId, buildMatrixJobForGraphRun, buildGraphExecutionRequest, isExecuteGraphResultFailed, createMatrixHostGraphExecutor, } from './runtime/executionMatrixHost.js';
 export type { BuildExecutionSeedSources, BuildExecutionSeedResult } from './runtime/executionMatrixHost.js';
 export { assertHostJobId, newGraphRunTaskId } from './runtime/graphRunIdentity.js';
 export { buildAiTasksRunTaskRequest, extractRunTaskMetadataPassthrough, extractRunTaskStrategyOverrides, resolveJobTypeId, resolveTaskTypeId, } from './runtime/buildAiTasksRunTaskRequest.js';
@@ -86,15 +86,12 @@ export type { GraphStudioDocument } from './runtime/graphModelStudioSeparation.j
 export { STUDIO_GRAPH_EXECUTE_REMOVED_KEYS, getStudioGraphExecuteRemovedKeyViolations, assertCanonicalStudioGraphExecuteRequest, buildGraphExecutionRequestFromStudioExecute, } from './runtime/studioGraphExecuteRequest.js';
 export type { StudioGraphExecuteRemovedKey, StudioGraphExecuteRequest, BuildGraphExecutionRequestFromStudioExecuteOptions, } from './runtime/studioGraphExecuteRequest.js';
 export { computeGraphDocumentContentSha256, stableStringifyGraphDocument, } from './runtime/graphDocumentFingerprint.js';
-export { migrateLegacyGraphResponse, migrateLegacyGraphResponseDefinition, } from './runtime/graphResponseMigration.js';
-export type { MigrateGraphResponseResult } from './runtime/graphResponseMigration.js';
 export { applyAiTaskProfileWebScopingToNarrix, mapAiTaskProfileQuestionsToWebScopeQuestions, } from './runtime/applyAiTaskProfileWebScopingToNarrix.js';
 export { createExellixGraphRuntime } from './runtime/ExellixGraphRuntime.js';
 export type { ExecutableGraphPlanV2, NodeExecutionPlan, ExecutionUnitPlanV2, } from '@x12i/graphenix-executable-contracts';
+export type { AuthoringGraphDocument } from '@x12i/graphenix-executable-contracts';
 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

@@ -48,7 +48,7 @@ export { resolveCanonicalModelUsed } from './runtime/canonicalModelUsed.js';
 export { buildAiTasksObservabilityRecord } from './runtime/aiTasksObservability.js';
 export { collectAiTasksNodeExtensionIssues, assertAiTasksNodeExtensionsValid, } from './inspection/validateAiTasksNodeExtensions.js';
 /** Execution-matrix host: resolve graph entry, seed execution, stable job ids, runtime binder. */
-export { resolveGraphEntryFromGraph, createResolveGraphEntryFromLoader, buildExecutionSeedFromGraphEntry, validateExecutionSeedPaths, buildStableMatrixJobId, buildMatrixJobForGraphRun, buildGraphExecutionRequest, isExecuteGraphResultFailed, createMatrixHostGraphExecutor, } from './runtime/executionMatrixHost.js';
+export { resolveGraphEntryFromGraph, resolveGraphEntryFromAuthoringDocument, authoringDocumentGraphId, createResolveGraphEntryFromLoader, buildExecutionSeedFromGraphEntry, validateExecutionSeedPaths, buildStableMatrixJobId, buildMatrixJobForGraphRun, buildGraphExecutionRequest, isExecuteGraphResultFailed, createMatrixHostGraphExecutor, } from './runtime/executionMatrixHost.js';
 export { assertHostJobId, newGraphRunTaskId } from './runtime/graphRunIdentity.js';
 export { buildAiTasksRunTaskRequest, extractRunTaskMetadataPassthrough, extractRunTaskStrategyOverrides, resolveJobTypeId, resolveTaskTypeId, } from './runtime/buildAiTasksRunTaskRequest.js';
 export { buildTaskNodeJobContext } from './runtime/buildTaskNodeJobContext.js';
@@ -63,12 +63,10 @@ export { assertCanonicalGraphRuntimeObject } from './runtime/validateCanonicalGr
 export { GRAPH_ENTRY_STUDIO_ONLY_KEYS, GRAPH_METADATA_STUDIO_ONLY_KEYS, stripGraphModelStudioFields, primaryRuntimeInputFromStudioDocument, getGraphEntryStudioOnlyKeyViolations, getGraphMetadataStudioOnlyKeyViolations, getGraphEntryEmptyInputPathViolations, } from './runtime/graphModelStudioSeparation.js';
 export { STUDIO_GRAPH_EXECUTE_REMOVED_KEYS, getStudioGraphExecuteRemovedKeyViolations, assertCanonicalStudioGraphExecuteRequest, buildGraphExecutionRequestFromStudioExecute, } from './runtime/studioGraphExecuteRequest.js';
 export { computeGraphDocumentContentSha256, stableStringifyGraphDocument, } from './runtime/graphDocumentFingerprint.js';
-export { migrateLegacyGraphResponse, migrateLegacyGraphResponseDefinition, } from './runtime/graphResponseMigration.js';
 export { applyAiTaskProfileWebScopingToNarrix, mapAiTaskProfileQuestionsToWebScopeQuestions, } from './runtime/applyAiTaskProfileWebScopingToNarrix.js';
 // New runtime with injection seam
 export { createExellixGraphRuntime } from './runtime/ExellixGraphRuntime.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.d.ts

@@ -1,6 +1,5 @@
 import type { GraphEngineFactory } from "./GraphEngine.js";
-import type { ExecutionStep } from "@exellix/ai-tasks";
-import type { ExecutableGraphPlanV2, GraphExecutionTrace } from "@x12i/graphenix-executable-contracts";
+import type { ExecutableGraphPlanV2, FinalizerExecutionPlan, GraphExecutionTrace, NodeExecutionPlan } from "@x12i/graphenix-executable-contracts";
 import type { Graph, GraphModelObject, GraphNode, GraphAiModelConfig, TaskNodeRuntimeObject } from "../types/refs.js";
 import type { RunLogEntry } from "../types/runLog.js";
 import type { RunTaskDiagnostics } from "../types/options.js";
@@ -10,38 +9,7 @@ import type { CreateRunxOptions, RunxClient } from "@x12i/runx";
 import { type EventEmitter } from "./events.js";
 import type { NodeTraceEntry } from "../types/results.js";
 import type { ExecuteGraphStepResponse } from "../types/results.js";
-export type RunTaskRequest = {
-    skillKey: string;
-    /** Execution pipeline (pre → main → post). When omitted, defaults to [{ phase: "main", type: "direct" }]. */
-    executionPipeline?: ExecutionStep[];
-    /** When true, task receives synthesized/context in prompt (e.g. for synthesized-context PRE step). */
-    includeContextInPrompt?: boolean;
-    input?: any;
-    variables?: Record<string, any>;
-    jobMemory?: any;
-    taskMemory?: any;
-    executionMemory?: any;
-    prevNodeId?: string;
-    jobId?: string;
-    taskId?: string;
-    agentId?: string;
-    skillId?: string;
-    masterSkillId?: string;
-    masterSkillActivityId?: string;
-    jobContext?: any;
-    modelConfig?: GraphAiModelConfig;
-    outputValidation?: {
-        schema: Record<string, unknown>;
-        mode?: "fail" | "warn";
-        validateWhenMissing?: boolean;
-    };
-    diagnostics?: RunTaskDiagnostics;
-    llmCall?: Record<string, unknown>;
-    identity?: Record<string, unknown>;
-    executionMode?: "default" | "trace";
-    taskKind?: "decision" | "utility" | "content";
-    autoValidateDecisionOutput?: boolean;
-};
+export type RunTaskRequest = import("@exellix/ai-tasks").RunTaskRequest;
 export type RunTaskResponse = {
     ok: boolean;
     rawContent?: string;
@@ -203,8 +171,14 @@ export declare function createExellixGraphRuntime(opts: ExellixGraphRuntimeOptio
         /** Per-node task-scope overrides → `executionMemory.taskVariables`. */
         taskVariables?: Record<string, unknown>;
         prevNodeId?: string;
-        /** Resolved graph model profiles; omitted when {@link graph} is supplied (resolved from the model document). */
+        /** Resolved model profiles from frozen plan slots; required when {@link nodePlan} is omitted. */
         modelConfig?: GraphAiModelConfig;
+        /** Frozen per-node plan from {@link compileExecutablePlanV2}; drives executionUnits on the executeGraph path. */
+        nodePlan?: NodeExecutionPlan;
+        /** Frozen finalizer plan slice when executing a synthesize finalizer utility invoke. */
+        finalizerPlan?: FinalizerExecutionPlan;
+        /** Graphenix v2 trace handle forwarded to ai-tasks node executor. */
+        executionTrace?: GraphExecutionTrace;
         /** Same UUID for every `runTask` in this `executeGraph` invocation; omitted → new UUID per direct `executeNode` call. */
         graphRunTaskId?: string;
         runTaskIdentity?: Record<string, unknown>;
@@ -214,7 +188,7 @@ export declare function createExellixGraphRuntime(opts: ExellixGraphRuntimeOptio
         jobKnowledgePatch?: Record<string, unknown>;
         /** Resolved per-node taskKnowledge, applied only to outbound RunTaskRequest.taskMemory. */
         taskKnowledgePatch?: Record<string, unknown>;
-        /** Graph-run default pipeline; node / `execution.executionPipeline` override per executeNode rules. */
+        /** @deprecated ai-tasks ≥ 9 executes {@link nodePlan.executionUnits}; graph-engine does not forward a pipeline. */
         graphExecutionPipeline?: ExecutionStepOption[];
         skillKeyResolution?: SkillKeyResolutionOptions;
         nodeTimeoutMs?: number;
@@ -256,6 +230,6 @@ export declare function createExellixGraphRuntime(opts: ExellixGraphRuntimeOptio
         };
         execution: any;
         outputsMemory: Record<string, unknown>;
-        request: RunTaskRequest;
+        request: import("@exellix/ai-tasks").RunTaskRequest;
     }>;
 };