@minded-ai/mindedjs 1.0.103-beta-1 → 1.0.103-beta-4

package/src/browserTask/executeBrowserTask.ts

@@ -0,0 +1,213 @@
+import { logger } from '../utils/logger';
+
+// Browser Use Cloud API configuration
+const BROWSER_USE_API_BASE_URL = 'https://api.browser-use.com/api/v1';
+
+// Types for Browser Use Cloud API
+export interface CloudTaskResponse {
+  id: string;
+  status: string;
+  live_url?: string;
+  steps?: any[];
+  output?: string;
+}
+
+// Browser Use Cloud API methods
+export const createCloudTask = async (prompt: string, model?: string): Promise<string> => {
+  const apiKey = process.env.BROWSER_USE_API_KEY;
+  if (!apiKey) {
+    throw new Error('BROWSER_USE_API_KEY environment variable is required');
+  }
+
+  logger.debug({ msg: 'Creating cloud browser task', prompt: prompt.substring(0, 100) + '...' });
+
+  const response = await fetch(`${BROWSER_USE_API_BASE_URL}/run-task`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      task: prompt,
+      use_proxy: false,
+      llm_model: model || 'gpt-4o',
+    }),
+  });
+
+  if (!response.ok) {
+    logger.error({ msg: 'Failed to create cloud browser task', status: response.status, statusText: response.statusText });
+    throw new Error(`Failed to create browser task: ${response.statusText}`);
+  }
+
+  const data = await response.json();
+  logger.debug({ msg: 'Cloud browser task created', taskId: data.id });
+  return data.id;
+};
+
+export const getTaskDetails = async (taskId: string): Promise<CloudTaskResponse> => {
+  const apiKey = process.env.BROWSER_USE_API_KEY;
+  if (!apiKey) {
+    throw new Error('BROWSER_USE_API_KEY environment variable is required');
+  }
+
+  const response = await fetch(`${BROWSER_USE_API_BASE_URL}/task/${taskId}`, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+    },
+  });
+
+  if (!response.ok) {
+    logger.error({ msg: 'Failed to get task details', taskId, status: response.status, statusText: response.statusText });
+    throw new Error(`Failed to get task details: ${response.statusText}`);
+  }
+
+  return response.json();
+};
+
+export const waitForLiveUrl = async (taskId: string, maxWaitTime: number = 30000): Promise<CloudTaskResponse> => {
+  const startTime = Date.now();
+  const pollInterval = 2000; // 2 seconds
+  let pollCount = 0;
+
+  logger.debug({ msg: 'Starting to poll for live_url', taskId, maxWaitTime, pollInterval });
+
+  while (Date.now() - startTime < maxWaitTime) {
+    pollCount++;
+    const elapsedTime = Date.now() - startTime;
+
+    logger.trace({
+      msg: 'Polling for live_url',
+      taskId,
+      pollCount,
+      elapsedTime,
+      remainingTime: maxWaitTime - elapsedTime,
+    });
+
+    const taskDetails = await getTaskDetails(taskId);
+
+    logger.trace({
+      msg: 'Task details received',
+      taskId,
+      status: taskDetails.status,
+      hasLiveUrl: !!taskDetails.live_url,
+      pollCount,
+    });
+
+    if (taskDetails.live_url) {
+      logger.debug({
+        msg: 'Live URL available',
+        taskId,
+        liveUrl: taskDetails.live_url,
+        pollCount,
+        totalTime: elapsedTime,
+      });
+      return taskDetails;
+    }
+
+    if (taskDetails.status === 'failed' || taskDetails.status === 'stopped') {
+      logger.error({
+        msg: 'Task failed while waiting for live_url',
+        taskId,
+        status: taskDetails.status,
+        pollCount,
+        elapsedTime,
+      });
+      throw new Error(`Task failed with status: ${taskDetails.status}`);
+    }
+
+    logger.trace({
+      msg: 'Live URL not yet available, continuing to poll',
+      taskId,
+      status: taskDetails.status,
+      pollCount,
+      nextPollIn: pollInterval,
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+  }
+
+  logger.error({
+    msg: 'Timeout waiting for live_url',
+    taskId,
+    pollCount,
+    totalTime: Date.now() - startTime,
+    maxWaitTime,
+  });
+  throw new Error('Timeout waiting for live_url to become available');
+};
+
+export const waitForCompletion = async (taskId: string, maxWaitTime: number = 300000): Promise<CloudTaskResponse> => {
+  const startTime = Date.now();
+  const pollInterval = 3000; // 3 seconds for completion polling
+  let pollCount = 0;
+
+  logger.debug({ msg: 'Starting to poll for task completion', taskId, maxWaitTime, pollInterval });
+
+  while (Date.now() - startTime < maxWaitTime) {
+    pollCount++;
+    const elapsedTime = Date.now() - startTime;
+
+    logger.trace({
+      msg: 'Polling for task completion',
+      taskId,
+      pollCount,
+      elapsedTime,
+      remainingTime: maxWaitTime - elapsedTime,
+    });
+
+    const taskDetails = await getTaskDetails(taskId);
+
+    logger.trace({
+      msg: 'Task completion status received',
+      taskId,
+      status: taskDetails.status,
+      pollCount,
+      hasOutput: !!taskDetails.output,
+      stepCount: taskDetails.steps?.length || 0,
+    });
+
+    if (taskDetails.status === 'finished') {
+      logger.debug({
+        msg: 'Task completed successfully',
+        taskId,
+        pollCount,
+        totalTime: elapsedTime,
+        stepCount: taskDetails.steps?.length || 0,
+        hasOutput: !!taskDetails.output,
+      });
+      return taskDetails;
+    }
+
+    if (taskDetails.status === 'failed' || taskDetails.status === 'stopped') {
+      logger.error({
+        msg: 'Task failed during completion polling',
+        taskId,
+        status: taskDetails.status,
+        pollCount,
+        elapsedTime,
+        stepCount: taskDetails.steps?.length || 0,
+      });
+      throw new Error(`Task failed with status: ${taskDetails.status}`);
+    }
+
+    logger.trace({
+      msg: 'Task still in progress, continuing to poll',
+      taskId,
+      status: taskDetails.status,
+      pollCount,
+      stepCount: taskDetails.steps?.length || 0,
+      nextPollIn: pollInterval,
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+  }
+
+  logger.error({
+    msg: 'Timeout waiting for task completion',
+    taskId,
+    pollCount,
+    totalTime: Date.now() - startTime,
+    maxWaitTime,
+  });
+  throw new Error('Timeout waiting for task completion');
+};

package/src/checkpointer/checkpointSaverFactory.ts

@@ -13,6 +13,6 @@ export function createCheckpointSaver(): BaseCheckpointSaver {
     return new MemorySaver();
   }
 
-  logger.debug('Using remote checkpoint saver');
+  logger.debug('[Agent] Using remote checkpoint saver');
   return new MindedCheckpointSaver();
 }

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({ msg: `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({ msg: `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({ msg: `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({ msg: '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({ msg: '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({ msg: '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({ msg: '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({ msg: `Generated Lambda handler at ${outputPath}` });
 
     // Compile the index.ts file using TypeScript
-    logger.info({ message: 'Compiling the Lambda handler...' });
+    logger.info({ msg: 'Compiling the Lambda handler...' });
 
     try {
       // Read tsconfig.json to get the outDir
@@ -138,12 +138,12 @@ function generateLambdaHandler(): void {
         cwd: process.cwd(),
       });
 
-      logger.info({ message: `Successfully compiled Lambda handler to ${outDir}/index.js` });
+      logger.info({ msg: `Successfully compiled Lambda handler to ${outDir}/index.js` });
     } catch (compileError) {
-      logger.error({ message: 'Failed to compile Lambda handler', error: compileError });
+      logger.error({ msg: 'Failed to compile Lambda handler', error: compileError });
     }
   } catch (error) {
-    logger.error({ message: 'Failed to generate Lambda handler', error: error });
+    logger.error({ msg: 'Failed to generate Lambda handler', error: error });
     process.exit(1);
   }
 }
@@ -155,14 +155,14 @@ function main() {
   if (command === 'token') {
     const token = args[1];
     if (!token) {
-      logger.error({ message: 'Please provide a token' });
+      logger.error({ msg: '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({ msg: 'Unknown command. Available commands: token, generate-lambda-ts-handler' });
     process.exit(1);
   }
 }

package/src/edges/createDirectEdge.ts

@@ -1,11 +1,16 @@
 import { StepForwardEdge } from '../types/Flows.types';
+import { stateAnnotation } from '../types/LangGraph.types';
 import { logger } from '../utils/logger';
 
 export const createDirectEdge = (edge: StepForwardEdge) => {
-  return async () => {
+  return async (state: typeof stateAnnotation.State) => {
+    if (state.goto) {
+      console.log('Jumping to node', state.goto);
+      return state.goto;
+    }
     // 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({ msg: `[Router] Direct edge`, target: edge.target });
     return edge.target;
   };
 };

package/src/edges/createLogicalRouter.ts

@@ -8,7 +8,12 @@ const CONDITION_TIMEOUT = 5000; // 5 seconds
 
 export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }) => {
   return async (state: typeof stateAnnotation.State) => {
-    logger.debug(`Evaluating logical conditions for ${edges.length} edges`);
+    logger.debug({ msg: `[Router] Evaluating logical conditions for ${edges.length} edges` });
+
+    if (state.goto) {
+      console.log('Jumping to node', state.goto);
+      return state.goto;
+    }
 
     // Separate regular conditions from "else" conditions
     const regularEdges = edges.filter((edge) => edge.condition.trim() !== 'else');
@@ -59,7 +64,16 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
         ]);
 
         if (result === true) {
-          logger.info({ message: `Condition matched for edge ${edge.source} → ${edge.target}` });
+          if (edge.source == edge.target) {
+            logger.info({ msg: `[Router] Stay at node ${edge.source}`, node: edge.source, condition: edge.condition });
+          } else {
+            logger.info({
+              msg: `[Router] Logical condition matched`,
+              transitionFrom: edge.source,
+              transitionTo: edge.target,
+              condition: edge.condition,
+            });
+          }
           return edge.target;
         }
       } catch (error) {
@@ -68,7 +82,7 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
         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: `[Router] Error evaluating condition for edge ${edge.source} → ${edge.target}`,
           condition: conditionPreview,
           error: errorMessage,
           edgeIndex: edges.indexOf(edge),
@@ -83,15 +97,18 @@ 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)` });
       // 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({
+        msg: `[Router] Else condition matched`,
+        transitionFrom: elseEdge.source,
+        transitionTo: 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({ msg: `[Router] Stay at node ${edges[0].source}, no conditions matched`, node: edges[0].source });
     return null;
   };
 };

package/src/edges/createPromptRouter.ts

@@ -70,11 +70,19 @@ export const createPromptRouter = ({
   currentNodeName?: string;
 }) => {
   return async (state: typeof stateAnnotation.State) => {
-    logger.info({ message: `Executing prompt router. Edges: ${JSON.stringify(edges)}` });
+    logger.debug({ msg: `[Router] Executing prompt router`, edges: JSON.stringify(edges) });
+
+    if (state.goto) {
+      console.log('Jumping to node', state.goto);
+      return state.goto;
+    }
 
     // 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({
+        msg: `[Router] Stay at node, No edges available and canStayInCurrentNode==true`,
+        node: currentNodeName,
+      });
       return currentNodeName;
     }
 
@@ -174,14 +182,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.debug({ 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,
+          msg: `[Router] Prompt router attempt ${attempts} failed`,
           error: lastError.message,
           attempt: attempts,
           maxRetries,
@@ -191,7 +198,7 @@ export const createPromptRouter = ({
           // If all retries failed, return the first available edge as fallback
           const fallbackNode = edges[0]?.target;
           logger.error({
-            message: 'Prompt router reached max retries, using fallback',
+            msg: '[Router] Prompt router reached max retries, using fallback',
             fallbackNode,
             lastError: lastError.message,
           });

package/src/edges/edgeFactory.ts

@@ -1,4 +1,14 @@
-import { Edge, EdgeType, Node, PromptConditionEdge, LogicalConditionEdge, StepForwardEdge, NodeType, ToolNode } from '../types/Flows.types';
+import {
+  Edge,
+  EdgeType,
+  Node,
+  PromptConditionEdge,
+  LogicalConditionEdge,
+  StepForwardEdge,
+  NodeType,
+  ToolNode,
+  BrowserTaskNode,
+} from '../types/Flows.types';
 import { PreCompiledGraph } from '../types/LangGraph.types';
 import { BaseLanguageModel } from '@langchain/core/language_models/base';
 import { createPromptRouter } from './createPromptRouter';
@@ -6,6 +16,7 @@ import { createLogicalRouter } from './createLogicalRouter';
 import { createDirectEdge } from './createDirectEdge';
 import { addHumanInTheLoopNode, buildHumanInTheLoopNodeName } from '../nodes/addHumanInTheLoopNode';
 import { addToolRunNode, buildToolRunNodeName } from '../nodes/addToolRunNode';
+import { addBrowserTaskRunNode, buildBrowserTaskRunNodeName } from '../nodes/addBrowserTaskRunNode';
 import { Tool } from '../types/Tools.types';
 import { Agent } from '../agent';
 import { logger } from '../utils/logger';
@@ -39,7 +50,7 @@ export const edgeFactory = ({
       // Priority 1: Step forward edge (max 1)
       if (edgesBySource.stepForward) {
         const directRouter = createDirectEdge(edgesBySource.stepForward);
-        return await directRouter();
+        return await directRouter(state);
       }
 
       // Priority 2: Logical condition edges
@@ -49,7 +60,7 @@ export const edgeFactory = ({
         if (result) {
           return result;
         } else {
-          logger.debug({ message: 'No logical conditions matched, continuing to prompt conditions' });
+          logger.debug({ msg: 'No logical conditions matched, continuing to prompt conditions' });
         }
       }
 
@@ -69,7 +80,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({ msg: `No conditions matched, returning to source: ${source}` });
       return source;
     };
   };
@@ -92,6 +103,11 @@ export const edgeFactory = ({
       effectiveSource = buildToolRunNodeName(source);
     }
 
+    if (originalNode?.type === NodeType.BROWSER_TASK) {
+      addBrowserTaskRunNode({ graph, browserTaskNode: originalNode as BrowserTaskNode, attachedToNodeName: source, agent });
+      effectiveSource = buildBrowserTaskRunNodeName(source);
+    }
+
     // Create and add the combined conditional edge with original node reference
     const combinedRouter = createCombinedRouter(effectiveSource, edgesBySource, originalNode);
     graph.addConditionalEdges(effectiveSource as any, combinedRouter);

package/src/index.ts

@@ -7,6 +7,12 @@ import { resetTimer, cancelTimer, onTimer } from './internalTools/timer';
 export type { ElevenLabsContext } from './types/Voice.types';
 export { Agent, events, logger, sendPlaceholderMessage, resetTimer, cancelTimer, onTimer };
 
+// Export LLM implementations
+export { MindedChatOpenAI } from './platform/models/mindedChatOpenAI';
+export { createParallelWrapper } from './platform/models/parallelWrapper';
+export type { MindedChatOpenAIFields, BaseParallelChatFields } from './platform/models/mindedChatOpenAI';
+export type { BaseParallelChatFields as ParallelWrapperFields } from './platform/models/parallelWrapper';
+
 // HTTP module for PII masking - only public API
 export type { PIIGatewayInstance, HttpRequestConfig, HttpResponse } from './platform/piiGateway';
 

package/src/interrupts/BaseInterruptSessionManager.ts

@@ -41,6 +41,8 @@ export interface InterruptSessionManager {
   dequeueAll(sessionId: string): QueuedMessage[] | Promise<QueuedMessage[]>;
   dequeue(sessionId: string): QueuedMessage | null | Promise<QueuedMessage | null>;
   checkQueueAndInterrupt(sessionId: string, updateStateObject?: Partial<State>): Promise<boolean>;
+  interrupt(sessionId: string): void | Promise<void>;
+  isInterrupted(sessionId: string): boolean | Promise<boolean>;
 }
 
 export abstract class BaseInterruptSessionManager implements InterruptSessionManager {
@@ -59,7 +61,8 @@ export abstract class BaseInterruptSessionManager implements InterruptSessionMan
   abstract enqueueMessage(sessionId: string, message: QueuedMessage): void | Promise<void>;
   abstract dequeueAll(sessionId: string): QueuedMessage[] | Promise<QueuedMessage[]>;
   abstract dequeue(sessionId: string): QueuedMessage | null | Promise<QueuedMessage | null>;
-
+  abstract interrupt(sessionId: string): void | Promise<void>;
+  abstract isInterrupted(sessionId: string): boolean | Promise<boolean>;
   // Abstract method to check if queue has messages - this is the only queue-specific part
   protected abstract hasQueuedMessages(sessionId: string): boolean | Promise<boolean>;
   protected abstract getQueuedMessages(sessionId: string): QueuedMessage[] | Promise<QueuedMessage[]>;
@@ -67,7 +70,7 @@ export abstract class BaseInterruptSessionManager implements InterruptSessionMan
   // Common implementation of checkQueueAndInterrupt
   async checkQueueAndInterrupt(sessionId: string, updateStateObject?: Partial<State>): Promise<boolean> {
     if (await this.hasQueuedMessages(sessionId)) {
-      logger.trace({ message: 'graph has queued messagess, interrupting graph', sessionId });
+      logger.trace({ msg: 'graph has queued messagess, interrupting graph', sessionId });
 
       // Interrupt the graph with NEW_TRIGGERS flag and optional updateStateObject
       const interruptPayload: InterruptPayload = { type: InterruptType.NEW_TRIGGERS };

package/src/interrupts/MemoryInterruptSessionManager.ts

@@ -4,6 +4,14 @@ export class MemoryInterruptSessionManager extends BaseInterruptSessionManager {
   private sessionProcessing: Map<string, boolean> = new Map();
   private sessionMessageQueues: Map<string, QueuedMessage[]> = new Map();
 
+  interrupt(sessionId: string): void {
+    this.sessionProcessing.set(sessionId, true);
+  }
+
+  isInterrupted(sessionId: string): boolean {
+    return this.sessionProcessing.get(sessionId) || false;
+  }
+
   isProcessed(sessionId: string): boolean {
     return this.sessionProcessing.get(sessionId) || false;
   }

package/src/interrupts/MindedInterruptSessionManager.ts

@@ -88,6 +88,31 @@ export class MindedInterruptSessionManager extends BaseInterruptSessionManager {
     }
   }
 
+  async isInterrupted(sessionId: string): Promise<boolean> {
+    try {
+      const response = await mindedConnection.awaitEmit<any, any>(mindedConnectionSocketMessageType.INTERRUPT_SESSION_IS_INTERRUPTED, {
+        type: mindedConnectionSocketMessageType.INTERRUPT_SESSION_IS_INTERRUPTED,
+        sessionId,
+      });
+      return response.isInterrupted ?? false;
+    } catch (error) {
+      console.error('Error checking if session is interrupted:', error);
+      return false;
+    }
+  }
+
+  async interrupt(sessionId: string): Promise<void> {
+    try {
+      await mindedConnection.awaitEmit<any, any>(mindedConnectionSocketMessageType.INTERRUPT_SESSION_INTERRUPT, {
+        type: mindedConnectionSocketMessageType.INTERRUPT_SESSION_INTERRUPT,
+        sessionId,
+      });
+    } catch (error) {
+      console.error('Error interrupting session:', error);
+      throw error;
+    }
+  }
+
   async dequeueAll(sessionId: string): Promise<QueuedMessage[]> {
     try {
       const response = await mindedConnection.awaitEmit<InterruptSessionDequeueAllRequest, InterruptSessionDequeueAllResponse>(

package/src/interrupts/interruptSessionManagerFactory.ts

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

package/src/llm/createLlmInstance.ts

@@ -1,4 +1,5 @@
-import { LLMConfig, LLMProviders, LLMProvider } from "../types/LLM.types";
+import { LLMConfig, LLMProviders, LLMProvider } from '../types/LLM.types';
+import { createParallelWrapper, BaseParallelChatFields } from '../platform/models/parallelWrapper';
 
 export const createLlmInstance = (llmConfig: LLMConfig) => {
   const { name, properties } = llmConfig;
@@ -6,5 +7,27 @@ export const createLlmInstance = (llmConfig: LLMConfig) => {
   if (!LLMClass) {
     throw new Error(`Unsupported LLM provider: ${name}`);
   }
-  return new LLMClass(properties);
+
+  // Create the base LLM instance
+  const llmInstance = new LLMClass(properties);
+
+  // Check if parallel configuration is present
+  const hasParallelConfig = properties.numParallelRequests && properties.numParallelRequests > 1;
+
+  // For MindedChatOpenAI, parallel functionality is handled on the backend
+  if (name === 'MindedChatOpenAI') {
+    return llmInstance;
+  }
+
+  // For other LLM providers, apply client-side parallel wrapper if configured
+  if (hasParallelConfig) {
+    const parallelOptions: BaseParallelChatFields = {
+      numParallelRequests: properties.numParallelRequests,
+      logTimings: properties.logTimings,
+    };
+
+    return createParallelWrapper(llmInstance, parallelOptions);
+  }
+
+  return llmInstance;
 };