@minded-ai/mindedjs 1.0.92-beta-2 → 1.0.92-beta-3

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,17 +59,16 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
         ]);
 
         if (result === true) {
-          logger.info(`Condition matched for edge ${edge.source} → ${edge.target}`);
+          logger.info({ message: `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({
-          msg: `Error evaluating condition for edge ${edge.source} → ${edge.target}`,
+          message: `Error evaluating condition for edge ${edge.source} → ${edge.target}`,
           condition: conditionPreview,
           error: errorMessage,
           edgeIndex: edges.indexOf(edge),
@@ -84,15 +83,15 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
 
     // If no regular conditions matched, check for "else" conditions
     if (elseEdges.length > 0) {
-      logger.info(`No regular conditions matched, evaluating ${elseEdges.length} else condition(s)`);
+      logger.info({ message: `No regular conditions matched, evaluating ${elseEdges.length} else condition(s)` });
       // Return the first "else" condition's target
       const elseEdge = elseEdges[0];
-      logger.info(`Else condition matched for edge ${elseEdge.source} → ${elseEdge.target}`);
+      logger.info({ message: `Else condition matched for edge ${elseEdge.source} → ${elseEdge.target}`, edge: elseEdge });
       return elseEdge.target;
     }
 
     // If no conditions matched or all failed, return to the source node
-    logger.info('No conditions matched');
+    logger.info({ message: '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(`Executing prompt router. Edges: ${JSON.stringify(edges)}`);
+    logger.info({ message: `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(`No edges available and canStayInCurrentNode is true, staying in current node: ${currentNodeName}`);
+      logger.info({ message: `No edges available and canStayInCurrentNode is true, staying in current node: ${currentNodeName}` });
       return currentNodeName;
     }
 
@@ -174,13 +174,14 @@ 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({ msg: `Router decision: ${decision}`, reasoning });
+        logger.info({ message: `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('No logical conditions matched, continuing to prompt conditions');
+          logger.debug({ message: '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(`No conditions matched, returning to source: ${source}`);
+      logger.info({ message: `No conditions matched, returning to source: ${source}` });
       return source;
     };
   };

package/src/interrupts/InterruptSessionManager.types.ts

@@ -1,5 +1,6 @@
 import { State } from '../types/LangGraph.types';
 import { GraphInterrupt } from '@langchain/langgraph';
+import { logger } from '../utils/logger';
 
 export enum InterruptType {
   NEW_TRIGGERS = 'NEW_TRIGGERS',
@@ -52,7 +53,7 @@ export abstract class BaseInterruptSessionManager implements InterruptSessionMan
   async checkQueueAndInterrupt(sessionId: string, updateStateObject?: Partial<State>): Promise<boolean> {
     if (await this.hasQueuedMessages(sessionId)) {
       const queue = await this.getQueuedMessages(sessionId);
-      console.log({ message: 'Interrupting graph', sessionId, queue, updateStateObject });
+      logger.trace({ message: 'graph has queued messagess, interrupting graph', sessionId, queue });
 
       // Interrupt the graph with NEW_TRIGGERS flag and optional updateStateObject
       const interruptPayload: InterruptPayload = { type: InterruptType.NEW_TRIGGERS };

package/src/interrupts/interruptSessionManagerFactory.ts

@@ -3,15 +3,18 @@ import { MemoryInterruptSessionManager } from './MemoryInterruptSessionManager';
 import { MindedInterruptSessionManager } from './MindedInterruptSessionManager';
 import { MindedConnection } from '../platform/mindedConnection';
 import { getConfig } from '../platform/config';
+import { logger } from '../utils/logger';
 
 export function createInterruptSessionManager(mindedConnection: MindedConnection | null): InterruptSessionManager {
   const { runLocally } = getConfig();
   if (runLocally) {
+    logger.info({ message: 'Using memory interrupt session manager' });
     return new MemoryInterruptSessionManager();
   } else {
     if (!mindedConnection) {
       throw new Error('MindedConnection is required for platform interrupt session manager');
     }
+    logger.info({ message: 'Using Minded interrupt session manager' });
     return new MindedInterruptSessionManager(mindedConnection);
   }
 }

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(`Executing tool node ${appRunnerTool.name}`);
+    logger.info({ message: `Executing tool node ${appRunnerTool.name}` });
 
     const executeWrapper = async (input: z.infer<typeof appRunnerTool.input>) => {
       try {

package/src/nodes/addHumanInTheLoopNode.ts

@@ -14,7 +14,7 @@ export const buildHumanInTheLoopNodeName = (nodeName: string) => `${nodeName}${i
 
 export const addHumanInTheLoopNode = async ({ graph, attachedToNodeName }: AddHumanInTheLoopNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing "human in the loop" node for the attached node${attachedToNodeName}`);
+    logger.info({ message: `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 });

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(`Executing jump node ${node.displayName} – jumping to ${node.targetNodeId}`);
+    logger.info({ message: `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,6 +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';
 const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
 type AddPromptNodeParams = {
   graph: PreCompiledGraph;
@@ -27,7 +28,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(`Executing prompt node ${node.displayName}`);
+    logger.info({ message: `Executing prompt node ${node.displayName}` });
     const llmToUse = node.llmConfig ? createLlmInstance(node.llmConfig) : llm;
 
     const globalTools = tools
@@ -69,13 +70,17 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
             const toolResult = await matchedTool.invoke(toolCall);
             console.log('after invoke?');
             //check for queue after tool call
+            const systemMessageId = uuidv4();
+
             await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId, {
               messages: [
                 result,
                 toolResult,
-                new SystemMessage(
-                  'you called tool when the user send a new message, Consider calling the function again after user message is processed',
-                ),
+                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, {
@@ -83,7 +88,7 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
                   nodeId: node.name,
                   nodeDisplayName: node.displayName,
                   raw: toolResult,
-                  messageIds: [toolResult.id!],
+                  messageIds: [toolResult.id!, systemMessageId],
                 }),
               ],
             });

package/src/nodes/addToolNode.ts

@@ -30,7 +30,7 @@ export const addToolNode = async ({
     throw new Error(`Tool not found: ${toolNode.toolName} in node ${node.name}`);
   }
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing tool node ${toolNode.displayName}`);
+    logger.info({ message: `Executing tool node ${toolNode.displayName}` });
 
     const tool = langchainTool(() => {}, {
       name: matchedTool.name,

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(`Executing trigger node ${node.displayName}`);
+    logger.info({ message: `Executing trigger node ${node.displayName}` });
     if (node.triggerType === TriggerType.MANUAL) {
       return {
         history: createHistoryStep<HistoryStep>(state.history, {

package/src/platform/mindedConnection.ts

@@ -34,7 +34,7 @@ export class MindedConnection {
     }
   };
 
-  public awaitEmit = async <T, R>(event: MindedConnectionSocketMessageType, message: T, timeoutMs: number = 5000): Promise<R> => {
+  public awaitEmit = async <T, R>(event: MindedConnectionSocketMessageType, message: T, timeoutMs: number = 10000): Promise<R> => {
     if (!this.socket) {
       throw new Error('Socket is not connected');
     }
@@ -75,43 +75,43 @@ export class MindedConnection {
 
       const checkReady = () => {
         if (connected && ready) {
-          logger.info('\x1b[32mConnection with Minded platform is ready!\x1b[0m');
-          logger.info('\x1b[32mPress Ctrl+C to exit...');
+          logger.info({ message: '\x1b[32mConnection with Minded platform is ready!\x1b[0m' });
+          logger.info({ message: '\x1b[32mPress Ctrl+C to exit...' });
           resolve();
         }
       };
 
       // Connection event handlers
       this.socket.on('connect', () => {
-        logger.info('Socket connected, waiting for server setup...');
+        logger.info({ message: 'Socket connected, waiting for server setup...' });
         connected = true;
         checkReady();
       });
 
       // Listen for ready event from server
       this.socket.on('sdk-socket-ready', (data: { agentId: string; orgName: string }) => {
-        logger.info('Server ready signal received', data);
+        logger.info({ message: 'Server ready signal received', data });
         ready = true;
         checkReady();
       });
 
       this.socket.on('connect_error', () => {
-        logger.error('Failed to connect to minded platform');
+        logger.error({ message: 'Failed to connect to minded platform' });
         reject(new Error('Failed to connect to minded platform'));
       });
 
       this.socket.on('disconnect', () => {
-        logger.info('Disconnected from local debugging socket');
+        logger.info({ message: 'Disconnected from local debugging socket' });
         connected = false;
         ready = false;
       });
 
       // Listen for error messages from the server
       this.socket.on('error', async (error: { message: string }) => {
-        logger.error({ msg: 'Server error:', error });
+        logger.error({ message: 'Server error:', error });
 
         if (error.message.includes('Invalid token')) {
-          logger.info('Invalid token');
+          logger.info({ message: 'Invalid token' });
 
           // Disconnect current socket
           if (this.socket?.connected) {
@@ -137,7 +137,7 @@ export class MindedConnection {
       // Handle process termination
       process.on('SIGINT', () => {
         if (this.socket?.connected) {
-          logger.info('\nDisconnecting...');
+          logger.info({ message: '\nDisconnecting...' });
           this.socket.disconnect();
         }
         process.exit(0);
@@ -155,16 +155,16 @@ export class MindedConnection {
 
   public disconnect() {
     if (!this.socket) {
-      logger.warn('No socket connection to disconnect');
+      logger.warn({ message: 'No socket connection to disconnect' });
       return;
     }
 
     if (this.socket.connected) {
-      logger.info('Disconnecting from Minded platform...');
+      logger.info({ message: 'Disconnecting from Minded platform...' });
       this.socket.disconnect();
       return;
     }
 
-    logger.warn('Socket is already disconnected');
+    logger.warn({ message: 'Socket is already disconnected' });
   }
 }

package/src/playbooks/playbooks.ts

@@ -113,7 +113,7 @@ function loadPlaybooksFromDirectories(directories: string[]): Playbook[] {
 
   for (const directory of directories) {
     if (!fs.existsSync(directory)) {
-      logger.info(`Playbooks directory does not exist: ${directory}`);
+      logger.info({ message: `Playbooks directory does not exist: ${directory}` });
       continue;
     }
 
@@ -126,12 +126,12 @@ function loadPlaybooksFromDirectories(directories: string[]): Playbook[] {
 
         if (playbook && playbook.name && playbook.blocks) {
           playbooks.push(playbook);
-          logger.info(`Loaded playbook: ${playbook.name} from ${file}`);
+          logger.info({ message: `Loaded playbook: ${playbook.name} from ${file}` });
         } else {
-          logger.warn(`Invalid playbook structure in ${file}`);
+          logger.warn({ message: `Invalid playbook structure in ${file}` });
         }
       } catch (error) {
-        logger.error(`Failed to load playbook file ${file}: ${error}`);
+        logger.error({ message: `Failed to load playbook file ${file}: ${error}` });
       }
     }
   }

package/src/utils/logger.ts

@@ -12,6 +12,7 @@ export const logger = pino({
       colorize: true,
       crlf: true,
       translateTime: 'SYS:standard',
+      messageKey: 'message', // Use 'message' instead of default 'msg'
     },
   },
   formatters: {

package/src/voice/voiceSession.ts

@@ -99,10 +99,10 @@ export class VoiceSession {
           },
           ...(this.voiceId
             ? {
-              tts: {
-                voice_id: this.voiceId,
-              },
-            }
+                tts: {
+                  voice_id: this.voiceId,
+                },
+              }
             : {}),
         } as ConversationInitiationClientData['conversation_config_override'],
       };
@@ -134,7 +134,11 @@ export class VoiceSession {
           }, data.ping_event.ping_ms);
           break;
         case 'user_transcript':
-          logger.debug({ message: 'User transcript received', sessionId: this.sessionId, data: data.user_transcription_event.user_transcript });
+          logger.debug({
+            message: 'User transcript received',
+            sessionId: this.sessionId,
+            data: data.user_transcription_event.user_transcript,
+          });
           if (this.onMessageCallback) {
             this.onMessageCallback(
               data.user_transcription_event.user_transcript,
@@ -189,7 +193,11 @@ export class VoiceSession {
           break;
         case 'agent_response_correction':
           try {
-            logger.debug({ message: 'Agent response correction received', sessionId: this.sessionId, data: data.agent_response_correction_event });
+            logger.debug({
+              message: 'Agent response correction received',
+              sessionId: this.sessionId,
+              data: data.agent_response_correction_event,
+            });
             await this.updateAgentResponse(
               data.agent_response_correction_event.original_agent_response,
               data.agent_response_correction_event.corrected_agent_response,