@framers/agentos 0.1.128 → 0.1.130

package/dist/orchestration/planning/MissionExpansionHandler.js

@@ -68,6 +68,77 @@ function estimateComplexity(node) {
         return 0.5;
     return 0.35;
 }
+function buildExecutorConfig(raw, fallbackId) {
+    if (isRecord(raw.executorConfig)) {
+        return raw.executorConfig;
+    }
+    const type = String(raw.type ?? 'gmi');
+    switch (type) {
+        case 'tool':
+            return {
+                type: 'tool',
+                toolName: String(raw.toolName ?? raw.name ?? fallbackId),
+                ...(isRecord(raw.args) ? { args: raw.args } : {}),
+            };
+        case 'extension':
+            return {
+                type: 'extension',
+                extensionId: String(raw.extensionId ?? 'extension'),
+                method: String(raw.method ?? 'run'),
+            };
+        case 'human':
+            return {
+                type: 'human',
+                prompt: String(raw.prompt ?? raw.instructions ?? raw.role ?? `Review ${fallbackId}`),
+            };
+        case 'guardrail':
+            return {
+                type: 'guardrail',
+                guardrailIds: Array.isArray(raw.guardrailIds)
+                    ? raw.guardrailIds.filter((value) => typeof value === 'string')
+                    : [],
+                onViolation: raw.onViolation === 'reroute'
+                    || raw.onViolation === 'warn'
+                    || raw.onViolation === 'sanitize'
+                    ? raw.onViolation
+                    : 'block',
+                ...(typeof raw.rerouteTarget === 'string' ? { rerouteTarget: raw.rerouteTarget } : {}),
+            };
+        case 'router':
+            return {
+                type: 'router',
+                condition: (raw.condition?.type
+                    ? raw.condition
+                    : { type: 'expression', expr: `'${END}'` }),
+            };
+        case 'subgraph':
+            return {
+                type: 'subgraph',
+                graphId: String(raw.graphId ?? fallbackId),
+                ...(isRecord(raw.inputMapping) ? { inputMapping: raw.inputMapping } : {}),
+                ...(isRecord(raw.outputMapping) ? { outputMapping: raw.outputMapping } : {}),
+            };
+        case 'voice':
+            return {
+                type: 'voice',
+                voiceConfig: isRecord(raw.voiceConfig)
+                    ? raw.voiceConfig
+                    : { mode: 'conversation' },
+            };
+        case 'gmi':
+        default:
+            return {
+                type: 'gmi',
+                instructions: String(raw.instructions ?? raw.role ?? `Execute ${fallbackId}`),
+                ...(typeof raw.maxInternalIterations === 'number'
+                    ? { maxInternalIterations: raw.maxInternalIterations }
+                    : {}),
+                ...(typeof raw.parallelTools === 'boolean' ? { parallelTools: raw.parallelTools } : {}),
+                ...(typeof raw.temperature === 'number' ? { temperature: raw.temperature } : {}),
+                ...(typeof raw.maxTokens === 'number' ? { maxTokens: raw.maxTokens } : {}),
+            };
+    }
+}
 function normalizeNode(raw) {
     const checkpoint = raw.checkpoint === true
         ? 'after'
@@ -80,15 +151,28 @@ function normalizeNode(raw) {
     return {
         id,
         type: String(raw.type ?? 'gmi'),
-        executorConfig: raw.executorConfig ?? {
-            type: 'gmi',
-            instructions: String(raw.instructions ?? raw.role ?? `Execute ${id}`),
-        },
+        executorConfig: buildExecutorConfig(raw, id),
         executionMode: raw.executionMode ?? 'single_turn',
         effectClass: raw.effectClass ?? 'read',
         checkpoint,
         complexity: clampComplexity(raw.complexity),
         ...(isRecord(raw.llm) ? { llm: raw.llm } : {}),
+        ...(typeof raw.timeout === 'number' ? { timeout: raw.timeout } : {}),
+        ...(isRecord(raw.retryPolicy) ? { retryPolicy: raw.retryPolicy } : {}),
+        ...(isRecord(raw.inputSchema) ? { inputSchema: raw.inputSchema } : {}),
+        ...(isRecord(raw.outputSchema) ? { outputSchema: raw.outputSchema } : {}),
+        ...(isRecord(raw.memoryPolicy)
+            ? { memoryPolicy: raw.memoryPolicy }
+            : {}),
+        ...(isRecord(raw.discoveryPolicy)
+            ? { discoveryPolicy: raw.discoveryPolicy }
+            : {}),
+        ...(isRecord(raw.personaPolicy)
+            ? { personaPolicy: raw.personaPolicy }
+            : {}),
+        ...(isRecord(raw.guardrailPolicy)
+            ? { guardrailPolicy: raw.guardrailPolicy }
+            : {}),
     };
 }
 function normalizeEdge(raw, index) {
@@ -149,71 +233,384 @@ function describeRole(node) {
         return `tool:${node.executorConfig.toolName}`;
     return node.id;
 }
+function isToolLikeNode(node) {
+    return node.type === 'tool' || node.executorConfig.type === 'tool';
+}
+function computeGraphDepth(graph) {
+    const depths = new Map();
+    const queue = [];
+    for (const edge of graph.edges) {
+        if (edge.source !== START || edge.target === END)
+            continue;
+        queue.push({ nodeId: edge.target, depth: 1 });
+    }
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const previousDepth = depths.get(current.nodeId) ?? Number.POSITIVE_INFINITY;
+        if (current.depth >= previousDepth)
+            continue;
+        depths.set(current.nodeId, current.depth);
+        for (const edge of graph.edges) {
+            if (edge.source !== current.nodeId || edge.target === END)
+                continue;
+            queue.push({ nodeId: edge.target, depth: current.depth + 1 });
+        }
+    }
+    return Math.max(0, ...depths.values());
+}
+function resolveSourceNodeId(spec, requesterNodeId) {
+    for (const key of ['afterNodeId', 'sourceNodeId', 'parentNodeId']) {
+        const value = spec[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return requesterNodeId;
+}
+function resolveTargetNodeId(spec) {
+    for (const key of ['nodeId', 'targetNodeId', 'agentId']) {
+        const value = spec[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    return '';
+}
+function cloneEdge(edge, overrides, suffix) {
+    return {
+        ...edge,
+        ...overrides,
+        id: `${edge.id}_${suffix}`,
+    };
+}
+function dedupeEdges(edges) {
+    const seen = new Set();
+    const result = [];
+    for (const edge of edges) {
+        const key = JSON.stringify({
+            source: edge.source,
+            target: edge.target,
+            type: edge.type,
+            condition: edge.condition,
+            discoveryQuery: edge.discoveryQuery,
+            discoveryKind: edge.discoveryKind,
+            discoveryFallback: edge.discoveryFallback,
+            personalityCondition: edge.personalityCondition,
+            guardrailPolicy: edge.guardrailPolicy,
+        });
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(edge);
+    }
+    return result;
+}
+function buildInlineInsertionPatch(newNode, graph, sourceNodeId, reason, estimates) {
+    const outEdges = graph.edges.filter((edge) => edge.source === sourceNodeId);
+    const staticOutEdges = outEdges.filter((edge) => edge.type === 'static');
+    const addEdges = [
+        {
+            id: `expansion_edge_${sourceNodeId}_${newNode.id}`,
+            source: sourceNodeId,
+            target: newNode.id,
+            type: 'static',
+        },
+    ];
+    const rewireEdges = [];
+    if (staticOutEdges.length > 0) {
+        for (const edge of staticOutEdges) {
+            rewireEdges.push({
+                from: sourceNodeId,
+                to: edge.target,
+                newTarget: newNode.id,
+            });
+            addEdges.push(cloneEdge(edge, { source: newNode.id }, `after_${newNode.id}`));
+        }
+    }
+    else {
+        addEdges.push({
+            id: `expansion_edge_${newNode.id}_end`,
+            source: newNode.id,
+            target: END,
+            type: 'static',
+        });
+    }
+    return {
+        addNodes: [newNode],
+        addEdges: dedupeEdges(addEdges),
+        removeNodes: [],
+        rewireEdges,
+        reason,
+        estimatedCostDelta: estimates.cost,
+        estimatedLatencyDelta: estimates.latencyMs,
+    };
+}
 function buildSpawnAgentPatch(spec, graph, requesterNodeId, reason) {
     const role = String(spec.role ?? spec.nodeId ?? spec.name ?? 'support_agent');
     const instructions = String(spec.instructions ?? `Handle ${role}`);
     const nodeId = typeof spec.nodeId === 'string' && spec.nodeId.trim()
         ? spec.nodeId.trim()
         : slugify(role);
+    const sourceNodeId = resolveSourceNodeId(spec, requesterNodeId);
     const newNode = normalizeNode({
         id: nodeId,
         type: spec.type ?? 'gmi',
         executorConfig: isRecord(spec.executorConfig)
             ? spec.executorConfig
-            : {
-                type: 'gmi',
+            : buildExecutorConfig({
+                ...spec,
+                type: spec.type ?? 'gmi',
                 instructions,
-            },
+            }, nodeId),
         executionMode: spec.executionMode ?? 'single_turn',
         effectClass: spec.effectClass ?? 'read',
         checkpoint: spec.checkpoint ?? 'after',
         complexity: spec.complexity,
+        ...(isRecord(spec.llm) ? { llm: spec.llm } : {}),
     });
-    const outEdges = graph.edges.filter((edge) => edge.source === requesterNodeId);
-    const staticOutEdges = outEdges.filter((edge) => edge.type === 'static');
-    const addEdges = [];
-    const rewireEdges = [];
-    addEdges.push({
-        id: `expansion_edge_${requesterNodeId}_${nodeId}`,
-        source: requesterNodeId,
-        target: nodeId,
-        type: 'static',
+    return buildInlineInsertionPatch(newNode, graph, sourceNodeId, reason, {
+        cost: typeof spec.estimatedCostDelta === 'number' && Number.isFinite(spec.estimatedCostDelta)
+            ? spec.estimatedCostDelta
+            : 0.5,
+        latencyMs: typeof spec.estimatedLatencyDelta === 'number' && Number.isFinite(spec.estimatedLatencyDelta)
+            ? spec.estimatedLatencyDelta
+            : 30000,
     });
-    if (staticOutEdges.length > 0) {
-        for (const edge of staticOutEdges) {
-            rewireEdges.push({
-                from: requesterNodeId,
-                to: edge.target,
-                newTarget: nodeId,
-            });
-            addEdges.push({
-                id: `expansion_edge_${nodeId}_${edge.target}`,
-                source: nodeId,
-                target: edge.target,
-                type: 'static',
-            });
+}
+function buildRemoveAgentPatch(spec, graph, reason) {
+    const nodeId = resolveTargetNodeId(spec);
+    if (!nodeId)
+        return null;
+    const incomingStatic = graph.edges.filter((edge) => edge.target === nodeId && edge.type === 'static');
+    const outgoingStatic = graph.edges.filter((edge) => edge.source === nodeId && edge.type === 'static');
+    const nextTargets = outgoingStatic.length > 0
+        ? outgoingStatic.map((edge) => edge.target)
+        : [END];
+    const addEdges = [];
+    for (const edge of incomingStatic) {
+        for (const nextTarget of nextTargets) {
+            if (edge.source === nextTarget)
+                continue;
+            addEdges.push(cloneEdge(edge, { target: nextTarget }, `remove_${nodeId}_${nextTarget.replace(/[^a-zA-Z0-9_-]/g, '_')}`));
         }
     }
+    return {
+        addNodes: [],
+        addEdges: dedupeEdges(addEdges),
+        removeNodes: [nodeId],
+        rewireEdges: [],
+        reason,
+        estimatedCostDelta: 0,
+        estimatedLatencyDelta: 0,
+    };
+}
+function buildReassignedNode(existing, spec) {
+    const nextType = (typeof spec.type === 'string' && spec.type.trim()
+        ? spec.type.trim()
+        : existing.type);
+    let executorConfig = existing.executorConfig;
+    if (isRecord(spec.executorConfig)) {
+        executorConfig = spec.executorConfig;
+    }
     else {
+        const nextRole = typeof spec.role === 'string' ? spec.role : undefined;
+        const nextInstructions = typeof spec.instructions === 'string' ? spec.instructions : nextRole;
+        if (nextType === 'gmi' && nextInstructions) {
+            executorConfig = {
+                type: 'gmi',
+                ...(existing.executorConfig.type === 'gmi' ? existing.executorConfig : {}),
+                instructions: nextInstructions,
+            };
+        }
+        else if (nextType === 'tool') {
+            const existingArgs = existing.executorConfig.type === 'tool' ? existing.executorConfig.args : undefined;
+            executorConfig = {
+                type: 'tool',
+                toolName: String(spec.toolName
+                    ?? (existing.executorConfig.type === 'tool' ? existing.executorConfig.toolName : existing.id)),
+                ...(isRecord(spec.args)
+                    ? { args: spec.args }
+                    : existingArgs
+                        ? { args: existingArgs }
+                        : {}),
+            };
+        }
+        else if (nextType === 'human' && nextInstructions) {
+            executorConfig = { type: 'human', prompt: nextInstructions };
+        }
+        else if (nextType !== existing.type) {
+            executorConfig = buildExecutorConfig({ ...spec, type: nextType }, existing.id);
+        }
+    }
+    return {
+        ...existing,
+        type: nextType,
+        executorConfig,
+        executionMode: spec.executionMode ?? existing.executionMode,
+        effectClass: spec.effectClass ?? existing.effectClass,
+        checkpoint: spec.checkpoint === true
+            ? 'after'
+            : spec.checkpoint === false
+                ? 'none'
+                : spec.checkpoint ?? existing.checkpoint,
+        complexity: clampComplexity(spec.complexity)
+            ?? existing.complexity,
+        ...(nextType === 'gmi'
+            ? isRecord(spec.llm)
+                ? { llm: spec.llm }
+                : existing.llm
+                    ? { llm: existing.llm }
+                    : {}
+            : {}),
+        ...('timeout' in spec && typeof spec.timeout === 'number' ? { timeout: spec.timeout } : {}),
+    };
+}
+function buildReassignRolePatch(spec, graph, reason) {
+    const nodeId = resolveTargetNodeId(spec);
+    if (!nodeId)
+        return null;
+    const existing = graph.nodes.find((node) => node.id === nodeId);
+    if (!existing)
+        return null;
+    const replacementNode = buildReassignedNode(existing, spec);
+    const incomingEdges = graph.edges.filter((edge) => edge.target === nodeId);
+    const outgoingEdges = graph.edges.filter((edge) => edge.source === nodeId);
+    const addEdges = dedupeEdges([
+        ...incomingEdges.map((edge) => cloneEdge(edge, { target: nodeId }, 'reassign_in')),
+        ...outgoingEdges.map((edge) => cloneEdge(edge, { source: nodeId }, 'reassign_out')),
+    ]);
+    return {
+        addNodes: [replacementNode],
+        addEdges,
+        removeNodes: [nodeId],
+        rewireEdges: [],
+        reason,
+        estimatedCostDelta: typeof spec.estimatedCostDelta === 'number' && Number.isFinite(spec.estimatedCostDelta)
+            ? spec.estimatedCostDelta
+            : 0.1,
+        estimatedLatencyDelta: typeof spec.estimatedLatencyDelta === 'number' && Number.isFinite(spec.estimatedLatencyDelta)
+            ? spec.estimatedLatencyDelta
+            : 0,
+    };
+}
+function buildAddToolPatch(spec, graph, requesterNodeId, reason) {
+    const sourceNodeId = resolveSourceNodeId(spec, requesterNodeId);
+    const toolName = typeof spec.toolName === 'string' && spec.toolName.trim()
+        ? spec.toolName.trim()
+        : typeof spec.name === 'string' && spec.name.trim()
+            ? spec.name.trim()
+            : '';
+    if (!toolName && !isRecord(spec.executorConfig))
+        return null;
+    const nodeId = typeof spec.nodeId === 'string' && spec.nodeId.trim()
+        ? spec.nodeId.trim()
+        : slugify(toolName || 'tool_step');
+    const newNode = normalizeNode({
+        ...spec,
+        id: nodeId,
+        type: 'tool',
+        executorConfig: isRecord(spec.executorConfig)
+            ? spec.executorConfig
+            : {
+                type: 'tool',
+                toolName,
+                ...(isRecord(spec.args) ? { args: spec.args } : {}),
+            },
+        executionMode: spec.executionMode ?? 'single_turn',
+        effectClass: spec.effectClass ?? 'read',
+        checkpoint: spec.checkpoint ?? 'after',
+    });
+    return buildInlineInsertionPatch(newNode, graph, sourceNodeId, reason, {
+        cost: typeof spec.estimatedCostDelta === 'number' && Number.isFinite(spec.estimatedCostDelta)
+            ? spec.estimatedCostDelta
+            : 0.15,
+        latencyMs: typeof spec.estimatedLatencyDelta === 'number' && Number.isFinite(spec.estimatedLatencyDelta)
+            ? spec.estimatedLatencyDelta
+            : 5000,
+    });
+}
+function buildForkBranchPatch(spec, graph, requesterNodeId, reason) {
+    const sourceNodeId = resolveSourceNodeId(spec, requesterNodeId);
+    const branchNodes = Array.isArray(spec.nodes)
+        ? spec.nodes.filter(isRecord).map((node) => normalizeNode(node))
+        : [];
+    if (branchNodes.length === 0) {
+        const role = String(spec.role ?? spec.nodeId ?? spec.name ?? 'branch_worker');
+        const branchNodeId = typeof spec.nodeId === 'string' && spec.nodeId.trim()
+            ? spec.nodeId.trim()
+            : slugify(role);
+        branchNodes.push(normalizeNode({
+            ...spec,
+            id: branchNodeId,
+            type: spec.type ?? 'gmi',
+            executorConfig: isRecord(spec.executorConfig)
+                ? spec.executorConfig
+                : buildExecutorConfig({
+                    ...spec,
+                    type: spec.type ?? 'gmi',
+                    instructions: spec.instructions ?? `Handle ${role}`,
+                }, branchNodeId),
+            executionMode: spec.executionMode ?? 'single_turn',
+            effectClass: spec.effectClass ?? 'read',
+            checkpoint: spec.checkpoint ?? 'after',
+            complexity: spec.complexity,
+        }));
+    }
+    if (branchNodes.length === 0)
+        return null;
+    const explicitJoinTargets = Array.isArray(spec.joinTargets)
+        ? spec.joinTargets.filter((value) => typeof value === 'string' && value.trim().length > 0)
+        : [];
+    const joinTarget = typeof spec.joinTarget === 'string' && spec.joinTarget.trim()
+        ? spec.joinTarget.trim()
+        : typeof spec.joinTargetId === 'string' && spec.joinTargetId.trim()
+            ? spec.joinTargetId.trim()
+            : '';
+    const sourceStaticTargets = graph.edges
+        .filter((edge) => edge.source === sourceNodeId && edge.type === 'static')
+        .map((edge) => edge.target);
+    const joinTargets = explicitJoinTargets.length > 0
+        ? explicitJoinTargets
+        : joinTarget
+            ? [joinTarget]
+            : sourceStaticTargets.length > 0
+                ? sourceStaticTargets
+                : [END];
+    const addEdges = [
+        {
+            id: `expansion_edge_${sourceNodeId}_${branchNodes[0].id}`,
+            source: sourceNodeId,
+            target: branchNodes[0].id,
+            type: 'static',
+        },
+    ];
+    for (let index = 0; index < branchNodes.length - 1; index++) {
         addEdges.push({
-            id: `expansion_edge_${nodeId}_end`,
-            source: nodeId,
-            target: END,
+            id: `expansion_edge_${branchNodes[index].id}_${branchNodes[index + 1].id}`,
+            source: branchNodes[index].id,
+            target: branchNodes[index + 1].id,
+            type: 'static',
+        });
+    }
+    const lastNodeId = branchNodes[branchNodes.length - 1].id;
+    for (const target of joinTargets) {
+        addEdges.push({
+            id: `expansion_edge_${lastNodeId}_${target.replace(/[^a-zA-Z0-9_-]/g, '_')}`,
+            source: lastNodeId,
+            target,
             type: 'static',
         });
     }
     return {
-        addNodes: [newNode],
-        addEdges,
+        addNodes: branchNodes,
+        addEdges: dedupeEdges(addEdges),
         removeNodes: [],
-        rewireEdges,
+        rewireEdges: [],
         reason,
         estimatedCostDelta: typeof spec.estimatedCostDelta === 'number' && Number.isFinite(spec.estimatedCostDelta)
             ? spec.estimatedCostDelta
-            : 0.5,
+            : 0.35 * branchNodes.length,
         estimatedLatencyDelta: typeof spec.estimatedLatencyDelta === 'number' && Number.isFinite(spec.estimatedLatencyDelta)
             ? spec.estimatedLatencyDelta
-            : 30000,
+            : 20000 * branchNodes.length,
     };
 }
 function buildManageGraphPatch(request, graph, requesterNodeId) {
@@ -229,18 +626,16 @@ function buildManageGraphPatch(request, graph, requesterNodeId) {
         return buildSpawnAgentPatch(spec, graph, requesterNodeId, reason);
     }
     if (action === 'remove_agent') {
-        const nodeId = typeof spec.nodeId === 'string' ? spec.nodeId.trim() : '';
-        if (!nodeId)
-            return null;
-        return {
-            addNodes: [],
-            addEdges: [],
-            removeNodes: [nodeId],
-            rewireEdges: [],
-            reason,
-            estimatedCostDelta: 0,
-            estimatedLatencyDelta: 0,
-        };
+        return buildRemoveAgentPatch(spec, graph, reason);
+    }
+    if (action === 'reassign_role') {
+        return buildReassignRolePatch(spec, graph, reason);
+    }
+    if (action === 'add_tool') {
+        return buildAddToolPatch(spec, graph, requesterNodeId, reason);
+    }
+    if (action === 'fork_branch') {
+        return buildForkBranchPatch(spec, graph, requesterNodeId, reason);
     }
     return null;
 }
@@ -253,7 +648,6 @@ export function createMissionExpansionHandler(options) {
     let currentEstimatedCost = options.initialEstimatedCost ?? 0;
     let currentExpansions = 0;
     let currentToolForges = 0;
-    let currentDepth = 0;
     const assignProviders = (patch) => {
         const nodes = [...patch.addNodes];
         const gmiNodes = nodes.filter((node) => node.type === 'gmi' && !node.llm);
@@ -358,6 +752,11 @@ export function createMissionExpansionHandler(options) {
                 return null;
             }
             const assignedPatch = assignProviders(patch);
+            const currentDepth = computeGraphDepth(context.graph);
+            const previewGraph = expander.applyPatch(context.graph, assignedPatch);
+            const nextDepth = computeGraphDepth(previewGraph);
+            const patchToolForgeDelta = assignedPatch.addNodes.filter(isToolLikeNode).length;
+            const patchDepthDelta = Math.max(0, nextDepth - currentDepth);
             const patchAgentDelta = assignedPatch.addNodes.length - (assignedPatch.removeNodes?.length ?? 0);
             const state = {
                 currentCost: currentEstimatedCost,
@@ -367,8 +766,8 @@ export function createMissionExpansionHandler(options) {
                 currentDepth,
                 patchCostDelta: assignedPatch.estimatedCostDelta,
                 patchAgentDelta,
-                patchToolForgeDelta: 0,
-                patchDepthDelta: 0,
+                patchToolForgeDelta,
+                patchDepthDelta,
             };
             const events = [
                 {
@@ -400,9 +799,10 @@ export function createMissionExpansionHandler(options) {
                 });
                 return { events };
             }
-            const nextGraph = expander.applyPatch(context.graph, assignedPatch);
+            const nextGraph = previewGraph;
             currentEstimatedCost += assignedPatch.estimatedCostDelta;
             currentExpansions += 1;
+            currentToolForges += patchToolForgeDelta;
             events.push({ type: 'mission:expansion_approved', by: 'auto' });
             events.push({
                 type: 'mission:expansion_applied',