@minded-ai/mindedjs 1.0.130 → 1.0.131

package/src/interrupts/MindedInterruptSessionManager.ts

@@ -1,5 +1,6 @@
 import { BaseInterruptSessionManager, QueuedMessage, QUEUE_INTERRUPT_DETECTED_BEFORE_SPEECH } from './BaseInterruptSessionManager';
 import * as mindedConnection from '../platform/mindedConnection';
+import { logger } from '../utils/logger';
 import {
   mindedConnectionSocketMessageType,
   InterruptSessionIsProcessedRequest,
@@ -35,8 +36,8 @@ export class MindedInterruptSessionManager extends BaseInterruptSessionManager {
         },
       );
       return response.isProcessed ?? false;
-    } catch (error) {
-      console.error('Error checking if session is processed:', error);
+    } catch (err) {
+      logger.error({ message: 'Error checking if session is processed', err });
       return false;
     }
   }
@@ -51,8 +52,8 @@ export class MindedInterruptSessionManager extends BaseInterruptSessionManager {
         },
       );
       return response.lockAcquired ?? false;
-    } catch (error) {
-      console.error('Error locking session:', error);
+    } catch (err) {
+      logger.error({ message: 'Error locking session', err });
       return false;
     }
   }
@@ -66,9 +67,9 @@ export class MindedInterruptSessionManager extends BaseInterruptSessionManager {
           sessionId,
         },
       );
-    } catch (error) {
-      console.error('Error releasing session:', error);
-      throw error;
+    } catch (err) {
+      logger.error({ message: 'Error releasing session', err });
+      throw err;
     }
   }
 
@@ -82,9 +83,9 @@ export class MindedInterruptSessionManager extends BaseInterruptSessionManager {
           message,
         },
       );
-    } catch (error) {
-      console.error('Error enqueuing message:', error);
-      throw error;
+    } catch (err) {
+      logger.error({ message: 'Error enqueuing message', err });
+      throw err;
     }
   }
 
@@ -98,8 +99,8 @@ export class MindedInterruptSessionManager extends BaseInterruptSessionManager {
         },
       );
       return response.messages ?? [];
-    } catch (error) {
-      console.error('Error dequeuing all messages:', error);
+    } catch (err) {
+      logger.error({ message: 'Error dequeuing all messages', err });
       return [];
     }
   }
@@ -121,8 +122,8 @@ export class MindedInterruptSessionManager extends BaseInterruptSessionManager {
       }
 
       return message;
-    } catch (error) {
-      console.error('Error dequeuing message:', error);
+    } catch (err) {
+      logger.error({ message: 'Error dequeuing message', err });
       return null;
     }
   }
@@ -138,8 +139,8 @@ export class MindedInterruptSessionManager extends BaseInterruptSessionManager {
         },
       );
       return response.hasMessages ?? false;
-    } catch (error) {
-      console.error('Error checking if session has messages:', error);
+    } catch (err) {
+      logger.error({ message: 'Error checking if session has messages', err });
       return false;
     }
   }
@@ -154,8 +155,8 @@ export class MindedInterruptSessionManager extends BaseInterruptSessionManager {
         },
       );
       return response.messages ?? [];
-    } catch (error) {
-      console.error('Error getting queued messages:', error);
+    } catch (err) {
+      logger.error({ message: 'Error getting queued messages', err });
       return [];
     }
   }

package/src/nodes/addAppToolNode.ts

@@ -42,9 +42,9 @@ export const addAppToolNode = async ({
       try {
         const response = await appRunnerTool.execute({ input, state, agent });
         return response || {};
-      } catch (error) {
-        logger.error({ msg: `[Node] Error executing tool`, error, node: node.name });
-        throw error;
+      } catch (err) {
+        logger.error({ message: `[Node] Error executing tool`, err, node: node.name });
+        throw err;
       }
     };
     const tool = langchainTool(executeWrapper, {

package/src/nodes/addToolRunNode.ts

@@ -38,9 +38,9 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
         const endTime = Date.now();
         logger.debug({ msg: '[Tool] Tool execution time', tool: matchedTool.name, executionTimeMs: endTime - startTime });
         return response || {};
-      } catch (error) {
-        logger.error({ msg: '[Tool] Error executing tool', error, node: toolNode.displayName });
-        throw error;
+      } catch (err) {
+        logger.error({ message: '[Tool] Error executing tool', err, node: toolNode.displayName });
+        throw err;
       }
     };
     const tool = langchainTool(executeWrapper, {

package/src/nodes/compilePrompt.ts

@@ -13,8 +13,8 @@ export function compilePrompt(prompt: string, params: Record<string, any> = {}):
     compiledPrompt = replacePlaceholders(compiledPrompt, params);
 
     return compiledPrompt;
-  } catch (error) {
-    logger.error({ message: 'Error compiling prompt', error });
+  } catch (err) {
+    logger.error({ message: 'Error compiling prompt', err });
     return prompt; // Return uncompiled if there's an error
   }
 }

package/src/platform/mindedCheckpointSaver.ts

@@ -125,8 +125,8 @@ export class MindedCheckpointSaver extends BaseCheckpointSaver<number> {
         },
       );
       return response.config;
-    } catch (error) {
-      logger.error({ msg: 'Error putting checkpoint:', error });
+    } catch (err) {
+      logger.error({ message: 'Error putting checkpoint:', err });
       return config;
     }
   }
@@ -139,8 +139,8 @@ export class MindedCheckpointSaver extends BaseCheckpointSaver<number> {
         writes,
         taskId,
       });
-    } catch (error) {
-      logger.error({ msg: 'Error putting writes:', error });
+    } catch (err) {
+      logger.error({ message: 'Error putting writes:', err });
     }
   }
 }

package/src/platform/piiGateway/gateway.ts

@@ -56,8 +56,8 @@ export class PIIGateway implements PIIGatewayInstance {
         headers: response.headers || {},
         config: config || {},
       };
-    } catch (error) {
-      logger.error({ msg: 'Secure HTTP request failed', error });
+    } catch (err) {
+      logger.error({ message: 'Secure HTTP request failed', err });
       return {
         data: undefined as T,
         status: 500,

package/src/platform/toolExecutor.ts

@@ -103,15 +103,15 @@ export class ToolExecutor {
       return {
         result,
       };
-    } catch (error) {
+    } catch (err) {
       logger.error({
-        msg: '[ToolExecutor] Error executing tool',
+        message: '[ToolExecutor] Error executing tool',
         toolName,
-        error: error instanceof Error ? error.message : String(error),
+        err,
       });
 
       return {
-        error: error instanceof Error ? error.message : String(error),
+        error: err instanceof Error ? err.message : String(err),
       };
     }
   }

package/src/platform/utils/tools.ts

@@ -23,10 +23,10 @@ export const zodSchemaToParams = (zodSchema: any): any[] => {
     }
 
     return params;
-  } catch (error) {
+  } catch (err) {
     logger.warn({
-      msg: '[ToolExecutor] Error parsing Zod schema',
-      error: error instanceof Error ? error.message : String(error),
+      message: '[ToolExecutor] Error parsing Zod schema',
+      err,
     });
     return [];
   }

package/src/playbooks/playbooks.ts

@@ -92,9 +92,9 @@ function editorJsToMarkdown(blocks: OutputBlockData[]): string {
             return '';
           }
         }
-      } catch (error) {
-        logger.error({ msg: 'Error converting EditorJS blocks to markdown', error, block });
-        throw error;
+      } catch (err) {
+        logger.error({ message: 'Error converting EditorJS blocks to markdown', err, block });
+        throw err;
       }
     })
     .join('\n\n');
@@ -152,8 +152,8 @@ function loadPlaybooksFromDirectories(directories: string[]): Playbook[] {
         } else {
           logger.warn({ msg: `Invalid playbook structure in ${file}` });
         }
-      } catch (error) {
-        logger.error({ msg: `Failed to load playbook file ${file}: ${error}` });
+      } catch (err) {
+        logger.error({ message: `Failed to load playbook file ${file}: ${err}` });
       }
     }
   }

package/src/toolsLibrary/classifier.ts

@@ -76,14 +76,13 @@ export async function classify(content: string, config: ClassifierConfig, llm: B
       const classText = typeof result.content === 'string' ? result.content.trim() : '';
       return { class: classText };
     }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.error({ message: 'Classification failed, using default', error: errorMessage });
+  } catch (err) {
+    logger.error({ message: 'Classification failed, using default', err });
 
     // Return default classification on error
     return {
       class: mergedConfig.defaultClass || 'unknown',
-      reason: mergedConfig.defaultReason || errorMessage,
+      reason: mergedConfig.defaultReason || (err as Error).message,
       confidence: 0,
     };
   }
@@ -204,15 +203,14 @@ const classifierTool: Tool<typeof schema, any> = {
           },
         },
       };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
+    } catch (err) {
       logger.error({
         message: 'Classification failed',
         sessionId: state.sessionId,
-        error: errorMessage,
+        err,
       });
 
-      throw error;
+      throw err;
     }
   },
 };
@@ -258,14 +256,13 @@ ${content}`;
 
     // If single result returned, wrap in array
     return [result as ClassificationResult];
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.error({ message: 'Multi-classification failed', error: errorMessage });
+  } catch (err) {
+    logger.error({ message: 'Multi-classification failed', err });
 
     return [
       {
         class: mergedConfig.defaultClass || 'unknown',
-        reason: mergedConfig.defaultReason || errorMessage,
+        reason: mergedConfig.defaultReason || (err as Error).message,
         confidence: 0,
       },
     ];

package/src/toolsLibrary/parseDocument.ts

@@ -114,18 +114,18 @@ const parseDocumentTool: Tool<typeof schema, any> = {
           },
         },
       };
-    } catch (error) {
+    } catch (err) {
       logger.error({
-        msg: 'Failed to parse document',
+        message: 'Failed to parse document',
         sessionId: state.sessionId,
-        error: error instanceof Error ? error.message : String(error),
+        err,
       });
 
       return {
-        result: `Failed to parse document: ${error instanceof Error ? error.message : String(error)}`,
+        result: `Failed to parse document: ${err instanceof Error ? err.message : String(err)}`,
         state: {
           memory: {
-            documentParsingError: error instanceof Error ? error.message : String(error),
+            documentParsingError: err instanceof Error ? err.message : String(err),
           },
         },
       };

package/src/utils/agentUtils.ts

@@ -45,8 +45,8 @@ export function loadFlowsFromDirectory(flowsDirectories: string[]): Flow[] {
           }
 
           flows.push(parsedFlow);
-        } catch (error) {
-          throw new Error(`Failed to parse flow file ${file}: ${error}`);
+        } catch (err) {
+          throw new Error(`Failed to parse flow file ${file}: ${err}`);
         }
       }
     }

package/src/utils/extractStateMemoryResponse.ts

@@ -11,8 +11,8 @@ const extractToolStateResponse = (toolMessage: ToolMessage): Partial<State> => {
       }
       return parsed.state;
     }
-  } catch (error) {
-    logger.error({ msg: 'Error parsing tool state response', error });
+  } catch (err) {
+    logger.error({ message: 'Error parsing tool state response', err });
   }
   return {};
 };
@@ -23,70 +23,72 @@ const constructMessagesFromToolMessage = (messages: any[]): BaseMessage[] => {
     return [];
   }
 
-  return messages.map((messageObj) => {
-    try {
-      // Handle case where message is already a BaseMessage instance
-      if (messageObj instanceof BaseMessage) {
-        return messageObj;
-      }
+  return messages
+    .map((messageObj) => {
+      try {
+        // Handle case where message is already a BaseMessage instance
+        if (messageObj instanceof BaseMessage) {
+          return messageObj;
+        }
 
-      // Handle case where message is a plain object that needs reconstruction
-      const messageType = messageObj.id[2];
-      const content = messageObj.kwargs.content || '';
-      const id = messageObj.kwargs.id;
-      const additionalKwargs = messageObj.additional_kwargs || {};
+        // Handle case where message is a plain object that needs reconstruction
+        const messageType = messageObj.id[2];
+        const content = messageObj.kwargs.content || '';
+        const id = messageObj.kwargs.id;
+        const additionalKwargs = messageObj.additional_kwargs || {};
 
-      switch (messageType) {
-        case 'AIMessage':
-          return new AIMessage({
-            content,
-            id,
-            additional_kwargs: additionalKwargs,
-            tool_calls: messageObj.tool_calls || [],
-            invalid_tool_calls: messageObj.invalid_tool_calls || [],
-          });
-        case 'HumanMessage':
-          return new HumanMessage({
-            content,
-            id,
-            additional_kwargs: additionalKwargs,
-          });
-        case 'SystemMessage':
-          return new SystemMessage({
-            content,
-            id,
-            additional_kwargs: additionalKwargs,
-          });
-        case 'ToolMessage':
-          return new ToolMessage({
-            content,
-            id,
-            additional_kwargs: additionalKwargs,
-            tool_call_id: messageObj.tool_call_id || '',
-          });
+        switch (messageType) {
+          case 'AIMessage':
+            return new AIMessage({
+              content,
+              id,
+              additional_kwargs: additionalKwargs,
+              tool_calls: messageObj.tool_calls || [],
+              invalid_tool_calls: messageObj.invalid_tool_calls || [],
+            });
+          case 'HumanMessage':
+            return new HumanMessage({
+              content,
+              id,
+              additional_kwargs: additionalKwargs,
+            });
+          case 'SystemMessage':
+            return new SystemMessage({
+              content,
+              id,
+              additional_kwargs: additionalKwargs,
+            });
+          case 'ToolMessage':
+            return new ToolMessage({
+              content,
+              id,
+              additional_kwargs: additionalKwargs,
+              tool_call_id: messageObj.tool_call_id || '',
+            });
 
-        default:
-          // Default to HumanMessage for unknown types
-          logger.warn({
-            msg: 'Unknown message type, defaulting to HumanMessage',
-            messageType,
-            messageObj
-          });
-          return null;
+          default:
+            // Default to HumanMessage for unknown types
+            logger.warn({
+              msg: 'Unknown message type, defaulting to HumanMessage',
+              messageType,
+              messageObj,
+            });
+            return null;
+        }
+      } catch (err) {
+        logger.error({
+          msg: 'Error reconstructing message',
+          err,
+          messageObj,
+        });
+        // Return a fallback HumanMessage in case of error
+        return new HumanMessage({
+          content: messageObj.content || 'Error reconstructing message',
+          id: messageObj.id,
+        });
       }
-    } catch (error) {
-      logger.error({
-        msg: 'Error reconstructing message',
-        error,
-        messageObj
-      });
-      // Return a fallback HumanMessage in case of error
-      return new HumanMessage({
-        content: messageObj.content || 'Error reconstructing message',
-        id: messageObj.id,
-      });
-    }
-  }).filter(Boolean) as BaseMessage[];
+    })
+    .filter(Boolean) as BaseMessage[];
 };
 
 export default extractToolStateResponse;

package/src/utils/logger.ts

@@ -19,4 +19,7 @@ export const logger = pino({
       return { level: label };
     },
   },
+  serializers: {
+    err: pino.stdSerializers.err,
+  },
 });

package/src/voice/voiceSession.ts

@@ -173,8 +173,8 @@ export class VoiceSession {
                 sessionId: this.sessionId,
                 timestamp: Date.now(),
               });
-            } catch (error) {
-              logger.error({ msg: '[Voice] Error sending interruption to dashboard', sessionId: this.sessionId, error });
+            } catch (err) {
+              logger.error({ message: '[Voice] Error sending interruption to dashboard', sessionId: this.sessionId, err });
             }
           }
           break;
@@ -191,8 +191,8 @@ export class VoiceSession {
                 timestamp: Date.now(),
                 type: mindedConnectionSocketMessageType.VOICE_AGENT_AUDIO,
               });
-            } catch (error) {
-              logger.error({ msg: '[Voice] Error sending audio to dashboard', sessionId: this.sessionId, error });
+            } catch (err) {
+              logger.error({ message: '[Voice] Error sending audio to dashboard', sessionId: this.sessionId, err });
             }
           }
           break;
@@ -210,8 +210,8 @@ export class VoiceSession {
               data.agent_response_correction_event.original_agent_response,
               data.agent_response_correction_event.corrected_agent_response,
             );
-          } catch (error) {
-            logger.error({ msg: '[Voice] Error updating agent response', sessionId: this.sessionId, error });
+          } catch (err) {
+            logger.error({ message: '[Voice] Error updating agent response', sessionId: this.sessionId, err });
           }
           break;
         default: