@exellix/graph-engine 6.0.0

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

@@ -0,0 +1,33 @@
+/**
+ * Graph engine interface for planning and execution state management
+ */
+export type PlanStatus = "continue" | "completed" | "blocked" | "waiting";
+export interface GraphPlan<NodeT = any> {
+    status: PlanStatus;
+    nextNodes: NodeT[];
+    details?: any;
+}
+export interface GraphEngine<NodeT = any> {
+    plan(): GraphPlan<NodeT>;
+    /**
+     * Commit results of a node execution back to the engine.
+     * The engine decides what it means (store output, mark done, update vars, etc.)
+     */
+    commit(input: {
+        nodeId: string;
+        output?: any;
+        error?: any;
+        meta?: Record<string, any>;
+    }): void;
+    snapshot(): any;
+}
+export interface GraphEngineFactory {
+    create(input: {
+        graph: any;
+        mode?: "forward" | "backward" | "hybrid";
+        goalNodeId?: string;
+        dimension?: string;
+        initialState?: any;
+        initialVariables?: Record<string, any>;
+    }): GraphEngine;
+}

package/dist/src/runtime/GraphEngine.js

@@ -0,0 +1,4 @@
+/**
+ * Graph engine interface for planning and execution state management
+ */
+export {};

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

@@ -0,0 +1,6 @@
+import type { RunTaskRequest, RunTaskResponse } from '../types/options.js';
+/**
+ * Stable ai-tasks observability for graph-engine results: versioned digest from `@exellix/ai-tasks`
+ * plus selected metadata fields not duplicated in the digest.
+ */
+export declare function buildAiTasksObservabilityRecord(response: RunTaskResponse, request?: RunTaskRequest): Record<string, unknown>;

package/dist/src/runtime/aiTasksObservability.js

@@ -0,0 +1,37 @@
+import { extractAiTasksObservabilityFromRunTaskResponse } from '@exellix/ai-tasks';
+import { resolveCanonicalModelUsed } from './canonicalModelUsed.js';
+/** Metadata keys kept alongside {@link extractAiTasksObservabilityFromRunTaskResponse} digest for consoles / trace. */
+const METADATA_EXTRAS = [
+    'activityId',
+    'durationMs',
+    'instructionVersion',
+    'localSkillKey',
+    'synthesisContextAuthoritative',
+];
+/**
+ * Stable ai-tasks observability for graph-engine results: versioned digest from `@exellix/ai-tasks`
+ * plus selected metadata fields not duplicated in the digest.
+ */
+export function buildAiTasksObservabilityRecord(response, request) {
+    const digest = extractAiTasksObservabilityFromRunTaskResponse(response, request);
+    const out = { ...digest };
+    const modelUsed = resolveCanonicalModelUsed(response);
+    if (modelUsed != null)
+        out.modelUsed = modelUsed;
+    const r = response;
+    const meta = r.metadata ?? r.meta;
+    if (meta != null && typeof meta === 'object' && !Array.isArray(meta)) {
+        const m = meta;
+        for (const k of METADATA_EXTRAS) {
+            if (m[k] !== undefined)
+                out[k] = m[k];
+        }
+        if (modelUsed != null) {
+            out.metadata = { ...m, modelUsed };
+        }
+    }
+    else if (modelUsed != null) {
+        out.metadata = { modelUsed };
+    }
+    return out;
+}

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

@@ -0,0 +1,46 @@
+/**
+ * Engine-level PRE/POST **utility** calls via `@exellix/ai-tasks` `runTask` only (no direct Xynthesis SDK usage).
+ * Triggered by `taskConfiguration.aiTaskProfile.preStrategyKey` / `postStrategyKey`.
+ * Distinct from `executionPipeline` PRE `synthesized-context`, which runs inside the MAIN node’s single ai-tasks `runTask`.
+ * Parsed outcomes are merged under **`execution.xynthesis.pre` / `execution.xynthesis.post`** (historical slot names on execution memory).
+ */
+import type { RunTaskRequest } from '@exellix/ai-tasks';
+import type { GraphAiModelConfig, Job } from '../types/refs.js';
+import type { RunTaskResponse, TasksClientLike } from './ExellixGraphRuntime.js';
+export type EngineStrategyPhase = 'pre' | 'post';
+export type RunEngineAiTasksStrategyPhaseArgs = {
+    phase: EngineStrategyPhase;
+    strategySkillKey: string;
+    /** Main node skill key (telemetry / payload only). */
+    parentSkillKey: string;
+    aiTasks: TasksClientLike;
+    job?: Job;
+    nodeId: string;
+    graphId?: string;
+    taskId: string;
+    runTaskJobId: string;
+    execution: Record<string, unknown>;
+    variables?: Record<string, unknown>;
+    jobMemory?: unknown;
+    taskMemory?: unknown;
+    jobContext?: Record<string, unknown>;
+    prevNodeId?: string;
+    modelConfig?: GraphAiModelConfig;
+    llmCall?: RunTaskRequest['llmCall'];
+    runTaskIdentity?: Record<string, unknown>;
+    /** Task node `taskConfiguration` (identity envelope merge). */
+    nodeTaskConfiguration?: Record<string, unknown>;
+    forwardRunTaskTrace: boolean;
+    runTaskDiagnostics?: RunTaskRequest['diagnostics'];
+    nodeTimeoutMs?: number;
+};
+export declare function runEngineAiTasksStrategyPhase(args: RunEngineAiTasksStrategyPhaseArgs): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    response: RunTaskResponse;
+}>;
+export declare function getAiTaskProfileStrategyKeys(taskConfiguration: Record<string, unknown> | undefined): {
+    preStrategyKey?: string;
+    postStrategyKey?: string;
+};

package/dist/src/runtime/aiTasksStrategyPhases.js

@@ -0,0 +1,93 @@
+import { buildAiTasksRunTaskRequest } from './buildAiTasksRunTaskRequest.js';
+import { buildRunTaskIdentityEnvelope } from './runTaskAugments.js';
+import { runTaskResponseSucceeded } from './runTaskResponse.js';
+import { withTimeout } from './withTimeout.js';
+function nonEmptyStrategyKey(v) {
+    return typeof v === 'string' && v.trim().length > 0;
+}
+function mergeStrategyPhaseSlot(execution, phase, payload) {
+    const prev = execution.xynthesis;
+    const base = prev != null && typeof prev === 'object' && !Array.isArray(prev)
+        ? { ...prev }
+        : {};
+    base[phase] = payload;
+    execution.xynthesis = base;
+}
+export async function runEngineAiTasksStrategyPhase(args) {
+    const identity = buildRunTaskIdentityEnvelope({
+        base: args.runTaskIdentity,
+        graphId: args.graphId,
+        nodeId: args.nodeId,
+        taskId: args.taskId,
+        jobId: args.runTaskJobId,
+        nodeMeta: {
+            ...(args.nodeTaskConfiguration ?? {}),
+            /** Historical identity keys (telemetry); graph-engine does not import Xynthesis. */
+            xynthesisEnginePhase: args.phase,
+            xynthesisParentSkillKey: args.parentSkillKey,
+        },
+    });
+    const taskTypeIdOverride = args.phase === 'pre'
+        ? `exellix-graph-xynthesis-pre:${args.parentSkillKey}`
+        : `exellix-graph-xynthesis-post:${args.parentSkillKey}`;
+    const req = buildAiTasksRunTaskRequest({
+        skillKey: args.strategySkillKey,
+        job: args.job,
+        nodeId: args.nodeId,
+        taskConfiguration: undefined,
+        graphId: args.graphId,
+        taskId: args.taskId,
+        runTaskJobId: args.runTaskJobId,
+        taskInput: {
+            phase: `exellix-graph-${args.phase}-strategy`,
+            parentSkillKey: args.parentSkillKey,
+            nodeId: args.nodeId,
+            graphId: args.graphId,
+            executionMemory: { ...args.execution },
+        },
+        variables: args.variables,
+        jobMemory: args.jobMemory,
+        taskMemory: args.taskMemory,
+        executionMemory: args.execution,
+        jobContext: args.jobContext,
+        prevNodeId: args.prevNodeId,
+        executionPipeline: [{ phase: 'main', type: 'direct' }],
+        executionStrategies: [],
+        modelConfig: args.modelConfig,
+        llmCall: args.llmCall ?? undefined,
+        identity,
+        ...(args.forwardRunTaskTrace ? { executionMode: 'trace' } : {}),
+        ...(args.runTaskDiagnostics != null && { diagnostics: args.runTaskDiagnostics }),
+        taskKind: 'utility',
+        taskTypeIdOverride,
+    });
+    const run = () => args.aiTasks.runTask(req);
+    const response = await (args.nodeTimeoutMs
+        ? withTimeout(run(), args.nodeTimeoutMs, () => {
+            const err = new Error(`Engine ${args.phase} strategy runTask timed out after ${args.nodeTimeoutMs}ms (nodeId=${args.nodeId}, skillKey=${args.strategySkillKey})`);
+            err.code = 'NODE_TIMEOUT';
+            err.nodeId = args.nodeId;
+            return err;
+        })
+        : run());
+    if (!runTaskResponseSucceeded(response)) {
+        return { ok: false, response };
+    }
+    const out = response.parsed ??
+        response.output ??
+        response.executionMemory ??
+        null;
+    mergeStrategyPhaseSlot(args.execution, args.phase, out);
+    return { ok: true };
+}
+export function getAiTaskProfileStrategyKeys(taskConfiguration) {
+    const profile = taskConfiguration?.aiTaskProfile;
+    if (profile == null || typeof profile !== 'object' || Array.isArray(profile))
+        return {};
+    const pre = profile.preStrategyKey;
+    const post = profile.postStrategyKey;
+    return {
+        ...(nonEmptyStrategyKey(pre) ? { preStrategyKey: pre.trim() } : {}),
+        ...(nonEmptyStrategyKey(post) ? { postStrategyKey: post.trim() } : {}),
+    };
+}

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

@@ -0,0 +1,17 @@
+import type { AiTaskProfileMetadata } from '../types/aiTaskProfile.js';
+import type { NarrixPreProcessorConfig, ResolvedNarrixWirePayload, WebScopeQuestion } from '../types/narrix.js';
+/**
+ * Maps graph-composer `string[]` web questions to narrix-web-scoper object shape.
+ * Synthetic ids are stable per index for a given node run.
+ */
+export declare function mapAiTaskProfileQuestionsToWebScopeQuestions(questions: string[]): WebScopeQuestion[];
+/**
+ * Returns the resolved outbound `RunTaskRequest.narrix` payload.
+ *
+ * Authoring contract (5.x): `taskConfiguration.narrix` only carries the discovery fields on
+ * {@link NarrixPreProcessorConfig} (`datasetId`, `layer`, `narrativeTypeIds`, `questionId`).
+ * Web-scope fields (`enableWebScope`, `webScopeQuestions`, ...) are produced here from
+ * `taskConfiguration.aiTaskProfile.webScoping` and merged onto the wire payload — they are not
+ * authored on `taskConfiguration.narrix`.
+ */
+export declare function applyAiTaskProfileWebScopingToNarrix(narrix: NarrixPreProcessorConfig | undefined, aiTaskProfile: AiTaskProfileMetadata | undefined): ResolvedNarrixWirePayload | undefined;

package/dist/src/runtime/applyAiTaskProfileWebScopingToNarrix.js

@@ -0,0 +1,46 @@
+/**
+ * Maps graph-composer `string[]` web questions to narrix-web-scoper object shape.
+ * Synthetic ids are stable per index for a given node run.
+ */
+export function mapAiTaskProfileQuestionsToWebScopeQuestions(questions) {
+    const out = [];
+    let i = 0;
+    for (const q of questions) {
+        const t = typeof q === 'string' ? q.trim() : '';
+        if (!t)
+            continue;
+        out.push({ id: `aiTaskProfile-q-${i}`, question: t });
+        i += 1;
+    }
+    return out;
+}
+function webScopingFromProfileIsActive(profile) {
+    if (profile?.webScoping?.enabled !== true)
+        return false;
+    const qs = profile.webScoping.questions;
+    if (!Array.isArray(qs) || qs.length === 0)
+        return false;
+    return mapAiTaskProfileQuestionsToWebScopeQuestions(qs).length > 0;
+}
+/**
+ * Returns the resolved outbound `RunTaskRequest.narrix` payload.
+ *
+ * Authoring contract (5.x): `taskConfiguration.narrix` only carries the discovery fields on
+ * {@link NarrixPreProcessorConfig} (`datasetId`, `layer`, `narrativeTypeIds`, `questionId`).
+ * Web-scope fields (`enableWebScope`, `webScopeQuestions`, ...) are produced here from
+ * `taskConfiguration.aiTaskProfile.webScoping` and merged onto the wire payload — they are not
+ * authored on `taskConfiguration.narrix`.
+ */
+export function applyAiTaskProfileWebScopingToNarrix(narrix, aiTaskProfile) {
+    const base = narrix != null ? { ...narrix } : undefined;
+    if (!webScopingFromProfileIsActive(aiTaskProfile)) {
+        return base;
+    }
+    const mapped = mapAiTaskProfileQuestionsToWebScopeQuestions(aiTaskProfile.webScoping.questions);
+    const wire = (base ?? {});
+    return {
+        ...wire,
+        enableWebScope: true,
+        webScopeQuestions: mapped,
+    };
+}

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

@@ -0,0 +1,67 @@
+/**
+ * Builds an `@exellix/ai-tasks` v7 {@link RunTaskRequest}: canonical `input` bucket, required
+ * correlation ids (`jobTypeId`, `taskTypeId`), and graph telemetry (`graphId`, `nodeId`, `coreSkillId`).
+ *
+ * See `node_modules/@exellix/ai-tasks/RUNTASK_REQUEST.md` for merge rules (ai-tasks merges `jobContext`,
+ * `variables`, and `input` — do not pre-merge `input` into `variables` in graph-engine).
+ * v7 closed schema: no root `executionType`, `outputConstraints`, `question`, or `jobInput`.
+ * Graph-engine forwards optional `inputs` (caller bag, as-is) separately from `input` (MAIN as-is + node bindings) — see `.docs/CR-input-and-inputs-dual-root.md`.
+ */
+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 { 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). */
+export declare function extractRunTaskStrategyOverrides(taskConfiguration: Record<string, unknown> | undefined | null): Partial<Pick<BuildAiTasksRunTaskRequestArgs, 'narrixMode' | 'inputStrategyKey' | 'narrixInput'>>;
+/** Optional `RunTaskRequest` fields commonly authored on task-node `taskConfiguration` (whitelist — closed merge order). */
+export type RunTaskMetadataPassthrough = Partial<Pick<RunTaskRequest, 'narrixScope' | 'aiScoping' | 'aiScopingOptions' | 'timeoutMs' | 'templateRenderOptions' | 'smartInputRenderOptions' | 'templateTokens' | 'aiEngineId' | 'sessionId' | 'agentType' | 'gatewayDiagnostics' | 'context' | 'knowledge' | 'executionStrategyCatalogItems'>>;
+/**
+ * Whitelisted optional transport fields from task-node `taskConfiguration` for `@exellix/ai-tasks` ≥ 7.2.x
+ * (`RunSkillRequest` / `RunTaskRequest` extras not covered by {@link extractRunTaskStrategyOverrides}).
+ */
+export declare function extractRunTaskMetadataPassthrough(taskConfiguration: Record<string, unknown> | undefined | null): RunTaskMetadataPassthrough;
+export type BuildAiTasksRunTaskRequestArgs = {
+    skillKey: string;
+    job?: Job;
+    /** Graph task node id — used for `nodeId`, `coreSkillId`, and default `taskTypeId`. */
+    nodeId: string;
+    taskConfiguration?: Record<string, unknown>;
+    graphId?: string;
+    taskId: string;
+    runTaskJobId: string;
+    /** Canonical ai-tasks task payload (`input`). */
+    taskInput: Record<string, unknown>;
+    /** Caller / graph-entry bag (`inputs`); forwarded when non-empty for dual-root smart-input resolution. */
+    callerInputs?: Record<string, unknown>;
+    variables?: Record<string, unknown>;
+    jobMemory?: unknown;
+    taskMemory?: unknown;
+    executionMemory?: Record<string, unknown>;
+    jobContext?: Record<string, unknown>;
+    prevNodeId?: string;
+    executionPipeline?: ExecutionStepOption[];
+    includeContextInPrompt?: boolean;
+    narrix?: ResolvedNarrixWirePayload;
+    outputValidation?: RunTaskRequest['outputValidation'];
+    diagnostics?: RunTaskRequest['diagnostics'];
+    modelConfig?: GraphAiModelConfig;
+    llmCall?: LlmCallConfig;
+    identity?: Record<string, unknown>;
+    executionMode?: 'default' | 'trace';
+    taskKind?: RunTaskRequest['taskKind'];
+    autoValidateDecisionOutput?: boolean;
+    /** Overrides default `resolveTaskTypeId(skillKey, nodeId, taskConfiguration)` e.g. engine strategy phases. */
+    taskTypeIdOverride?: string;
+    /** Usually from `taskConfiguration.narrixMode` via {@link extractRunTaskStrategyOverrides}. */
+    narrixMode?: RunTaskRequest['narrixMode'];
+    inputStrategyKey?: RunTaskRequest['inputStrategyKey'];
+    narrixInput?: RunTaskRequest['narrixInput'];
+    /** Required on every request for ai-tasks ≥ 7.1.x — use `[]` for plain MAIN. */
+    executionStrategies?: RunTaskRequest['executionStrategies'];
+    xynthesized?: XynthesizedMemory;
+    smartInput?: SmartInputConfig;
+};
+export declare function resolveJobTypeId(job?: Job): string;
+export declare function resolveTaskTypeId(skillKey: string, nodeId: string, taskConfiguration?: Record<string, unknown>): string;
+export declare function buildAiTasksRunTaskRequest(args: BuildAiTasksRunTaskRequestArgs): RunTaskRequest;

package/dist/src/runtime/buildAiTasksRunTaskRequest.js

@@ -0,0 +1,164 @@
+import { buildRunTaskTaskConfigurationForward } from './buildRunTaskTaskConfigurationForward.js';
+import { normalizeSmartInputConfigForRunTask } from './smartInputPaths.js';
+/** Reads task-node `taskConfiguration` keys forwarded to `@exellix/ai-tasks` `RunTaskRequest` (runtime strategy / Narrix wiring). */
+export function extractRunTaskStrategyOverrides(taskConfiguration) {
+    if (taskConfiguration == null || typeof taskConfiguration !== 'object' || Array.isArray(taskConfiguration))
+        return {};
+    const m = taskConfiguration;
+    const out = {};
+    const narrixMode = m.narrixMode;
+    if (typeof narrixMode === 'string' && narrixMode.trim() !== '') {
+        out.narrixMode = narrixMode.trim();
+    }
+    const inputStrategyKey = m.inputStrategyKey;
+    if (typeof inputStrategyKey === 'string' && inputStrategyKey.trim() !== '') {
+        out.inputStrategyKey = inputStrategyKey.trim();
+    }
+    const narrixInput = m.narrixInput;
+    if (narrixInput != null && typeof narrixInput === 'object' && !Array.isArray(narrixInput)) {
+        out.narrixInput = narrixInput;
+    }
+    return out;
+}
+/**
+ * Whitelisted optional transport fields from task-node `taskConfiguration` for `@exellix/ai-tasks` ≥ 7.2.x
+ * (`RunSkillRequest` / `RunTaskRequest` extras not covered by {@link extractRunTaskStrategyOverrides}).
+ */
+export function extractRunTaskMetadataPassthrough(taskConfiguration) {
+    if (taskConfiguration == null || typeof taskConfiguration !== 'object' || Array.isArray(taskConfiguration))
+        return {};
+    const m = taskConfiguration;
+    const out = {};
+    const narrixScope = m.narrixScope;
+    if (narrixScope != null && typeof narrixScope === 'object' && !Array.isArray(narrixScope)) {
+        out.narrixScope = narrixScope;
+    }
+    const aiScoping = m.aiScoping;
+    if (Array.isArray(aiScoping)) {
+        out.aiScoping = aiScoping;
+    }
+    const aiScopingOptions = m.aiScopingOptions;
+    if (aiScopingOptions != null && typeof aiScopingOptions === 'object' && !Array.isArray(aiScopingOptions)) {
+        out.aiScopingOptions = aiScopingOptions;
+    }
+    const timeoutMs = m.timeoutMs;
+    if (typeof timeoutMs === 'number' && Number.isFinite(timeoutMs)) {
+        out.timeoutMs = timeoutMs;
+    }
+    const templateRenderOptions = m.templateRenderOptions;
+    if (templateRenderOptions != null && typeof templateRenderOptions === 'object' && !Array.isArray(templateRenderOptions)) {
+        out.templateRenderOptions = templateRenderOptions;
+    }
+    const smartInputRenderOptions = m.smartInputRenderOptions;
+    if (smartInputRenderOptions != null &&
+        typeof smartInputRenderOptions === 'object' &&
+        !Array.isArray(smartInputRenderOptions)) {
+        out.smartInputRenderOptions = smartInputRenderOptions;
+    }
+    const templateTokens = m.templateTokens;
+    if (templateTokens != null && typeof templateTokens === 'object' && !Array.isArray(templateTokens)) {
+        out.templateTokens = templateTokens;
+    }
+    const aiEngineId = m.aiEngineId;
+    if (typeof aiEngineId === 'string' && aiEngineId.trim() !== '') {
+        out.aiEngineId = aiEngineId.trim();
+    }
+    const sessionId = m.sessionId;
+    if (typeof sessionId === 'string' && sessionId.trim() !== '') {
+        out.sessionId = sessionId.trim();
+    }
+    const agentType = m.agentType;
+    if (agentType === 'chat' ||
+        agentType === 'ai-reasoner' ||
+        agentType === 'ai-auditor' ||
+        agentType === 'ai-scoper' ||
+        agentType === 'ai-discovery' ||
+        agentType === 'ai-planner' ||
+        agentType === 'ai-executor') {
+        out.agentType = agentType;
+    }
+    const gatewayDiagnostics = m.gatewayDiagnostics;
+    if (gatewayDiagnostics != null && typeof gatewayDiagnostics === 'object' && !Array.isArray(gatewayDiagnostics)) {
+        out.gatewayDiagnostics = gatewayDiagnostics;
+    }
+    if (m.context !== undefined) {
+        out.context = m.context;
+    }
+    if (m.knowledge !== undefined) {
+        out.knowledge = m.knowledge;
+    }
+    const executionStrategyCatalogItems = m.executionStrategyCatalogItems;
+    if (Array.isArray(executionStrategyCatalogItems)) {
+        out.executionStrategyCatalogItems = executionStrategyCatalogItems;
+    }
+    return out;
+}
+export function resolveJobTypeId(job) {
+    const j = job;
+    const raw = j?.jobType ?? j?.jobTypeId;
+    return typeof raw === 'string' && raw.trim() !== '' ? raw.trim() : 'exellix-graph-job';
+}
+export function resolveTaskTypeId(skillKey, nodeId, taskConfiguration) {
+    const raw = taskConfiguration?.taskTypeId;
+    if (typeof raw === 'string' && raw.trim() !== '')
+        return raw.trim();
+    return skillKey;
+}
+export function buildAiTasksRunTaskRequest(args) {
+    const agentId = typeof args.job?.agentId === 'string' && args.job.agentId.trim() !== ''
+        ? args.job.agentId.trim()
+        : 'standalone-agent';
+    const jobTypeId = resolveJobTypeId(args.job);
+    const taskTypeId = args.taskTypeIdOverride ??
+        resolveTaskTypeId(args.skillKey, args.nodeId, args.taskConfiguration);
+    const masterSkillActivityId = `${args.runTaskJobId}:${args.nodeId}`;
+    const executionStrategies = args.executionStrategies ?? [];
+    const metaPassthrough = extractRunTaskMetadataPassthrough(args.taskConfiguration);
+    const taskConfigurationForward = buildRunTaskTaskConfigurationForward(args.taskConfiguration);
+    const smartInputForward = normalizeSmartInputConfigForRunTask(args.smartInput);
+    const req = {
+        ...metaPassthrough,
+        skillKey: args.skillKey,
+        jobId: args.runTaskJobId,
+        taskId: args.taskId,
+        agentId,
+        jobTypeId,
+        taskTypeId,
+        coreSkillId: args.nodeId,
+        nodeId: args.nodeId,
+        ...(args.graphId != null && args.graphId !== '' ? { graphId: args.graphId } : {}),
+        masterSkillId: args.graphId,
+        masterSkillActivityId,
+        input: { ...args.taskInput },
+        ...(args.callerInputs != null && Object.keys(args.callerInputs).length > 0
+            ? { inputs: { ...args.callerInputs } }
+            : {}),
+        ...(args.variables != null && typeof args.variables === 'object' && !Array.isArray(args.variables)
+            ? { variables: args.variables }
+            : {}),
+        ...(args.jobMemory !== undefined ? { jobMemory: args.jobMemory } : {}),
+        ...(args.taskMemory !== undefined ? { taskMemory: args.taskMemory } : {}),
+        ...(args.executionMemory != null ? { executionMemory: args.executionMemory } : {}),
+        ...(args.jobContext != null ? { jobContext: args.jobContext } : {}),
+        ...(args.prevNodeId != null && args.prevNodeId !== '' ? { prevNodeId: args.prevNodeId } : {}),
+        ...(args.executionPipeline != null ? { executionPipeline: args.executionPipeline } : {}),
+        ...(args.includeContextInPrompt === true ? { includeContextInPrompt: true } : {}),
+        ...(args.narrix != null ? { narrix: args.narrix } : {}),
+        ...(args.outputValidation != null ? { outputValidation: args.outputValidation } : {}),
+        ...(args.diagnostics != null ? { diagnostics: args.diagnostics } : {}),
+        ...(args.modelConfig != null ? { modelConfig: args.modelConfig } : {}),
+        ...(args.llmCall != null ? { llmCall: args.llmCall } : {}),
+        ...(args.identity != null ? { identity: args.identity } : {}),
+        ...(args.executionMode != null ? { executionMode: args.executionMode } : {}),
+        ...(args.taskKind != null ? { taskKind: args.taskKind } : {}),
+        ...(args.autoValidateDecisionOutput !== undefined ? { autoValidateDecisionOutput: args.autoValidateDecisionOutput } : {}),
+        ...(args.narrixMode != null ? { narrixMode: args.narrixMode } : {}),
+        ...(args.inputStrategyKey != null ? { inputStrategyKey: args.inputStrategyKey } : {}),
+        ...(args.narrixInput != null ? { narrixInput: args.narrixInput } : {}),
+        executionStrategies,
+        ...(args.xynthesized != null ? { xynthesized: args.xynthesized } : {}),
+        ...(smartInputForward != null ? { smartInput: smartInputForward } : {}),
+        ...(taskConfigurationForward != null ? { taskConfiguration: taskConfigurationForward } : {}),
+    };
+    return req;
+}

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

@@ -0,0 +1,27 @@
+import type { RunLogEntry, RunLogBuildOptions, RunLogBuildResult } from '../types/runLog.js';
+/** Truncate `data` for HTTP/console payloads; returns replacement suitable for `RunLogEntry.data`. */
+export declare function truncateRunLogData(data: unknown, maxJsonChars: number): unknown;
+/** Normalize @exellix/ai-tasks epoch-ms or ISO `ts` to epoch ms for exellix-graph `RunLogEntry`. */
+export declare function parseRunLogEntryTs(v: unknown): number;
+/** Normalize entries from ai-tasks metadata (best-effort). */
+export declare function normalizeExternalRunLogEntries(raw: unknown): RunLogEntry[];
+export declare function extractTaskRunLogFromMetadata(metadata: unknown): RunLogEntry[];
+export declare function extractLogxerCorrelationFromMetadata(metadata: unknown): string | undefined;
+/**
+ * Build merged `runLog` for a completed graph run from execution trace + optional per-task lines.
+ */
+export declare function buildRunLog(opts: RunLogBuildOptions): RunLogBuildResult;
+export declare function resolveRunLogLimits(input: {
+    runLogMode?: import('../types/runLog.js').RunLogMode;
+    maxRunLogEntries?: number;
+    maxRunLogDataJsonChars?: number;
+    defaults?: {
+        runLogMode?: import('../types/runLog.js').RunLogMode;
+        maxRunLogEntries?: number;
+        maxRunLogDataJsonChars?: number;
+    };
+}): {
+    mode: import('../types/runLog.js').RunLogMode;
+    maxEntries: number;
+    maxDataJsonChars: number;
+};