@minded-ai/mindedjs 1.0.150 → 1.0.151-beta-1

package/src/nodes/addPromptNode.ts

@@ -50,150 +50,334 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
     const systemMessage = combinedPlaybooks + '\n\n' + currentPromptNode;
     const compiledPrompt = compilePrompt(systemMessage, { memory: state.memory, system: { currentTime: new Date().toISOString() } });
 
-    const startTime = Date.now();
-    const result: AIMessage = await llmToUse.bindTools(scopedTools).invoke([new SystemMessage(compiledPrompt), ...state.messages]);
-    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
-    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) {
-      // Execute the tools
-      const toolResults = [];
-      let stateUpdates = {};
-
-      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.
+     */
+    let allMessages: any[] = [];
+    let allHistory: any[] = [];
+    let accumulatedStateUpdates = {};
+    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 =
+        allMessages.length > 0 || allHistory.length > 0
+          ? {
+              messages: allMessages,
+              history: allHistory,
+            }
+          : 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
+        allMessages.push(result);
+        allHistory.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 = allMessages.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
+              allMessages.push(toolResult);
+
+              // Check for queue after tool call
+              const systemMessageId = uuidv4();
+              await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
+                messages: [
+                  ...allMessages,
+                  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: [
+                  ...allHistory,
+                  createHistoryStep<HistoryStep>(state.history, {
+                    type: NodeType.TOOL,
+                    nodeId: node.name,
+                    nodeDisplayName: node.displayName,
+                    raw: toolResult,
+                    messageIds: [toolResult.id!, systemMessageId],
+                  }),
+                ],
+              });
+
+              const toolStateUpdate = extractToolStateResponse(toolResult);
+              // Properly merge memory and other state updates
+              accumulatedStateUpdates = {
+                ...accumulatedStateUpdates,
+                ...toolStateUpdate,
+                memory: { ...(accumulatedStateUpdates as any).memory, ...(toolStateUpdate as any).memory },
+              };
+
+              allHistory.push(
                 createHistoryStep<HistoryStep>(state.history, {
                   type: NodeType.TOOL,
                   nodeId: node.name,
                   nodeDisplayName: node.displayName,
                   raw: toolResult,
-                  messageIds: [toolResult.id!, systemMessageId],
+                  messageIds: [toolResult.id!],
                 }),
-              ],
-            });
-            const toolStateUpdate = extractToolStateResponse(toolResult);
-            // Properly merge memory and other state updates
-            stateUpdates = {
-              ...stateUpdates,
-              ...toolStateUpdate,
-              memory: { ...(stateUpdates as any).memory, ...(toolStateUpdate as any).memory },
-            };
-            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
+              allMessages.push(errorMessage);
+
+              // Check for queue after tool error
+              const errorSystemMessageId = uuidv4();
+              await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
+                messages: [
+                  ...allMessages,
+                  new SystemMessage({
+                    id: errorSystemMessageId,
+                    content: 'Tool execution failed. Consider handling the error or calling another function if needed.',
+                  }),
+                ],
+                history: [
+                  ...allHistory,
+                  createHistoryStep<HistoryStep>(state.history, {
+                    type: NodeType.TOOL,
+                    nodeId: node.name,
+                    nodeDisplayName: node.displayName,
+                    raw: errorMessage,
+                    messageIds: [errorMessage.id!, errorSystemMessageId],
+                  }),
+                ],
+              });
+              allHistory.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);
+
+            allMessages.push(missingToolMessage);
+            allHistory.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 = allMessages.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) {
+          return {
+            ...accumulatedStateUpdates,
+            messages: allMessages,
+            history: allHistory,
+          };
+        }
+
+        // Otherwise, prepare for next iteration
+        // allMessages now contains all the new messages from this iteration
+        currentMessages = [...state.messages, ...allMessages];
+
+        // 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) {
+      // Update state so AI_MESSAGE will get the latest state
+      const stateForAIMessage = structuredClone(state);
+      stateForAIMessage.goto = null;
+      stateForAIMessage.messages.push(...allMessages, finalAIMessage);
+
+      let aiMessageStateUpdate: any = { goto: null };
+      let messagesToReturn = [...allMessages, finalAIMessage];
+
+      if (finalAIMessage.getType() === 'ai') {
+        logger.info({
+          msg: `[Model] Response`,
+          content: finalAIMessage.content,
+          sessionId: state.sessionId,
+          node: node.displayName,
+        });
+
+        const results = await emit(AgentEvents.AI_MESSAGE, {
+          message: finalAIMessage.content as string,
+          state: stateForAIMessage,
+        });
+
+        const handlerResult = results.find((r) => r !== undefined);
+        if (handlerResult && handlerResult.state) {
+          aiMessageStateUpdate = { ...aiMessageStateUpdate, ...handlerResult.state };
 
-      // Return the tool call message and tool results with state updates spread at top level
+          // If the handler returned modified messages, use those instead
+          if (handlerResult.state.messages) {
+            messagesToReturn = [...allMessages, ...handlerResult.state.messages];
+          }
+        }
+      }
+
+      allHistory.push(
+        createHistoryStep<HistoryStep>(state.history, {
+          type: NodeType.PROMPT_NODE,
+          nodeId: node.name,
+          nodeDisplayName: node.displayName,
+          raw: finalAIMessage.content,
+          messageIds: [finalAIMessage.id!],
+        }),
+      );
+
+      // Return all accumulated state updates and messages
       return {
-        ...stateUpdates,
-        messages: [result, ...toolResults],
-        history: [
-          createHistoryStep<HistoryStep>(state.history, {
-            type: NodeType.TOOL,
-            nodeId: node.name,
-            nodeDisplayName: node.displayName,
-            raw: result,
-            messageIds: [result.id!],
-          }),
-          ...toolResults.map((toolResult) =>
-            createHistoryStep<HistoryStep>(state.history, {
-              type: NodeType.TOOL,
-              nodeId: node.name,
-              nodeDisplayName: node.displayName,
-              raw: toolResult,
-              messageIds: [toolResult.id!],
-            }),
-          ),
-        ],
+        ...accumulatedStateUpdates,
+        ...aiMessageStateUpdate,
+        messages: messagesToReturn,
+        history: allHistory,
       };
     }
 
-    // Model text response
-    state.goto = null;
-    //update state so AI_MESSAGE will get the latest state
-    const stateForAIMessage = structuredClone(state);
-    stateForAIMessage.goto = null;
-    stateForAIMessage.messages.push(result);
-    let stateUpdate: any = { goto: null, messages: [result] };
-    if (result.getType() === 'ai') {
-      logger.info({ msg: `[Model] Response`, content: result.content, sessionId: state.sessionId, node: node.displayName });
-      const results = await emit(AgentEvents.AI_MESSAGE, { message: result.content as string, state: stateForAIMessage });
-      const handlerResult = results.find((r) => r !== undefined);
-      if (handlerResult && handlerResult.state) {
-        stateUpdate = { ...stateUpdate, ...handlerResult.state };
-      }
+    // If we hit the loop limit without a final AI message, return what we have
+    if (loopCount > MAX_LOOP_ITERATIONS && allMessages.length > 0) {
+      logger.warn({
+        msg: '[Model] Returning accumulated messages after hitting loop limit',
+        messageCount: allMessages.length,
+        sessionId: state.sessionId,
+        node: node.displayName,
+      });
+
+      return {
+        ...accumulatedStateUpdates,
+        goto: null,
+        messages: allMessages,
+        history: allHistory,
+      };
     }
-    return {
-      ...stateUpdate,
-      history: createHistoryStep<HistoryStep>(state.history, {
-        type: NodeType.PROMPT_NODE,
-        nodeId: node.name,
-        nodeDisplayName: node.displayName,
-        raw: result.content,
-        messageIds: [result.id!],
-      }),
-    };
+
+    // This should only be reached in unexpected cases
+    throw new Error('Unexpected state: no messages generated in prompt node');
   };
   graph.addNode(node.name, callback);
 };