@minded-ai/mindedjs 1.0.95-beta-3 → 1.0.96-beta-1

package/src/cli/index.ts

@@ -19,7 +19,7 @@ function setToken(token: string): void {
   if (!fs.existsSync(envPath)) {
     // Create .env file with the token
     fs.writeFileSync(envPath, tokenLine + '\n');
-    logger.info({ message: `Created ${envPath} and added token` });
+    logger.info(`Created ${envPath} and added token`);
   } else {
     // Read existing .env file
     const envContent = fs.readFileSync(envPath, 'utf8');
@@ -29,12 +29,12 @@ function setToken(token: string): void {
       // Replace existing token
       const updatedContent = envContent.replace(/MINDED_CONNECTION_TOKEN=.*/, tokenLine);
       fs.writeFileSync(envPath, updatedContent);
-      logger.info({ message: `Updated MINDED_CONNECTION_TOKEN in ${envPath}` });
+      logger.info(`Updated MINDED_CONNECTION_TOKEN in ${envPath}`);
     } else {
       // Append token to existing file
       const newContent = envContent.endsWith('\n') ? envContent + tokenLine + '\n' : envContent + '\n' + tokenLine + '\n';
       fs.writeFileSync(envPath, newContent);
-      logger.info({ message: `Added MINDED_CONNECTION_TOKEN to ${envPath}` });
+      logger.info(`Added MINDED_CONNECTION_TOKEN to ${envPath}`);
     }
   }
 }
@@ -44,7 +44,7 @@ function generateLambdaHandler(): void {
 
   // Check if minded.json exists
   if (!fs.existsSync(mindedConfigPath)) {
-    logger.error({ message: 'minded.json not found in the current directory' });
+    logger.error('minded.json not found in the current directory');
     process.exit(1);
   }
 
@@ -54,14 +54,14 @@ function generateLambdaHandler(): void {
     const configContent = fs.readFileSync(mindedConfigPath, 'utf8');
     mindedConfig = JSON.parse(configContent);
   } catch (error) {
-    logger.error({ message: 'Failed to read or parse minded.json:', error });
+    logger.error('Failed to read or parse minded.json:', error);
     process.exit(1);
   }
 
   // Get the agent path
   const agentPath = mindedConfig.agent;
   if (!agentPath) {
-    logger.error({ message: 'No agent path found in minded.json' });
+    logger.error('No agent path found in minded.json');
     process.exit(1);
   }
 
@@ -91,7 +91,7 @@ function generateLambdaHandler(): void {
   }
 
   if (!templateContent) {
-    logger.error({ message: 'Could not find Lambda handler template file' });
+    logger.error('Could not find Lambda handler template file');
     process.exit(1);
   }
 
@@ -102,10 +102,10 @@ function generateLambdaHandler(): void {
     // Write the Lambda handler to index.ts at the root
     const outputPath = path.join(process.cwd(), 'index.ts');
     fs.writeFileSync(outputPath, templateContent);
-    logger.info({ message: `Generated Lambda handler at ${outputPath}` });
+    logger.info(`Generated Lambda handler at ${outputPath}`);
 
     // Compile the index.ts file using TypeScript
-    logger.info({ message: 'Compiling the Lambda handler...' });
+    logger.info('Compiling the Lambda handler...');
 
     try {
       // Read tsconfig.json to get the outDir
@@ -138,7 +138,7 @@ function generateLambdaHandler(): void {
         cwd: process.cwd(),
       });
 
-      logger.info({ message: `Successfully compiled Lambda handler to ${outDir}/index.js` });
+      logger.info(`Successfully compiled Lambda handler to ${outDir}/index.js`);
     } catch (compileError) {
       logger.error({ message: 'Failed to compile Lambda handler', error: compileError });
     }
@@ -155,14 +155,14 @@ function main() {
   if (command === 'token') {
     const token = args[1];
     if (!token) {
-      logger.error({ message: 'Please provide a token' });
+      logger.error('Please provide a token');
       process.exit(1);
     }
     setToken(token);
   } else if (command === 'generate-lambda-ts-handler') {
     generateLambdaHandler();
   } else {
-    logger.error({ message: 'Unknown command. Available commands: token, generate-lambda-ts-handler' });
+    logger.error('Unknown command. Available commands: token, generate-lambda-ts-handler');
     process.exit(1);
   }
 }

package/src/edges/createDirectEdge.ts

@@ -5,7 +5,7 @@ export const createDirectEdge = (edge: StepForwardEdge) => {
   return async () => {
     // For direct edges, we just return the target of the first edge
     // since there's no conditional logic needed
-    logger.info({ message: `Executing edge ${JSON.stringify(edge)}` });
+    logger.info(`Executing edge ${JSON.stringify(edge)}`);
     return edge.target;
   };
 };

package/src/edges/createLogicalRouter.ts

@@ -11,8 +11,8 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
     logger.debug(`Evaluating logical conditions for ${edges.length} edges`);
 
     // Separate regular conditions from "else" conditions
-    const regularEdges = edges.filter((edge) => edge.condition.trim() !== 'else');
-    const elseEdges = edges.filter((edge) => edge.condition.trim() === 'else');
+    const regularEdges = edges.filter(edge => edge.condition.trim() !== 'else');
+    const elseEdges = edges.filter(edge => edge.condition.trim() === 'else');
 
     // First, evaluate all regular conditions
     for (const edge of regularEdges) {
@@ -59,16 +59,17 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
         ]);
 
         if (result === true) {
-          logger.info({ message: `Condition matched for edge ${edge.source} → ${edge.target}` });
+          logger.info(`Condition matched for edge ${edge.source} → ${edge.target}`);
           return edge.target;
         }
+
       } catch (error) {
         // Provide detailed error information back to the customer
         const errorMessage = error instanceof Error ? error.message : String(error);
         const conditionPreview = edge.condition.length > 100 ? `${edge.condition.substring(0, 100)}...` : edge.condition;
 
         logger.error({
-          message: `Error evaluating condition for edge ${edge.source} → ${edge.target}`,
+          msg: `Error evaluating condition for edge ${edge.source} → ${edge.target}`,
           condition: conditionPreview,
           error: errorMessage,
           edgeIndex: edges.indexOf(edge),
@@ -83,15 +84,15 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
 
     // If no regular conditions matched, check for "else" conditions
     if (elseEdges.length > 0) {
-      logger.info({ message: `No regular conditions matched, evaluating ${elseEdges.length} else condition(s)` });
+      logger.info(`No regular conditions matched, evaluating ${elseEdges.length} else condition(s)`);
       // Return the first "else" condition's target
       const elseEdge = elseEdges[0];
-      logger.info({ message: `Else condition matched for edge ${elseEdge.source} → ${elseEdge.target}`, edge: elseEdge });
+      logger.info(`Else condition matched for edge ${elseEdge.source} → ${elseEdge.target}`);
       return elseEdge.target;
     }
 
     // If no conditions matched or all failed, return to the source node
-    logger.info({ message: 'No conditions matched' });
+    logger.info('No conditions matched');
     return null;
   };
 };

package/src/edges/createPromptRouter.ts

@@ -70,11 +70,11 @@ export const createPromptRouter = ({
   currentNodeName?: string;
 }) => {
   return async (state: typeof stateAnnotation.State) => {
-    logger.info({ message: `Executing prompt router. Edges: ${JSON.stringify(edges)}` });
+    logger.info(`Executing prompt router. Edges: ${JSON.stringify(edges)}`);
 
     // If canStayInCurrentNode is true and there are no edges, return current node immediately
     if (canStayInCurrentNode && edges.length === 0 && currentNodeName) {
-      logger.info({ message: `No edges available and canStayInCurrentNode is true, staying in current node: ${currentNodeName}` });
+      logger.info(`No edges available and canStayInCurrentNode is true, staying in current node: ${currentNodeName}`);
       return currentNodeName;
     }
 
@@ -174,14 +174,13 @@ export const createPromptRouter = ({
 
         const decision = validatedResponse.nextNodeId === currentNodeName ? 'stay in current node' : validatedResponse.nextNodeId;
         const reasoning = includeReasoning && 'reasoning' in validatedResponse ? ` - Reasoning: ${validatedResponse.reasoning}` : '';
-        logger.info({ message: `Router decision: ${decision}`, reasoning });
+        logger.info({ msg: `Router decision: ${decision}`, reasoning });
 
         return validatedResponse.nextNodeId;
       } catch (error) {
         lastError = error instanceof Error ? error : new Error(String(error));
         logger.warn({
           message: `Prompt router attempt ${attempts} failed`,
-          edge: edges,
           error: lastError.message,
           attempt: attempts,
           maxRetries,

package/src/edges/edgeFactory.ts

@@ -49,7 +49,7 @@ export const edgeFactory = ({
         if (result) {
           return result;
         } else {
-          logger.debug({ message: 'No logical conditions matched, continuing to prompt conditions' });
+          logger.debug('No logical conditions matched, continuing to prompt conditions');
         }
       }
 
@@ -69,7 +69,7 @@ export const edgeFactory = ({
 
       // Fallback: stay at current source node
       const source = originalNode?.name || sourceNode;
-      logger.info({ message: `No conditions matched, returning to source: ${source}` });
+      logger.info(`No conditions matched, returning to source: ${source}`);
       return source;
     };
   };

package/src/nodes/addAppToolNode.ts

@@ -26,7 +26,7 @@ export const addAppToolNode = async ({
   const cleanedParameters = Object.fromEntries(Object.entries(node.parameters || {}).filter(([, value]) => value !== ''));
   const appRunnerTool = getAppActionRunnerTool(node.displayName!);
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info({ message: `Executing tool node ${appRunnerTool.name}` });
+    logger.info(`Executing tool node ${appRunnerTool.name}`);
 
     const executeWrapper = async (input: z.infer<typeof appRunnerTool.input>) => {
       try {
@@ -75,8 +75,8 @@ export const addAppToolNode = async ({
     };
     const toolCallMessage = await tool.invoke(AIToolCallMessage.tool_calls[0]);
     AIToolCallMessage.additional_kwargs = {
-      appActionInvocation: {
-        nodeTitle: node.name,
+      mindedMetadata: {
+        nodeType: NodeType.APP_TOOL,
       },
     };
     return {

package/src/nodes/addHumanInTheLoopNode.ts

@@ -3,7 +3,6 @@ import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
 import { RunnableLike } from '@langchain/core/runnables';
 import { logger } from '../utils/logger';
 import { internalNodesSuffix } from '../types/Flows.types';
-import { InterruptType } from '../interrupts/BaseInterruptSessionManager';
 
 type AddHumanInTheLoopNodeParams = {
   graph: PreCompiledGraph;
@@ -14,9 +13,10 @@ export const buildHumanInTheLoopNodeName = (nodeName: string) => `${nodeName}${i
 
 export const addHumanInTheLoopNode = async ({ graph, attachedToNodeName }: AddHumanInTheLoopNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info({ message: `Executing "human in the loop" node for the attached node${attachedToNodeName}` });
+    logger.info(`Executing "human in the loop" node for the attached node${attachedToNodeName}`);
+
     if (state.messages[state.messages.length - 1].getType() === 'ai') {
-      const value = interrupt({ type: InterruptType.HUMAN_IN_THE_LOOP });
+      const value = interrupt('input from human in the loop');
       return value;
     }
   };

package/src/nodes/addJumpToNode.ts

@@ -7,7 +7,7 @@ import { createHistoryStep } from '../utils/history';
 
 export const addJumpToNode = async ({ graph, node }: { graph: PreCompiledGraph; node: JumpToNode }) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info({ message: `Executing jump node ${node.displayName} – jumping to ${node.targetNodeId}` });
+    logger.info(`Executing jump node ${node.displayName} – jumping to ${node.targetNodeId}`);
     // No state modifications are necessary; control flow is handled via edges.
     return {
       history: createHistoryStep<HistoryStep>(state.history, {

package/src/nodes/addPromptNode.ts

@@ -14,7 +14,7 @@ import { Agent } from '../agent';
 import { logger } from '../utils/logger';
 import { compilePlaybooks } from '../playbooks/playbooks';
 import { createHistoryStep } from '../utils/history';
-import { v4 as uuidv4 } from 'uuid';
+
 type AddPromptNodeParams = {
   graph: PreCompiledGraph;
   node: PromptNode;
@@ -26,8 +26,7 @@ type AddPromptNodeParams = {
 
 export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: AddPromptNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
-    logger.info({ message: `Executing prompt node ${node.displayName}` });
+    logger.info(`Executing prompt node ${node.displayName}`);
     const llmToUse = node.llmConfig ? createLlmInstance(node.llmConfig) : llm;
 
     const globalTools = tools
@@ -51,9 +50,9 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
     ${state.memory ? `# Task context:\n${JSON.stringify(state.memory)}\n\n` : ''}
     ${compiledPlaybooks ? `# General guidelines:\n${compiledPlaybooks}\n\n` : ''}
     `;
-    // await wait(5000);
+
     const result: AIMessage = await llmToUse.bindTools(globalTools).invoke([...state.messages, new SystemMessage(message)]);
-    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
+
     // Check if the result contains tool calls
     if (result.tool_calls && result.tool_calls.length > 0) {
       // Execute the tools
@@ -67,29 +66,6 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
           try {
             // Invoke the LangChain tool directly
             const toolResult = await matchedTool.invoke(toolCall);
-            //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: [
-                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
             stateUpdates = {
@@ -98,8 +74,7 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
               memory: { ...(stateUpdates as any).memory, ...(toolStateUpdate as any).memory },
             };
             toolResults.push(toolResult);
-          } catch (error: any) {
-            if (error?.name === 'GraphInterrupt') throw error;
+          } catch (error) {
             logger.error({ msg: `Error executing tool ${toolCall.name}:`, error });
             const errorMessage = new ToolMessage({
               content: JSON.stringify({ error: error instanceof Error ? error.message : String(error) }),
@@ -112,30 +87,10 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
         }
       }
 
-      // await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
-
       // Return the tool call message and tool results with state updates spread at top level
       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!],
-            }),
-          ),
-        ],
       };
     }
 
@@ -146,6 +101,7 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
       });
       console.log('AI Message', result.content);
     }
+
     return {
       history: createHistoryStep<HistoryStep>(state.history, {
         type: NodeType.PROMPT_NODE,

package/src/nodes/addToolNode.ts

@@ -30,8 +30,8 @@ export const addToolNode = async ({
     throw new Error(`Tool not found: ${toolNode.toolName} in node ${node.name}`);
   }
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
-    logger.info({ message: `Executing tool node ${toolNode.displayName}` });
+    logger.info(`Executing tool node ${toolNode.displayName}`);
+
     const tool = langchainTool(() => {}, {
       name: matchedTool.name,
       description: matchedTool.description,
@@ -56,8 +56,6 @@ export const addToolNode = async ({
         tool_choice: tool.name,
       })
       .invoke([...state.messages, new SystemMessage(prompt)]);
-    logger.info({ message: 'after llm tool invoke' });
-    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
     return {
       messages: [AIToolCallMessage],
       history: createHistoryStep<HistoryStep>(state.history, {

package/src/nodes/addToolRunNode.ts

@@ -23,7 +23,6 @@ type AddToolRunNodeParams = {
 
 export const buildToolRunNodeName = (nodeName: string) => `${nodeName}${internalNodesSuffix.TOOL_RUN}`;
 
-//you never want to interrupt here because of new triggers, as this node depends on the last message to be the tool call from the addToolNode, interrupting will add human message here
 export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeName, agent }: AddToolRunNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
     const matchedTool = tools.find((tool) => tool.name === toolNode.toolName);
@@ -55,6 +54,7 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
 
     // Push the toolCallMessage into the messages array from toolStateUpdate
     const updatedMessages = [toolCallMessage, ...((toolStateUpdate as any).messages || [])];
+
     // Return the full state update from the tool with the updated messages
     return {
       ...toolStateUpdate,

package/src/nodes/addTriggerNode.ts

@@ -7,7 +7,7 @@ import { createHistoryStep } from '../utils/history';
 
 export const addTriggerNode = async ({ graph, node }: { graph: PreCompiledGraph; node: TriggerNode }) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info({ message: `Executing trigger node ${node.displayName}` });
+    logger.info(`Executing trigger node ${node.displayName}`);
     if (node.triggerType === TriggerType.MANUAL) {
       return {
         history: createHistoryStep<HistoryStep>(state.history, {

package/src/platform/mindedConnection.ts

@@ -1,5 +1,8 @@
 import { io, Socket } from 'socket.io-client';
-import { mindedConnectionSocketMessageType, mindedConnectionSocketMessageTypeMap } from './mindedConnectionTypes';
+import {
+  mindedConnectionSocketMessageType,
+  mindedConnectionSocketMessageTypeMap,
+} from './mindedConnectionTypes';
 import { stringify } from 'flatted';
 import { getConfig } from './config';
 import { logger } from '../utils/logger';
@@ -25,13 +28,20 @@ export const on = <E extends keyof mindedConnectionSocketMessageTypeMap>(
   listeners[event].push(callback);
 };
 
-export const emit = <E extends keyof mindedConnectionSocketMessageTypeMap>(event: E, message: mindedConnectionSocketMessageTypeMap[E]) => {
+export const emit = <E extends keyof mindedConnectionSocketMessageTypeMap>(
+  event: E,
+  message: mindedConnectionSocketMessageTypeMap[E]
+) => {
   if (socket) {
     socket.emit(event, message);
   }
 };
 
-export const awaitEmit = async <T, R>(event: mindedConnectionSocketMessageType, message: T, timeoutMs: number = 5000): Promise<R> => {
+export const awaitEmit = async <T, R>(
+  event: mindedConnectionSocketMessageType,
+  message: T,
+  timeoutMs: number = 5000
+): Promise<R> => {
   if (!socket) {
     throw new Error('Socket is not connected');
   }
@@ -87,43 +97,43 @@ const connect = async (token: string): Promise<void> => {
 
     const checkReady = () => {
       if (connected && ready) {
-        logger.info({ message: '\x1b[32mConnection with Minded platform is ready!\x1b[0m' });
-        logger.info({ message: '\x1b[32mPress Ctrl+C to exit...' });
+        logger.info('\x1b[32mConnection with Minded platform is ready!\x1b[0m');
+        logger.info('\x1b[32mPress Ctrl+C to exit...');
         resolve();
       }
     };
 
     // Connection event handlers
     socket.on('connect', () => {
-      logger.info({ message: 'Socket connected, waiting for server setup...' });
+      logger.info('Socket connected, waiting for server setup...');
       connected = true;
       checkReady();
     });
 
     // Listen for ready event from server
     socket.on('sdk-socket-ready', (data: { agentId: string; orgName: string }) => {
-      logger.info({ message: 'Server ready signal received', data });
+      logger.info('Server ready signal received', data);
       ready = true;
       checkReady();
     });
 
     socket.on('connect_error', () => {
-      logger.error({ message: 'Failed to connect to minded platform' });
+      logger.error('Failed to connect to minded platform');
       reject(new Error('Failed to connect to minded platform'));
     });
 
     socket.on('disconnect', () => {
-      logger.info({ message: 'Disconnected from local debugging socket' });
+      logger.info('Disconnected from local debugging socket');
       connected = false;
       ready = false;
     });
 
     // Listen for error messages from the server
     socket.on('error', async (error: { message: string }) => {
-      logger.error({ message: 'Server error:', error });
+      logger.error({ msg: 'Server error:', error });
 
       if (error.message.includes('Invalid token')) {
-        logger.info({ message: 'Invalid token' });
+        logger.info('Invalid token');
 
         // Disconnect current socket
         if (socket?.connected) {
@@ -149,7 +159,7 @@ const connect = async (token: string): Promise<void> => {
     // Handle process termination
     process.on('SIGINT', () => {
       if (socket?.connected) {
-        logger.info({ message: '\nDisconnecting...' });
+        logger.info('\nDisconnecting...');
         socket.disconnect();
       }
       process.exit(0);
@@ -167,17 +177,17 @@ export const start = async (): Promise<void> => {
 
 export const disconnect = () => {
   if (!socket) {
-    logger.warn({ message: 'No socket connection to disconnect' });
+    logger.warn('No socket connection to disconnect');
     return;
   }
 
   if (socket.connected) {
-    logger.info({ message: 'Disconnecting from Minded platform...' });
+    logger.info('Disconnecting from Minded platform...');
     socket.disconnect();
     return;
   }
 
-  logger.warn({ message: 'Socket is already disconnected' });
+  logger.warn('Socket is already disconnected');
 };
 
 export const mindedConnection = {