@minded-ai/mindedjs 2.0.0 → 2.0.1-beta-1

package/src/nodes/addPromptNode.ts

@@ -58,134 +58,323 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
       state.messages.unshift(systemMessage);
     }
 
-    const startTime = Date.now();
-    const result: AIMessage = await llmToUse.bindTools(scopedTools).invoke(state.messages);
-    const endTime = Date.now();
-    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
-    logger.debug({
-      msg: '[Model] Model execution time',
-      executionTimeMs: endTime - startTime,
-      sessionId: state.sessionId,
-      node: node.displayName,
-    });
-    // Check if the result contains tool calls
-    if (result.tool_calls && result.tool_calls.length > 0) {
-      // Execute the tools
-      const toolResults = [];
-
-      for (const toolCall of result.tool_calls) {
-        const matchedTool = scopedTools.find((t) => t.name === toolCall.name);
-        logger.info({
-          msg: `[Model] Calling tool inside prompt node`,
-          tool: matchedTool?.name,
+    // Check if we should use the agentic loop (only when humanInTheLoop is true)
+    const useAgenticLoop = node.humanInTheLoop === true;
+
+    /**
+     * When humanInTheLoop is true: Run an agentic loop that continues invoking the LLM
+     * after tool calls until we get a final AI message without tool calls.
+     *
+     * When humanInTheLoop is false: Return immediately after tool execution without
+     * additional LLM invocations.
+     */
+    const newMessages: any[] = [];
+    const newHistory: any[] = [];
+    let currentMessages = [...state.messages];
+    let finalAIMessage: AIMessage | null = null;
+    let loopCount = 0;
+    const MAX_LOOP_ITERATIONS = 10;
+
+    while (true) {
+      loopCount++;
+
+      // Break if we've reached the maximum number of iterations
+      if (loopCount > MAX_LOOP_ITERATIONS) {
+        logger.warn({
+          msg: '[Model] Reached maximum loop iterations, breaking agentic loop',
+          loopCount,
           sessionId: state.sessionId,
           node: node.displayName,
         });
-        if (matchedTool) {
-          try {
-            // Invoke the LangChain tool directly
-            const startTime = Date.now();
-            const toolResult = await matchedTool.invoke(toolCall);
-            const endTime = Date.now();
-            logger.debug({
-              msg: `[Tool] Tool result inside prompt node`,
-              tool: matchedTool?.name,
-              result: toolResult,
-              executionTimeMs: endTime - startTime,
-              sessionId: state.sessionId,
-              node: node.displayName,
-            });
-            //check for queue after tool call
-            const systemMessageId = uuidv4();
-
-            await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
-              messages: [
-                result,
-                toolResult,
-                new SystemMessage({
-                  id: systemMessageId,
-                  content:
-                    'you called tool when the user send a new message, Consider calling the function again after user message is processed',
-                }),
-              ],
-              history: [
+        break;
+      }
+      const startTime = Date.now();
+
+      const result: AIMessage = await llmToUse.bindTools(scopedTools).invoke([new SystemMessage(compiledPrompt), ...currentMessages]);
+
+      // Always pass accumulated state to interrupt manager
+      // Pass the accumulated messages from this prompt node execution
+      // If empty, pass undefined to avoid empty state updates
+      const interruptState =
+        newMessages.length > 0 || newHistory.length > 0
+          ? {
+              ...state,
+              messages: [...state.messages, ...newMessages],
+              history: [...state.history, ...newHistory],
+            }
+          : undefined;
+      await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, interruptState);
+
+      const endTime = Date.now();
+
+      logger.debug({
+        msg: '[Model] Model execution time',
+        executionTimeMs: endTime - startTime,
+        sessionId: state.sessionId,
+        node: node.displayName,
+      });
+
+      // Check if the result contains tool calls
+      if (result.tool_calls && result.tool_calls.length > 0) {
+        // Add the tool call message
+        newMessages.push(result);
+        newHistory.push(
+          createHistoryStep<HistoryStep>(state.history, {
+            type: NodeType.TOOL,
+            nodeId: node.name,
+            nodeDisplayName: node.displayName,
+            raw: result,
+            messageIds: [result.id!],
+          }),
+        );
+
+        // Execute the tools
+        // Track how many tool responses we've added for validation
+        const toolResponseStartIndex = newMessages.length;
+
+        // Ensure we process ALL tool calls, even if some fail
+        for (const toolCall of result.tool_calls) {
+          const matchedTool = scopedTools.find((t) => t.name === toolCall.name);
+          logger.info({
+            msg: `[Model] Calling tool inside prompt node`,
+            tool: matchedTool?.name || toolCall.name,
+            toolCallId: toolCall.id,
+            sessionId: state.sessionId,
+            node: node.displayName,
+          });
+
+          if (matchedTool) {
+            try {
+              // Invoke the LangChain tool directly
+              const toolStartTime = Date.now();
+              const toolResult = await matchedTool.invoke(toolCall);
+              const toolEndTime = Date.now();
+
+              logger.debug({
+                msg: `[Tool] Tool result inside prompt node`,
+                tool: matchedTool?.name,
+                result: toolResult,
+                executionTimeMs: toolEndTime - toolStartTime,
+                sessionId: state.sessionId,
+                node: node.displayName,
+              });
+
+              // Add the tool result directly to allMessages
+              newMessages.push(toolResult);
+
+              // Check for queue after tool call
+              const systemMessageId = uuidv4();
+              await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
+                ...state,
+                messages: [
+                  ...state.messages,
+                  ...newMessages,
+                  new SystemMessage({
+                    id: systemMessageId,
+                    content:
+                      'you called tool when the user send a new message, Consider calling the function again after user message is processed',
+                  }),
+                ],
+                history: [
+                  ...state.history,
+                  ...newHistory,
+                  createHistoryStep<HistoryStep>(state.history, {
+                    type: NodeType.TOOL,
+                    nodeId: node.name,
+                    nodeDisplayName: node.displayName,
+                    raw: toolResult,
+                    messageIds: [toolResult.id!, systemMessageId],
+                  }),
+                ],
+              });
+
+              // In v2.0, tools update state by reference, no need to extract state updates
+
+              newHistory.push(
                 createHistoryStep<HistoryStep>(state.history, {
                   type: NodeType.TOOL,
                   nodeId: node.name,
                   nodeDisplayName: node.displayName,
                   raw: toolResult,
-                  messageIds: [toolResult.id!, systemMessageId],
+                  messageIds: [toolResult.id!],
                 }),
-              ],
-            });
-            toolResults.push(toolResult);
-          } catch (err: any) {
-            if (err?.name === 'GraphInterrupt') throw err;
+              );
+            } catch (err: any) {
+              if (err?.name === 'GraphInterrupt') throw err;
+              logger.error({
+                msg: `[Tool] Error executing tool inside prompt node`,
+                tool: toolCall.name,
+                err,
+                sessionId: state.sessionId,
+                node: node.displayName,
+              });
+              const errorMessage = new ToolMessage({
+                content: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }),
+                tool_call_id: toolCall.id!,
+              });
+
+              // Add the error message directly to allMessages
+              newMessages.push(errorMessage);
+
+              // Check for queue after tool error
+              const errorSystemMessageId = uuidv4();
+              await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
+                ...state,
+                messages: [
+                  ...state.messages,
+                  ...newMessages,
+                  new SystemMessage({
+                    id: errorSystemMessageId,
+                    content: 'Tool execution failed. Consider handling the error or calling another function if needed.',
+                  }),
+                ],
+                history: [
+                  ...state.history,
+                  ...newHistory,
+                  createHistoryStep<HistoryStep>(state.history, {
+                    type: NodeType.TOOL,
+                    nodeId: node.name,
+                    nodeDisplayName: node.displayName,
+                    raw: errorMessage,
+                    messageIds: [errorMessage.id!, errorSystemMessageId],
+                  }),
+                ],
+              });
+              newHistory.push(
+                createHistoryStep<HistoryStep>(state.history, {
+                  type: NodeType.TOOL,
+                  nodeId: node.name,
+                  nodeDisplayName: node.displayName,
+                  raw: errorMessage,
+                  messageIds: [errorMessage.id!],
+                }),
+              );
+            }
+          } else {
             logger.error({
-              msg: `[Tool] Error executing tool inside prompt node`,
+              msg: `[Tool] Model called tool but it was not found inside prompt node`,
               tool: toolCall.name,
-              err,
+              toolCallId: toolCall.id,
               sessionId: state.sessionId,
               node: node.displayName,
             });
-            const errorMessage = new ToolMessage({
-              content: JSON.stringify({ error: err instanceof Error ? err.message : String(err) }),
-              tool_call_id: toolCall.id!,
+
+            // IMPORTANT: Create an error message for the missing tool with the correct tool_call_id
+            const missingToolMessage = new ToolMessage({
+              content: JSON.stringify({ error: `Tool '${toolCall.name}' not found` }),
+              tool_call_id: toolCall.id!, // This MUST match the tool_call_id from the AI message
+              name: toolCall.name,
             });
-            toolResults.push(errorMessage);
+
+            newMessages.push(missingToolMessage);
+            newHistory.push(
+              createHistoryStep<HistoryStep>(state.history, {
+                type: NodeType.TOOL,
+                nodeId: node.name,
+                nodeDisplayName: node.displayName,
+                raw: missingToolMessage,
+                messageIds: [missingToolMessage.id!],
+              }),
+            );
           }
-        } else {
+        }
+
+        // Validate that we have responses for ALL tool calls
+        const toolResponseCount = newMessages.length - toolResponseStartIndex;
+        if (toolResponseCount !== result.tool_calls.length) {
           logger.error({
-            msg: `[Tool] Model called tool but it was not found inside prompt node`,
-            tool: toolCall.name,
+            msg: '[Model] Tool response count mismatch',
+            expectedCount: result.tool_calls.length,
+            actualCount: toolResponseCount,
+            toolCallIds: result.tool_calls.map((tc) => tc.id),
             sessionId: state.sessionId,
             node: node.displayName,
           });
         }
+
+        // If humanInTheLoop is false, return immediately after tool execution
+        if (!useAgenticLoop) {
+          // In v2.0, modify state directly
+          state.messages.push(...newMessages);
+          state.history.push(...newHistory);
+          return state;
+        }
+
+        // Otherwise, prepare for next iteration
+        // allMessages now contains all the new messages from this iteration
+        currentMessages = [...state.messages, ...newMessages];
+
+        // Continue the loop to see what the model wants to do next
+        continue;
+      } else {
+        // We got an AI message without tool calls - this is our final response
+        finalAIMessage = result;
+        break;
+      }
+    }
+
+    // Process the final AI message if we have one
+    if (finalAIMessage) {
+      // Add the final AI message to our messages first
+      newMessages.push(finalAIMessage);
+
+      if (finalAIMessage.getType() === 'ai') {
+        logger.info({
+          msg: `[Model] Response`,
+          content: finalAIMessage.content,
+          sessionId: state.sessionId,
+          node: node.displayName,
+        });
+
+        // First add all messages to state
+        state.messages.push(...newMessages);
+
+        // In v2.0, emit AI_MESSAGE for handlers to process
+        // Handlers will modify state directly by reference
+        await emit(AgentEvents.AI_MESSAGE, {
+          message: finalAIMessage.content as string,
+          state: state,
+        });
       }
 
-      state.messages.push(result, ...toolResults);
-      state.history.push(
+      // Set goto to null
+      state.goto = null;
+
+      newHistory.push(
         createHistoryStep<HistoryStep>(state.history, {
-          type: NodeType.TOOL,
+          type: NodeType.PROMPT_NODE,
           nodeId: node.name,
           nodeDisplayName: node.displayName,
-          raw: result,
-          messageIds: [result.id!],
+          raw: finalAIMessage.content,
+          messageIds: [finalAIMessage.id!],
         }),
-        ...toolResults.map((toolResult) =>
-          createHistoryStep<HistoryStep>(state.history, {
-            type: NodeType.TOOL,
-            nodeId: node.name,
-            nodeDisplayName: node.displayName,
-            raw: toolResult,
-            messageIds: [toolResult.id!],
-          }),
-        ),
       );
+
+      // History is added to state
+      state.history.push(...newHistory);
+
       return state;
     }
 
-    // Model text response
-    state.goto = null;
-    state.messages.push(result);
+    // If we hit the loop limit without a final AI message, return what we have
+    if (loopCount > MAX_LOOP_ITERATIONS && newMessages.length > 0) {
+      logger.warn({
+        msg: '[Model] Returning accumulated messages after hitting loop limit',
+        messageCount: newMessages.length,
+        sessionId: state.sessionId,
+        node: node.displayName,
+      });
 
-    if (result.getType() === 'ai') {
-      logger.info({ msg: `[Model] Response`, content: result.content, sessionId: state.sessionId, node: node.displayName });
-      await emit(AgentEvents.AI_MESSAGE, { message: result.content as string, state });
+      state.goto = null;
+      // In v2.0, modify state directly
+      state.messages.push(...newMessages);
+      state.history.push(...newHistory);
+
+      return state;
     }
 
-    state.history.push(
-      createHistoryStep<HistoryStep>(state.history, {
-        type: NodeType.PROMPT_NODE,
-        nodeId: node.name,
-        nodeDisplayName: node.displayName,
-        raw: result.content,
-        messageIds: [result.id!],
-      }),
-    );
-
-    return state;
+    // This should only be reached in unexpected cases
+    throw new Error('Unexpected state: no messages generated in prompt node');
   };
   graph.addNode(node.name, callback);
 };