genaicode 0.10.0 → 0.10.2

package/dist/prompt/steps/step-ask-question/handlers/handle-conversation-graph.js

@@ -30,13 +30,20 @@ A conversation graph is a flexible structure for managing complex interactions.
 - **Flow Control**: Edges determine how the conversation can progress
 - **Flexibility**: Support for various conversation patterns and flows
 - **Context Awareness**: Each node operates with awareness of the conversation state
+- **User Interaction**: User can reject or accept some of the actions, so the graph should account for that
 
 ## Implementation Notes
 
 - Nodes should be self-contained and focused
 - Edges should have clear, evaluatable conditions
 - Any node can connect to any other node if logically appropriate
-- Nodes and edges must formulate a direct acyclic graph (DAG)
+- Nodes and edges must formulate a graph structure, allowing for complex interactions
+
+## Graph Structure requirements and constraints
+
+- The graph may contain cycles, but should be designed to avoid infinite loops
+- Each node should be reachable from the entry node
+- The entry node should be clearly defined and serve as the starting point for the conversation
 
 ## Technical Details
 
@@ -61,215 +68,436 @@ export const getEdgeEvaluationPrompt = (currentNode, outgoingEdges) => {
     return `We are evaluating the outgoing edges from the current node(${currentNode.id}):
 
 ${outgoingEdges.map((edge) => `- ${edge.targetNode}: ${edge.instruction}`).join('\n')}
-  
-Select the correct edge, or terminate if the conversation should stop.`;
+
+Select the correct edge, or terminate if the conversation should stop. Use the 'evaluateEdge' function.`;
 };
+export const GRAPH_ANALYSIS_PROMPT_TEXT = `Please analyze the conversation graph provided by the assistant in the preceding message. Simulate diverse conversation paths mentally and identify any structural or logical problems, dead ends, unreachable nodes, missing transitions, or potential infinite loops. Explain the problems you find in detail. If no significant problems are found, state that clearly.`;
+export const GRAPH_REVISION_PROMPT_TEXT = `Based on the analysis provided in the preceding message, generate a new, improved conversation graph using the 'conversationGraph' function. Ensure the new graph addresses the identified problems and better facilitates the original conversation goal.`;
 registerActionHandler('conversationGraph', handleConversationGraph);
 /**
- * Handles the conversationGraph action by:
- * 1. Generating a conversationGraph function call
- * 2. Extracting nodes and edges from the response
- * 3. Traversing the graph and executing actions
- * 4. Returning appropriate ActionResult
+ * Main handler for the conversationGraph action.
+ * Orchestrates confirmation, generation, analysis/revision, and traversal.
  */
-export async function handleConversationGraph({ askQuestionCall, prompt, options, generateContentFn, generateImageFn, waitIfPaused, }) {
+export async function handleConversationGraph(props) {
+    const state = {
+        prompt: [...props.prompt], // Work on a copy
+        currentGraphState: null,
+        conversationGraphCall: null,
+    };
     try {
-        const userConfirmation = await askUserForConfirmationWithAnswer('The assistant wants to perform a conversation graph. Do you want to proceed?', 'Run conversation graph', 'Decline', true, options);
-        if (userConfirmation.answer) {
-            putUserMessage(userConfirmation.answer);
-        }
+        // 1. Confirm Execution
+        const userConfirmation = await _confirmGraphExecution(props.askQuestionCall, state, props.options);
         if (!userConfirmation.confirmed) {
-            putSystemMessage('Conversation graph declined.');
-            prompt.push({
-                type: 'assistant',
-                text: askQuestionCall.args?.message ?? '',
-            }, {
-                type: 'user',
-                text: 'Declined conversation graph. ' + (userConfirmation.answer ? `\n\n${userConfirmation.answer}` : ''),
-            });
-            return {
-                breakLoop: false,
-                items: [],
-            };
+            props.prompt.push(...state.prompt.slice(props.prompt.length)); // Update original prompt if declined
+            return { breakLoop: false, items: [] };
         }
-        putSystemMessage('Generating conversation graph...');
-        // Generate the conversationGraph function call
-        const [conversationGraphCall] = (await generateContentFn([
-            ...prompt,
-            {
-                type: 'assistant',
-                text: askQuestionCall.args?.message ?? '',
-            },
+        // 2. Generate Initial Graph
+        const initialGraphCall = await _generateInitialGraph(props.askQuestionCall, state, props.generateContentFn, props.options);
+        if (!initialGraphCall) {
+            props.prompt.push(...state.prompt.slice(props.prompt.length)); // Update original prompt on failure
+            return { breakLoop: false, items: [] };
+        }
+        // 3. Analyze and Revise Graph
+        const finalGraphCall = await _analyzeAndReviseGraph(state, props.generateContentFn, props.options);
+        if (!finalGraphCall) {
+            // This case implies the initial generation failed, handled in _generateInitialGraph
+            // If analysis/revision failed, we still proceed with the initial graph (returned by _analyzeAndReviseGraph)
+            // So, if finalGraphCall is null here, something went very wrong earlier.
+            throw new Error('Unexpected state: finalGraphCall is null after analysis/revision.');
+        }
+        state.conversationGraphCall = finalGraphCall; // Ensure state uses the final graph
+        // 4. Traverse Graph
+        const traversalResult = await _traverseGraph(state, props, userConfirmation);
+        // Update the original prompt with the full history from the graph execution
+        props.prompt.splice(0, props.prompt.length, ...state.prompt);
+        return traversalResult;
+    }
+    catch (error) {
+        // Ensure final state is marked inactive on error
+        if (state.currentGraphState) {
+            state.currentGraphState = { ...state.currentGraphState, isActive: false };
+        }
+        putSystemMessage('Error during conversation graph execution', {
+            error,
+            conversationGraphState: state.currentGraphState,
+        });
+        // Add error context to the prompt
+        state.prompt.push({
+            type: 'assistant',
+            text: 'An error occurred during conversation graph execution.',
+        }, {
+            type: 'user',
+            text: 'Lets continue the conversation.',
+        });
+        // Update the original prompt with the history including the error
+        props.prompt.splice(0, props.prompt.length, ...state.prompt);
+        return { breakLoop: false, items: [] };
+    }
+}
+// Helper: Confirm Graph Execution with User
+async function _confirmGraphExecution(askQuestionCall, state, options) {
+    const userConfirmation = await askUserForConfirmationWithAnswer('The assistant wants to perform a conversation graph. Do you want to proceed?', 'Run conversation graph', 'Decline', true, options);
+    if (userConfirmation.answer) {
+        putUserMessage(userConfirmation.answer);
+    }
+    if (!userConfirmation.confirmed) {
+        putSystemMessage('Conversation graph declined.');
+        state.prompt.push({
+            type: 'assistant',
+            text: askQuestionCall.args?.message ?? '',
+        }, {
+            type: 'user',
+            text: 'Declined conversation graph. ' + (userConfirmation.answer ? `\n\n${userConfirmation.answer}` : ''),
+        });
+    }
+    return userConfirmation;
+}
+// Helper: Generate Initial Conversation Graph
+async function _generateInitialGraph(askQuestionCall, state, generateContentFn, options) {
+    putSystemMessage('Generating conversation graph...');
+    const initialGraphResponse = await generateContentFn([
+        ...state.prompt,
+        {
+            type: 'assistant',
+            text: askQuestionCall.args?.message ?? '',
+        },
+        {
+            type: 'user',
+            text: CONVERSATION_GRAPH_PROMPT,
+        },
+    ], {
+        functionDefs: getFunctionDefs(),
+        requiredFunctionName: 'conversationGraph',
+        temperature: 0.7,
+        modelType: ModelType.DEFAULT,
+        expectedResponseType: {
+            text: false,
+            functionCall: true,
+            media: false,
+        },
+    }, options);
+    const conversationGraphCall = initialGraphResponse
+        .filter((item) => item.type === 'functionCall')
+        .map((item) => item.functionCall)[0];
+    if (!conversationGraphCall || !conversationGraphCall.args) {
+        putSystemMessage('Failed to generate initial conversation graph.');
+        state.prompt.push({
+            type: 'assistant',
+            text: 'I encountered an issue generating the conversation plan.',
+        }, {
+            type: 'user',
+            text: 'Okay, unable to generate graph.',
+        });
+        return null;
+    }
+    state.prompt.push({
+        type: 'assistant',
+        text: askQuestionCall.args?.message ?? '',
+        functionCalls: [conversationGraphCall],
+    });
+    state.conversationGraphCall = conversationGraphCall;
+    state.currentGraphState = {
+        nodes: conversationGraphCall.args.nodes,
+        edges: conversationGraphCall.args.edges,
+        currentNodeId: null,
+        isActive: false,
+    };
+    return conversationGraphCall;
+}
+// Helper: Analyze and Revise Graph
+async function _analyzeAndReviseGraph(state, generateContentFn, options) {
+    if (!state.conversationGraphCall || !state.currentGraphState) {
+        return null; // Should not happen if called correctly
+    }
+    const initialGraphCall = state.conversationGraphCall;
+    putSystemMessage('Starting automatic graph analysis...', {
+        conversationGraphState: state.currentGraphState,
+        ...initialGraphCall.args,
+    });
+    const analysisPrompt = [
+        {
+            type: 'assistant',
+            text: CONVERSATION_GRAPH_PROMPT,
+        },
+        {
+            type: 'assistant',
+            text: 'I have prepared a conversation graph for you.',
+            functionCalls: [initialGraphCall],
+        },
+        {
+            type: 'user',
+            text: GRAPH_ANALYSIS_PROMPT_TEXT,
+            functionResponses: [
+                {
+                    name: 'conversationGraph',
+                    call_id: initialGraphCall.id,
+                    content: '',
+                },
+            ],
+        },
+    ];
+    const analysisResult = await generateContentFn(analysisPrompt, {
+        modelType: ModelType.CHEAP,
+        temperature: 0.5,
+        expectedResponseType: { text: true, functionCall: false, media: false },
+    }, options);
+    const analysisText = analysisResult.find((part) => part.type === 'text')?.text;
+    if (analysisText) {
+        analysisPrompt.push({ type: 'assistant', text: analysisText });
+        putSystemMessage('Attempting to fix graph based on analysis...', {
+            conversationGraphState: state.currentGraphState,
+            analysisText,
+        });
+        const revisionPrompt = [
+            ...analysisPrompt,
             {
                 type: 'user',
-                text: CONVERSATION_GRAPH_PROMPT + (userConfirmation.answer ? `\n\n${userConfirmation.answer}` : ''),
+                text: GRAPH_REVISION_PROMPT_TEXT,
             },
-        ], {
+        ];
+        const revisionResult = await generateContentFn(revisionPrompt, {
+            modelType: ModelType.DEFAULT,
+            temperature: 0.7,
             functionDefs: getFunctionDefs(),
             requiredFunctionName: 'conversationGraph',
-            temperature: 0.7,
-            modelType: ModelType.DEFAULT,
             expectedResponseType: {
                 text: false,
                 functionCall: true,
                 media: false,
             },
-        }, options))
+        }, options);
+        const revisedGraphCall = revisionResult
             .filter((item) => item.type === 'functionCall')
-            .map((item) => item.functionCall);
-        prompt.push({
-            type: 'assistant',
-            text: askQuestionCall.args?.message ?? '',
-            functionCalls: [conversationGraphCall],
-        }, {
+            .map((item) => item.functionCall)[0];
+        if (revisedGraphCall?.args?.nodes?.length) {
+            state.conversationGraphCall = {
+                ...initialGraphCall,
+                args: { ...initialGraphCall.args, ...revisedGraphCall.args },
+            };
+            state.currentGraphState = {
+                ...state.currentGraphState,
+                nodes: state.conversationGraphCall.args.nodes,
+                edges: state.conversationGraphCall.args.edges,
+            };
+            putSystemMessage('Graph revised successfully.', {
+                conversationGraphState: state.currentGraphState,
+                ...state.conversationGraphCall.args,
+            });
+            return state.conversationGraphCall;
+        }
+        else {
+            putSystemMessage('Failed to generate revised conversation graph, keeping original.', {
+                conversationGraphState: state.currentGraphState,
+            });
+        }
+    }
+    else {
+        putSystemMessage('LLM failed to provide analysis text. Proceeding with original graph.', {
+            conversationGraphState: state.currentGraphState,
+        });
+    }
+    return initialGraphCall; // Return original if revision failed or wasn't needed
+}
+// Helper: Execute Node Action
+async function _executeNodeAction(currentNode, state, props) {
+    const nodeAskQuestionCall = {
+        name: 'askQuestion',
+        args: {
+            message: currentNode.instruction, // Use node instruction as message hint
+            actionType: currentNode.actionType,
+        },
+    };
+    putSystemMessage(`Executing node ${currentNode.id} (Action: ${currentNode.actionType})`, {
+        conversationGraphState: state.currentGraphState,
+        nodeDetails: currentNode,
+    });
+    // Generate a message for the assistant to say before executing the action
+    const [sendMessage] = (await props.generateContentFn(state.prompt, {
+        functionDefs: getFunctionDefs(),
+        requiredFunctionName: 'sendMessage',
+        temperature: 0.7,
+        modelType: ModelType.CHEAP,
+        expectedResponseType: {
+            text: false,
+            functionCall: true,
+            media: false,
+        },
+    }, props.options))
+        .filter((item) => item.type === 'functionCall')
+        .map((item) => item.functionCall);
+    if (sendMessage?.args?.message) {
+        putAssistantMessage(sendMessage.args.message, sendMessage.args);
+        nodeAskQuestionCall.args.message = sendMessage.args.message;
+    }
+    const currentNodeHandler = getActionHandler(currentNode.actionType);
+    const nodeResult = await currentNodeHandler({
+        ...props,
+        askQuestionCall: nodeAskQuestionCall,
+        prompt: state.prompt, // Pass the current prompt state
+    });
+    // Add results from the node handler to history
+    if (nodeResult.items && nodeResult.items.length > 0) {
+        for (const item of nodeResult.items) {
+            if (item?.assistant) {
+                state.prompt.push(item.assistant);
+            }
+            if (item?.user) {
+                putUserMessage(item.user.text ?? '', item.user.data, undefined, item.user.images, item.user);
+                state.prompt.push(item.user);
+            }
+        }
+    }
+    return nodeResult;
+}
+// Helper: Evaluate Next Step (Edges)
+async function _evaluateNextStep(currentNode, state, generateContentFn, options) {
+    const outgoingEdges = state.currentGraphState.edges.filter((edge) => edge.sourceNode === currentNode.id);
+    if (outgoingEdges.length === 0) {
+        putSystemMessage(`No outgoing edges found from node ${currentNode.id}. Ending execution.`, {
+            conversationGraphState: { ...state.currentGraphState, isActive: false },
+        });
+        return { nextNode: null, terminate: true };
+    }
+    const edgeEvaluationResult = await generateContentFn([
+        ...state.prompt,
+        {
             type: 'user',
+            text: getEdgeEvaluationPrompt(currentNode, outgoingEdges),
+        },
+    ], {
+        functionDefs: getFunctionDefs(),
+        requiredFunctionName: 'evaluateEdge',
+        temperature: 0.2,
+        modelType: ModelType.CHEAP,
+        expectedResponseType: {
+            text: false,
+            functionCall: true,
+            media: false,
+        },
+    }, options);
+    const evaluateEdge = edgeEvaluationResult
+        .filter((item) => item.type === 'functionCall')
+        .map((item) => item.functionCall)[0];
+    if (!evaluateEdge?.args) {
+        putSystemMessage(`Failed to evaluate edges from node ${currentNode.id}. Ending execution.`, {
+            conversationGraphState: { ...state.currentGraphState, isActive: false },
+        });
+        return { nextNode: null, terminate: true };
+    }
+    state.prompt.push({ type: 'assistant', functionCalls: [evaluateEdge] });
+    state.prompt.push({
+        type: 'user',
+        functionResponses: [
+            {
+                name: 'evaluateEdge',
+                call_id: evaluateEdge.id,
+                content: JSON.stringify(evaluateEdge.args),
+            },
+        ],
+        text: `Edge evaluated: ${evaluateEdge.args.shouldTerminate ? 'Terminate' : (evaluateEdge.args.selectedEdge?.targetNode ?? 'Error')}`,
+    });
+    if (evaluateEdge.args.shouldTerminate || !evaluateEdge.args.selectedEdge) {
+        putSystemMessage('Conversation graph traversal terminated by edge evaluation.', {
+            conversationGraphState: { ...state.currentGraphState, isActive: false },
+        });
+        return { nextNode: null, terminate: true };
+    }
+    const nextNodeId = evaluateEdge.args.selectedEdge.targetNode;
+    const nextNode = state.currentGraphState.nodes.find((node) => node.id === nextNodeId);
+    if (!nextNode) {
+        putSystemMessage(`Target node ${nextNodeId} not found. Ending execution.`, {
+            conversationGraphState: { ...state.currentGraphState, isActive: false, currentNodeId: null },
+        });
+        return { nextNode: null, terminate: true };
+    }
+    return { nextNode, terminate: false };
+}
+// Helper: Traverse the Graph
+async function _traverseGraph(state, props, userConfirmation) {
+    if (!state.conversationGraphCall?.args || !state.currentGraphState) {
+        throw new Error('Cannot traverse graph without a valid graph definition.');
+    }
+    const { entryNode, nodes } = state.conversationGraphCall.args;
+    let currentNode = nodes.find((node) => node.id === entryNode);
+    if (!currentNode) {
+        state.currentGraphState = { ...state.currentGraphState, isActive: false, currentNodeId: null };
+        putSystemMessage('Error occurred during conversation graph execution (entry node not found).', {
+            conversationGraphState: state.currentGraphState,
+        });
+        state.prompt.push({
+            type: 'user',
+            text: 'Okay, unable to start graph execution (entry node not found).',
             functionResponses: [
                 {
                     name: 'conversationGraph',
-                    call_id: conversationGraphCall.id,
+                    call_id: state.conversationGraphCall.id,
                     content: '',
                 },
             ],
         });
-        const { entryNode, nodes, edges } = conversationGraphCall.args;
-        putSystemMessage('Starting conversation graph traversal.', {
-            entryNode,
-            nodes,
-            edges,
-        });
-        // Start with the first node
-        let currentNode = nodes.find((node) => node.id === entryNode);
-        if (!currentNode) {
-            putSystemMessage('Error occurred during conversation graph execution.');
-            prompt.push({
-                type: 'assistant',
-                text: askQuestionCall.args?.message ?? '',
-            }, {
-                type: 'user',
-                text: 'Error occurred during conversation graph execution.',
+        return { breakLoop: false, items: [] };
+    }
+    state.currentGraphState = { ...state.currentGraphState, currentNodeId: currentNode.id, isActive: true };
+    putSystemMessage('Starting conversation graph traversal.', {
+        conversationGraphState: state.currentGraphState,
+        entryNode,
+        nodes,
+        edges: state.currentGraphState.edges,
+    });
+    // Add prompt to history about user accepting the graph
+    state.prompt.push({
+        type: 'user',
+        text: 'I accept the conversation graph and will proceed with it.' +
+            (userConfirmation.answer ? `\n\n${userConfirmation.answer}` : ''), // Assuming confirmation happened before
+        functionResponses: [
+            {
+                name: 'conversationGraph',
+                call_id: state.conversationGraphCall.id,
+                content: '',
+            },
+        ],
+    });
+    const visitedNodes = new Set();
+    let iteration = 0;
+    const MAX_ITERATIONS = 50;
+    while (currentNode && iteration < MAX_ITERATIONS) {
+        iteration++;
+        visitedNodes.add(currentNode.id);
+        state.currentGraphState = { ...state.currentGraphState, currentNodeId: currentNode.id, isActive: true };
+        const nodeResult = await _executeNodeAction(currentNode, state, props);
+        if (nodeResult.breakLoop) {
+            state.currentGraphState = { ...state.currentGraphState, isActive: false };
+            putSystemMessage(`Node action ${currentNode.actionType} requested to break loop.`, {
+                conversationGraphState: state.currentGraphState,
             });
-            return {
-                breakLoop: false,
-                items: [],
-            };
+            return nodeResult; // Propagate breakLoop
         }
-        // Track visited nodes to prevent cycles
-        const visitedNodes = new Set();
-        let iteration = 0;
-        const MAX_ITERATIONS = 50; // Safeguard against infinite loops
-        while (currentNode && iteration < MAX_ITERATIONS) {
-            iteration++;
-            visitedNodes.add(currentNode.id);
-            // Execute the current node
-            putSystemMessage(`Executing node ${currentNode.id}`, currentNode);
-            const [sendMessage] = (await generateContentFn(prompt, {
-                functionDefs: getFunctionDefs(),
-                requiredFunctionName: 'sendMessage',
-                temperature: 0.7,
-                modelType: ModelType.CHEAP,
-                expectedResponseType: {
-                    text: false,
-                    functionCall: true,
-                    media: false,
-                },
-            }, options))
-                .filter((item) => item.type === 'functionCall')
-                .map((item) => item.functionCall);
-            if (sendMessage.args?.message) {
-                putAssistantMessage(sendMessage.args.message, sendMessage.args);
-            }
-            const currentNodeHandler = getActionHandler(currentNode.actionType);
-            const nodeResult = await currentNodeHandler({
-                askQuestionCall: {
-                    name: 'askQuestion',
-                    args: {
-                        message: sendMessage.args?.message ?? '',
-                        actionType: currentNode.actionType,
-                    },
-                },
-                prompt,
-                options,
-                generateContentFn,
-                generateImageFn,
-                waitIfPaused,
-            });
-            const lastItem = nodeResult.items.slice(-1)[0];
-            if (lastItem?.user?.text) {
-                putUserMessage(lastItem.user.text, undefined, undefined, undefined, lastItem.user);
-            }
-            prompt.push(...nodeResult.items.map(({ assistant, user }) => [assistant, user]).flat());
-            // Move to the next node
-            const outgoingEdges = edges.filter((edge) => edge.sourceNode === currentNode.id);
-            const [evaluateEdge] = (await generateContentFn([
-                ...prompt,
-                {
-                    type: 'user',
-                    text: getEdgeEvaluationPrompt(currentNode, outgoingEdges),
-                },
-            ], {
-                functionDefs: getFunctionDefs(),
-                requiredFunctionName: 'evaluateEdge',
-                temperature: 0.7,
-                modelType: ModelType.CHEAP,
-                expectedResponseType: {
-                    text: false,
-                    functionCall: true,
-                    media: false,
-                },
-            }, options))
-                .filter((item) => item.type === 'functionCall')
-                .map((item) => item.functionCall);
-            if (!evaluateEdge.args?.shouldTerminate) {
-                putSystemMessage('Conversation graph traversal terminated.');
-                break;
-            }
-            const outgoingEdge = outgoingEdges.find((edge) => edge.targetNode === evaluateEdge.args?.selectedEdge?.targetNode);
-            if (!outgoingEdge) {
-                putSystemMessage(`No valid outgoing edge found from node ${currentNode.id}.`);
-                break;
-            }
-            // Find next node
-            const nextNode = nodes.find((node) => node.id === outgoingEdge.targetNode);
-            if (!nextNode) {
-                putSystemMessage(`Target node ${outgoingEdge.targetNode} not found.`);
-                break;
-            }
-            // Check for cycles
-            if (visitedNodes.has(nextNode.id)) {
-                putSystemMessage(`Cycle detected at node ${nextNode.id}. Stopping traversal.`);
-                break;
-            }
-            currentNode = nextNode;
+        const { nextNode, terminate } = await _evaluateNextStep(currentNode, state, props.generateContentFn, props.options);
+        if (terminate) {
+            break;
         }
-        if (iteration >= MAX_ITERATIONS) {
-            putSystemMessage('Maximum iterations reached. Stopping traversal.');
+        currentNode = nextNode;
+        // Update state for the next iteration (will be sent at the start of the next loop)
+        if (currentNode) {
+            state.currentGraphState = { ...state.currentGraphState, currentNodeId: currentNode.id };
         }
-        putSystemMessage('Conversation graph traversal completed.');
-        prompt.push({
-            type: 'assistant',
-            text: 'Conversation graph traversal completed.',
-        }, {
-            type: 'user',
-            text: 'Lets continue the conversation.',
-        });
-        return {
-            breakLoop: false,
-            items: [],
-        };
     }
-    catch (error) {
-        putSystemMessage('Error during conversation graph execution', { error });
-        prompt.push({
-            type: 'assistant',
-            text: 'An error occurred during conversation graph execution.', // TODO: Prompt user for message
-        }, {
-            type: 'user',
-            text: 'Lets continue the conversation.', // TODO: Prompt user for message
+    if (iteration >= MAX_ITERATIONS) {
+        putSystemMessage('Maximum iterations reached. Stopping traversal.', {
+            conversationGraphState: { ...state.currentGraphState, isActive: false },
         });
-        return {
-            breakLoop: false,
-            items: [],
-        };
     }
+    state.currentGraphState = { ...state.currentGraphState, isActive: false };
+    putSystemMessage('Conversation graph traversal completed.', {
+        conversationGraphState: state.currentGraphState,
+    });
+    state.prompt.push({
+        type: 'assistant',
+        text: 'Conversation graph traversal completed.',
+    }, {
+        type: 'user',
+        text: 'Lets continue the conversation.',
+    });
+    return { breakLoop: false, items: [] };
 }
 //# sourceMappingURL=handle-conversation-graph.js.map