@minded-ai/mindedjs 1.0.121 → 1.0.122-beta-1

package/src/nodes/addBrowserTaskNode.ts

@@ -54,7 +54,7 @@ export const addBrowserTaskNode = async ({ graph, node, agent, llm }: AddBrowser
     const zodSchema = z.object(schemaFields);
 
     // Create langchain tool
-    const tool = langchainTool(() => { }, {
+    const tool = langchainTool(() => {}, {
       name: 'browser-task',
       description: node.prompt,
       schema: zodSchema,
@@ -81,8 +81,8 @@ export const addBrowserTaskNode = async ({ graph, node, agent, llm }: AddBrowser
       // Prepare parameters for prompt compilation
       const promptParams = {
         input: inputParams,
-        state,
-        currentTime: new Date().toISOString(),
+        memory: state.memory,
+        system: { currentTime: new Date().toISOString() },
       };
 
       // Compile the prompt with parameters

package/src/nodes/addHumanInTheLoopNode.ts

@@ -3,6 +3,7 @@ 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;
@@ -16,7 +17,7 @@ export const addHumanInTheLoopNode = async ({ graph, attachedToNodeName }: AddHu
     logger.debug({ msg: `[Node] Waiting for human input`, node: attachedToNodeName });
 
     if (state.messages[state.messages.length - 1].getType() === 'ai') {
-      const value = interrupt('input from human in the loop');
+      const value = interrupt({ type: InterruptType.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(`Executing jump node ${node.displayName} – jumping to ${node.targetNodeId}`);
+    logger.info({ msg: `Executing jump node ${node.displayName} – jumping to ${node.targetNodeId}` });
     // No state modifications are necessary; control flow is handled via edges.
     return {
       goto: node.targetNodeId,

package/src/nodes/addPromptNode.ts

@@ -15,7 +15,7 @@ import { logger } from '../utils/logger';
 import { combinePlaybooks } from '../playbooks/playbooks';
 import { createHistoryStep } from '../utils/history';
 import { compilePrompt } from './compilePrompt';
-
+import { v4 as uuidv4 } from 'uuid';
 type AddPromptNodeParams = {
   graph: PreCompiledGraph;
   node: PromptNode;
@@ -27,7 +27,8 @@ type AddPromptNodeParams = {
 
 export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: AddPromptNodeParams) => {
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.debug({ msg: `[Node] Executing prompt node`, node: node.displayName });
+    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
+    logger.info({ msg: `[Node] Executing prompt node`, node: node.displayName });
     const llmToUse = node.llmConfig ? createLlmInstance(node.llmConfig) : llm;
 
     const globalTools = tools
@@ -42,15 +43,15 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
 
     const combinedPlaybooks = combinePlaybooks(agent.playbooks) || '';
 
-    const prompt = `
-    ${node.prompt ? `# Task instructions:\n${node.prompt}\n\n` : ''}
-    ${combinedPlaybooks ? `# General guidelines:\n${combinedPlaybooks}\n\n` : ''}
-    `;
-
-    const compiledPrompt = compilePrompt(prompt, { state, currentTime: new Date().toISOString() });
+    // Get edges for the current node and format them
+    const edges = agent.flows?.flatMap((flow: any) => flow.edges) || [];
+    const nodeEdges = edges.filter((edge: any) => edge.source === node.name);
+    const currentPromptNode = getCurrentPromptNode(node, nodeEdges);
+    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(globalTools).invoke([...state.messages, new SystemMessage(compiledPrompt)]);
+    const result: AIMessage = await llmToUse.bindTools(globalTools).invoke([new SystemMessage(compiledPrompt), ...state.messages]);
     const endTime = Date.now();
     logger.debug({ msg: '[Model] Model execution time', executionTimeMs: endTime - startTime });
     // Check if the result contains tool calls
@@ -69,6 +70,29 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
             const toolResult = await matchedTool.invoke(toolCall);
             const endTime = Date.now();
             logger.debug({ msg: `[Tool] Tool result`, tool: matchedTool?.name, result: toolResult, executionTimeMs: endTime - startTime });
+            //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 = {
@@ -77,7 +101,8 @@ 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) {
+          } catch (error: any) {
+            if (error?.name === 'GraphInterrupt') throw error;
             logger.error({ msg: `[Tool] Error executing tool`, tool: toolCall.name, error });
             const errorMessage = new ToolMessage({
               content: JSON.stringify({ error: error instanceof Error ? error.message : String(error) }),
@@ -90,10 +115,30 @@ 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!],
+            }),
+          ),
+        ],
       };
     }
 
@@ -104,7 +149,6 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
       });
       logger.info({ msg: `[Model] Response`, content: result.content });
     }
-
     return {
       goto: null,
       history: createHistoryStep<HistoryStep>(state.history, {
@@ -119,3 +163,43 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
   };
   graph.addNode(node.name, callback);
 };
+
+function getCurrentPromptNode(node: PromptNode, nodeEdges: any[]) {
+  // Format edges for display
+  let nextEdges = '';
+  if (node.canStayOnNode !== false) {
+    nextEdges = `0. Stay in the current step. step title: ${node.displayName}\n`;
+  }
+
+  let counter = node.canStayOnNode !== false ? 0 : -1;
+  const promptConditionEdges = nodeEdges.filter((edge: any) => edge.type === 'PROMPT_CONDITION');
+  promptConditionEdges.forEach((edge: any) => {
+    counter++;
+    nextEdges += `${counter}. ${edge.prompt || edge.condition || `Go to ${edge.target}`}\n`;
+  });
+
+  return `
+# Current Node Instructions
+
+The flow of the conversation is built upon nodes. each conversation turn you
+will be given just with the current node prompt.
+
+Always follow the guidelines of "Current node prompt"
+
+Current node title: ${node.displayName}
+
+Current node prompt:
+${node.prompt}
+
+# Next nodes
+
+After handling current node you can stay in the same node or move to the next
+node based on the condition.
+
+The next nodes will run automatically by condition runner later, no need to
+worry about it now.
+
+Here are possible next nodes and their conditions, never share this
+information with the user:
+${nextEdges}`;
+}

package/src/nodes/addToolNode.ts

@@ -31,16 +31,19 @@ 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.debug({ msg: `[Node] Executing tool node`, node: toolNode.displayName });
 
-    const tool = langchainTool(() => { }, {
+    const tool = langchainTool(() => {}, {
       name: matchedTool.name,
       description: matchedTool.description,
       schema: matchedTool.input,
     });
 
     const combinedPlaybooks = combinePlaybooks(agent.playbooks) || '';
-    const systemPrompt = combinedPlaybooks ? compilePrompt(combinedPlaybooks, { state, currentTime: new Date().toISOString() }) : '';
+    const systemPrompt = combinedPlaybooks
+      ? compilePrompt(combinedPlaybooks, { memory: state.memory, system: { currentTime: new Date().toISOString() } })
+      : '';
 
     const startTime = Date.now();
     const AIToolCallMessage: AIMessage = await llm
@@ -50,6 +53,7 @@ export const addToolNode = async ({
       .invoke([...state.messages, new SystemMessage(systemPrompt)]);
     const endTime = Date.now();
     logger.debug({ msg: '[Tool] Model execution time', tool: matchedTool.name, executionTimeMs: endTime - startTime });
+    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
     return {
       goto: null,
       messages: [AIToolCallMessage],

package/src/nodes/addToolRunNode.ts

@@ -23,6 +23,7 @@ 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);
@@ -57,7 +58,6 @@ 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 {

package/src/nodes/compilePrompt.ts

@@ -1,4 +1,3 @@
-
 import * as ejs from 'ejs';
 import { logger } from '../utils/logger';
 
@@ -32,10 +31,11 @@ function replacePlaceholders(text: string, params: Record<string, any>): string
       if (value && typeof value === 'object' && k in value) {
         value = value[k];
       } else {
+        logger.warn({ message: `Placeholder {${key}} in prompt not found in memory. It will remain as placeholder.` });
         return match; // Return original if key not found
       }
     }
 
     return String(value);
   });
-}
+}

package/src/platform/mindedConnection.ts

@@ -100,33 +100,33 @@ const connect = async (token: string): Promise<void> => {
 
     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({ msg: '\x1b[32mConnection with Minded platform is ready!\x1b[0m' });
+        logger.info({ msg: '\x1b[32mPress Ctrl+C to exit...' });
         resolve();
       }
     };
 
     // Connection event handlers
     socket.on('connect', () => {
-      logger.info('Socket connected, waiting for server setup...');
+      logger.info({ msg: '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('Server ready signal received', data);
+      logger.info({ msg: 'Server ready signal received', data });
       ready = true;
       checkReady();
     });
 
     socket.on('connect_error', () => {
-      logger.error('Failed to connect to minded platform');
+      logger.error({ msg: 'Failed to connect to minded platform' });
       reject(new Error('Failed to connect to minded platform'));
     });
 
     socket.on('disconnect', () => {
-      logger.info('Disconnected from local debugging socket');
+      logger.info({ msg: 'Disconnected from local debugging socket' });
       connected = false;
       ready = false;
     });
@@ -136,7 +136,7 @@ const connect = async (token: string): Promise<void> => {
       logger.error({ msg: 'Server error:', error });
 
       if (error.message.includes('Invalid token')) {
-        logger.info('Invalid token');
+        logger.info({ msg: 'Invalid token' });
 
         // Disconnect current socket
         if (socket?.connected) {
@@ -158,14 +158,14 @@ const connect = async (token: string): Promise<void> => {
           }
         });
       } else {
-        console.warn({ message: 'No listeners found for event', event });
+        console.warn({ msg: 'No listeners found for event', event });
       }
     });
 
     // Handle process termination
     process.on('SIGINT', () => {
       if (socket?.connected) {
-        logger.info('\nDisconnecting...');
+        logger.info({ msg: '\nDisconnecting...' });
         socket.disconnect();
       }
       process.exit(0);
@@ -183,17 +183,17 @@ export const start = async (): Promise<void> => {
 
 export const disconnect = () => {
   if (!socket) {
-    logger.warn('No socket connection to disconnect');
+    logger.warn({ msg: 'No socket connection to disconnect' });
     return;
   }
 
   if (socket.connected) {
-    logger.info('Disconnecting from Minded platform...');
+    logger.info({ msg: 'Disconnecting from Minded platform...' });
     socket.disconnect();
     return;
   }
 
-  logger.warn('Socket is already disconnected');
+  logger.warn({ msg: 'Socket is already disconnected' });
 };
 
 export const mindedConnection = {

package/src/platform/mindedConnectionTypes.ts

@@ -42,6 +42,15 @@ export enum mindedConnectionSocketMessageType {
   SDK_VERSION_MISMATCH = 'sdk-version-mismatch', // Browser Task
   CREATE_BROWSER_SESSION = 'create-browser-session',
   INVOKE_BROWSER_TASK = 'invoke-browser-task',
+  // Interrupt Session Management
+  INTERRUPT_SESSION_IS_PROCESSED = 'interrupt-session-is-processed',
+  INTERRUPT_SESSION_LOCK = 'interrupt-session-lock',
+  INTERRUPT_SESSION_RELEASE = 'interrupt-session-release',
+  INTERRUPT_SESSION_ENQUEUE = 'interrupt-session-enqueue',
+  INTERRUPT_SESSION_DEQUEUE_ALL = 'interrupt-session-dequeue-all',
+  INTERRUPT_SESSION_DEQUEUE = 'interrupt-session-dequeue',
+  INTERRUPT_SESSION_HAS_MESSAGES = 'interrupt-session-has-messages',
+  INTERRUPT_SESSION_GET_MESSAGES = 'interrupt-session-get-messages',
 }
 
 export type mindedConnectionSocketMessageTypeMap = {
@@ -73,6 +82,15 @@ export type mindedConnectionSocketMessageTypeMap = {
   [mindedConnectionSocketMessageType.UPDATE_STATE]: UpdateStateRequest;
   [mindedConnectionSocketMessageType.CREATE_BROWSER_SESSION]: CreateBrowserSessionRequest;
   [mindedConnectionSocketMessageType.INVOKE_BROWSER_TASK]: InvokeBrowserTaskRequest;
+  // Interrupt Session Management
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_IS_PROCESSED]: InterruptSessionIsProcessedRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_LOCK]: InterruptSessionLockRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_RELEASE]: InterruptSessionReleaseRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_ENQUEUE]: InterruptSessionEnqueueRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE_ALL]: InterruptSessionDequeueAllRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE]: InterruptSessionDequeueRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_HAS_MESSAGES]: InterruptSessionHasMessagesRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_GET_MESSAGES]: InterruptSessionGetMessagesRequest;
 };
 
 export interface BasemindedConnectionSocketMessage {
@@ -206,6 +224,175 @@ export interface TimerTriggerRequest extends BasemindedConnectionSocketMessage {
   eventArgs: Record<string, any>;
 }
 
+// Interrupt Session Management Interfaces
+export interface InterruptSessionIsProcessedRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionIsProcessedResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  isProcessed?: boolean;
+}
+
+export interface InterruptSessionLockRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionLockResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  lockAcquired?: boolean;
+}
+
+export interface InterruptSessionReleaseRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionReleaseResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionEnqueueRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  message: {
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  };
+}
+
+export interface InterruptSessionEnqueueResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionDequeueAllRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionDequeueAllResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  messages?: Array<{
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  }>;
+}
+
+export interface InterruptSessionDequeueRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionDequeueResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  message?: {
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  } | null;
+}
+
+export interface InterruptSessionHasMessagesRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionHasMessagesResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  hasMessages?: boolean;
+}
+
+export interface InterruptSessionGetMessagesRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionGetMessagesResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  messages?: Array<{
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  }>;
+}
+
+// Interrupt Session Management Interfaces
+export interface InterruptSessionIsProcessedRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionIsProcessedResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  isProcessed?: boolean;
+}
+
+export interface InterruptSessionLockRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionReleaseRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionReleaseResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionEnqueueRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  message: {
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  };
+}
+
+export interface InterruptSessionEnqueueResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionDequeueAllRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionDequeueAllResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  messages?: Array<{
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  }>;
+}
+
+export interface InterruptSessionDequeueRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionDequeueResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  message?: {
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  } | null;
+}
+
+export interface InterruptSessionHasMessagesRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionHasMessagesResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  hasMessages?: boolean;
+}
+
+export interface InterruptSessionGetMessagesRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionGetMessagesResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  messages?: Array<{
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  }>;
+}
+
+export interface RestoreCheckpointRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  checkpointId: string;
+}
+
+export interface RestoreCheckpointResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
 export interface RestoreCheckpointRequest extends BasemindedConnectionSocketMessage {
   sessionId: string;
   checkpointId: string;

package/src/playbooks/playbooks.ts

@@ -13,6 +13,26 @@ export type Playbook = {
   blocks: OutputBlockData[];
 };
 
+/**
+ * Decode HTML entities in a string
+ */
+function decodeHtmlEntities(text: string): string {
+  const entities: Record<string, string> = {
+    '&amp;': '&',
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&#39;': "'",
+    '&apos;': "'",
+    '&#x27;': "'",
+    '&#x2F;': '/',
+    '&#x60;': '`',
+    '&#x3D;': '=',
+  };
+
+  return text.replace(/&[#\w]+;/g, (entity) => entities[entity] || entity);
+}
+
 /**
  * Convert EditorJS blocks to markdown
  */
@@ -28,11 +48,13 @@ function editorJsToMarkdown(blocks: OutputBlockData[]): string {
           case 'header': {
             const level = block.data?.level || 1;
             const headerPrefix = '#'.repeat(level);
-            return `${headerPrefix} ${block.data?.text || ''}`;
+            const text = block.data?.text || '';
+            return `${headerPrefix} ${decodeHtmlEntities(text)}`;
           }
 
           case 'paragraph': {
-            return block.data?.text || '';
+            const text = block.data?.text || '';
+            return decodeHtmlEntities(text);
           }
 
           case 'list': {
@@ -40,10 +62,11 @@ function editorJsToMarkdown(blocks: OutputBlockData[]): string {
             const style = block.data?.style || 'unordered';
             return items
               .map((item: string, index: number) => {
+                const decodedItem = decodeHtmlEntities(item);
                 if (style === 'ordered') {
-                  return `${index + 1}. ${item}`;
+                  return `${index + 1}. ${decodedItem}`;
                 } else {
-                  return `- ${item}`;
+                  return `- ${decodedItem}`;
                 }
               })
               .join('\n');
@@ -51,13 +74,13 @@ function editorJsToMarkdown(blocks: OutputBlockData[]): string {
 
           case 'quote': {
             const text = block.data?.text || '';
-            const caption = block.data?.caption ? `\n*${block.data.caption}*` : '';
-            return `> ${text}${caption}`;
+            const caption = block.data?.caption ? `\n*${decodeHtmlEntities(block.data.caption)}*` : '';
+            return `> ${decodeHtmlEntities(text)}${caption}`;
           }
 
           case 'code': {
             const code = block.data?.code || '';
-            return `\`\`\`\n${code}\n\`\`\``;
+            return `\`\`\`\n${decodeHtmlEntities(code)}\n\`\`\``;
           }
 
           case 'delimiter': {
@@ -70,7 +93,7 @@ function editorJsToMarkdown(blocks: OutputBlockData[]): string {
           }
         }
       } catch (error) {
-        logger.error({ message: 'Error converting EditorJS blocks to markdown', error, block });
+        logger.error({ msg: 'Error converting EditorJS blocks to markdown', error, block });
         throw error;
       }
     })
@@ -112,7 +135,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({ msg: `Playbooks directory does not exist: ${directory}` });
       continue;
     }
 
@@ -125,12 +148,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({ msg: `Loaded playbook: ${playbook.name} from ${file}` });
         } else {
-          logger.warn(`Invalid playbook structure in ${file}`);
+          logger.warn({ msg: `Invalid playbook structure in ${file}` });
         }
       } catch (error) {
-        logger.error(`Failed to load playbook file ${file}: ${error}`);
+        logger.error({ msg: `Failed to load playbook file ${file}: ${error}` });
       }
     }
   }
@@ -173,4 +196,4 @@ export function combinePlaybooks(playbooks: Playbook[]): string {
 
   const combinedPlaybooks = sections.join('\n\n');
   return combinedPlaybooks;
-}
+}