@exellix/graph-engine 8.0.0 → 8.1.0

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,
-    };
-}

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

@@ -1,7 +0,0 @@
-import type { GraphModelObject } from '../types/refs.js';
-export type MigrateGraphResponseResult<T> = {
-    graph: T;
-    migrated: boolean;
-};
-export declare function migrateLegacyGraphResponseDefinition<T extends object>(graph: T): MigrateGraphResponseResult<T>;
-export declare function migrateLegacyGraphResponse<T extends GraphModelObject | object>(graph: T): MigrateGraphResponseResult<T>;

package/dist/src/runtime/graphResponseMigration.js

@@ -1,44 +0,0 @@
-const LEGACY_RESPONSE_DROP_KEYS = new Set([
-    'version',
-    'target',
-    'primaryResponsePaths',
-    'debugResponsePaths',
-    'notableExecutionPaths',
-    'mappingPreset',
-]);
-function isPlainObject(value) {
-    return value != null && typeof value === 'object' && !Array.isArray(value);
-}
-function cloneGraph(graph) {
-    return structuredClone(graph);
-}
-export function migrateLegacyGraphResponseDefinition(graph) {
-    const graphRecord = graph;
-    const metadata = isPlainObject(graphRecord.metadata) ? graphRecord.metadata : undefined;
-    const graphResponse = metadata && isPlainObject(metadata.graphResponse) ? metadata.graphResponse : undefined;
-    const legacyMapping = graphResponse && isPlainObject(graphResponse.responseMapping)
-        ? graphResponse.responseMapping
-        : undefined;
-    if (graphRecord.response !== undefined || !legacyMapping) {
-        return { graph, migrated: false };
-    }
-    const next = cloneGraph(graph);
-    const nextRecord = next;
-    const response = {};
-    for (const [key, value] of Object.entries(legacyMapping)) {
-        if (LEGACY_RESPONSE_DROP_KEYS.has(key))
-            continue;
-        response[key] = value;
-    }
-    if (!Object.prototype.hasOwnProperty.call(response, 'missing')) {
-        response.missing = 'omit';
-    }
-    nextRecord.response = response;
-    if (isPlainObject(nextRecord.metadata)) {
-        delete nextRecord.metadata.graphResponse;
-    }
-    return { graph: next, migrated: true };
-}
-export function migrateLegacyGraphResponse(graph) {
-    return migrateLegacyGraphResponseDefinition(graph);
-}