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

package/src/agent.ts

@@ -26,6 +26,8 @@ import {
 import { createLlmInstance } from './llm/createLlmInstance';
 import { createCheckpointSaver } from './checkpointer/checkpointSaverFactory';
 import { getConfig } from './platform/config';
+import { InterruptSessionManager, InterruptType } from './interrupts/BaseInterruptSessionManager';
+import { createInterruptSessionManager } from './interrupts/interruptSessionManagerFactory';
 import { BaseMessage, HumanMessage } from '@langchain/core/messages';
 import triggerTypeToDefaultMessage from './triggers/triggerTypeToDefaultMessage';
 import appActionRunnerToolCreator from './internalTools/appActionRunnerTool';
@@ -43,6 +45,7 @@ type CreateAgentParams<Memory> = {
   tools: Tool<any, Memory>[];
   platformToken?: string;
   memorySaver?: BaseCheckpointSaver;
+  interruptSessionManager?: InterruptSessionManager;
 };
 
 /**
@@ -75,6 +78,8 @@ export class Agent {
 
   // Langgraph memory saver. In memory for local development, Custom for Platform
   private checkpointer!: BaseCheckpointSaver;
+  // Interrupt session manager. In memory for local development, Custom for Platform
+  public interruptSessionManager!: InterruptSessionManager;
   // Langgraph compiled graph
   public compiledGraph!: CompiledGraph;
   // Cache for secrets to avoid repeated API calls
@@ -145,7 +150,7 @@ export class Agent {
 
   private async init(params: CreateAgentParams<z.infer<typeof this.memorySchema>>): Promise<void> {
     try {
-      const { config, tools, memorySaver } = params;
+      const { config, tools, memorySaver, interruptSessionManager } = params;
       const { runLocally } = getConfig();
       if (!runLocally) {
         await mindedConnection.start();
@@ -178,6 +183,7 @@ export class Agent {
       const appActionsRunnerTools = this.initAppActionsRunnerTools();
       this.tools = [...tools, ...appActionsRunnerTools];
       this.checkpointer = memorySaver || createCheckpointSaver();
+      this.interruptSessionManager = interruptSessionManager || createInterruptSessionManager();
 
       // call here methods that needs environment variables to be loaded
       this.llm = createLlmInstance(config.llm);
@@ -298,17 +304,9 @@ export class Agent {
 
     // Add edge from start to first node if no triggers exist
     const hasTrigger = nodes.some((node) => node.type === NodeType.TRIGGER && node.triggerType !== TriggerType.MANUAL);
-    if (!hasTrigger) {
-      // Find the Main flow
-      const mainFlow = this.flows.find((flow) => flow.name === 'Main flow');
-      if (mainFlow && mainFlow.nodes.length > 0) {
-        this.startingNodeId = mainFlow.nodes[0].name;
-        graph.addEdge('__start__', mainFlow.nodes[0].name as any);
-      } else if (nodes.length > 0) {
-        // Fallback to first node if Main flow not found
-        this.startingNodeId = nodes[0].name;
-        graph.addEdge('__start__', nodes[0].name as any);
-      }
+    if (!hasTrigger && nodes.length > 0) {
+      this.startingNodeId = nodes[0].name;
+      graph.addEdge('__start__', nodes[0].name as any);
     } else {
       nodes.forEach((node) => {
         if (node.type === NodeType.TRIGGER && node.triggerType !== TriggerType.MANUAL) {
@@ -350,7 +348,6 @@ export class Agent {
       sessionId: state.sessionId || uuidv4(), // Preserve existing sessionId or generate new one
       sessionType: state.sessionType || SessionType.TEXT,
       overrideStartFromNodeId: null,
-      goto: null,
     };
 
     // Emit INIT event with the initial state
@@ -416,10 +413,24 @@ export class Agent {
    * });
    * ```
    */
-  public async invoke({ triggerBody, triggerName, sessionId, appName }: AgentInvokeParams) {
+  public async invoke({ triggerBody, triggerName, sessionId, appName, bypassSessionCheck }: AgentInvokeParams): Promise<any> {
     sessionId = sessionId ?? uuidv4();
     try {
       await this.waitForInitialization();
+
+      // Try to acquire lock atomically (unless bypassing session check)
+      if (!bypassSessionCheck && !(await this.interruptSessionManager.lock(sessionId))) {
+        // Could not acquire lock, session is being processed - enqueue the message
+        logger.info({ message: 'Enqueuing message', sessionId, triggerBody, triggerName, appName });
+        await this.interruptSessionManager.enqueueMessage(sessionId, {
+          triggerBody,
+          triggerName,
+          appName,
+        });
+        return;
+      }
+      // Session lock acquired, proceed with processing
+
       let messages: Array<BaseMessage> = [];
       let memoryUpdate = {};
       let sessionType: SessionType = SessionType.TEXT;
@@ -447,7 +458,8 @@ export class Agent {
           const handlerResult = results.find((r) => r !== undefined);
           if (handlerResult) {
             if (!handlerResult.isQualified) {
-              logger.debug({ msg: '[Trigger] Disqualified', triggerName, triggerBody, sessionId });
+              logger.info({ message: `Trigger ${triggerName} was disqualified` });
+              await this.interruptSessionManager.release(sessionId);
               return;
             }
             memoryUpdate = handlerResult.memory || {};
@@ -457,7 +469,7 @@ export class Agent {
         }
       }
 
-      logger.info({ msg: '[Trigger] Received', triggerName, triggerBody, sessionId });
+      logger.info({ message: 'Invoking trigger', triggerName, sessionId, triggerBody });
       const langraphConfig = this.getLangraphConfig(sessionId || uuidv4());
       const state = await this.compiledGraph.getState(langraphConfig);
       const suffixes = Object.values(internalNodesSuffix);
@@ -479,13 +491,37 @@ export class Agent {
 
       let res;
       // Resume interruption
-      if (state.tasks?.[0]?.interrupts?.length > 0) {
-        res = await this.compiledGraph.invoke(
-          new Command({
-            resume: { memory: memoryUpdate, messages, history: historyStep, sessionId, sessionType },
-          }),
-          langraphConfig,
-        );
+      if (state.tasks?.[state.tasks.length - 1]?.interrupts?.length > 0) {
+        const lastTask = state.tasks[state.tasks.length - 1];
+        const interrupt = lastTask.interrupts[0];
+        const interruptValue = (interrupt as any).value;
+
+        if (interruptValue?.type === InterruptType.HUMAN_IN_THE_LOOP) {
+          // For HUMAN_IN_THE_LOOP, use resume with the full object
+          res = await this.compiledGraph.invoke(
+            new Command({
+              resume: { memory: memoryUpdate, messages, history: historyStep, sessionId, sessionType, overrideStartFromNodeId: null },
+            }),
+            langraphConfig,
+          );
+        } else if (interruptValue?.type === InterruptType.NEW_TRIGGERS) {
+          // For NEW_TRIGGERS, check if there's an updateStateObject to apply first
+          const finalState = { memory: memoryUpdate, messages, history: [historyStep], sessionId, sessionType };
+          if (interruptValue.updateStateObject) {
+            finalState.messages = [...interruptValue.updateStateObject.messages, ...messages];
+            finalState.history = [...(interruptValue.updateStateObject.history || []), historyStep];
+            //add handlers for other state fields as needed
+          }
+
+          // Then use update with the full object and empty resume
+          res = await this.compiledGraph.invoke(
+            new Command({
+              update: finalState,
+              resume: '',
+            }),
+            langraphConfig,
+          );
+        }
       } else if (state.values.overrideStartFromNodeId) {
         res = await this.compiledGraph.invoke(
           new Command({
@@ -507,14 +543,39 @@ export class Agent {
           langraphConfig,
         );
       }
+
+      const nextMessage = await this.interruptSessionManager.dequeue(sessionId);
+      if (nextMessage) {
+        // Dequeue the first message and process it recursively
+        // Recursively process the next message with bypass flag
+        const invokeParams: AgentInvokeParams = {
+          triggerBody: nextMessage.triggerBody,
+          triggerName: nextMessage.triggerName,
+          sessionId: sessionId,
+          bypassSessionCheck: true,
+        };
+        if (nextMessage.appName) {
+          invokeParams.appName = nextMessage.appName;
+        }
+        logger.info({ message: 'Invoking next message in the queue', invokeParams });
+        return await this.invoke(invokeParams);
+      }
+
+      // Release the session lock
+      await this.interruptSessionManager.release(sessionId);
+
       return res;
     } catch (error: any) {
       logger.error({
-        msg: '[Trigger] Error',
+        message: 'Invoke error',
         errorMessage: error.message,
         stack: error.stack,
         sessionId,
       });
+
+      // Release the session lock on error
+      await this.interruptSessionManager.release(sessionId);
+
       const state = await this.compiledGraph.getState(this.getLangraphConfig(sessionId));
       this.emit(AgentEvents.ERROR, { error: error instanceof Error ? error : new Error(JSON.stringify(error)), state: state.values });
       throw error;
@@ -744,7 +805,7 @@ export class Agent {
     // Skip secret loading in local development
     const { runLocally } = getConfig();
     if (runLocally) {
-      logger.debug({ msg: '[Agent] Secrets loaded from local .env file' });
+      logger.info({ message: 'Running locally - skipping secret loading' });
       return {};
     }
     if (!mindedConnection.isConnected()) {
@@ -771,10 +832,10 @@ export class Agent {
       const secrets = response.secrets || {};
 
       // Load secrets into process.env
+      logger.debug(`Loading ${Object.keys(secrets).length} secrets into environment variables`);
       Object.entries(secrets).forEach(([key, value]) => {
         process.env[key] = value;
       });
-      logger.debug(`[Agent] Loaded ${Object.keys(secrets).length} secrets from platform`);
 
       // Cache the secrets for future requests
       this.secretsCache = secrets;
@@ -790,7 +851,7 @@ export class Agent {
   }
 
   private setupVoice(): void {
-    logger.info('[Voice] Setting up voice');
+    logger.info({ message: 'Setting up voice' });
     if (!mindedConnection.isConnected()) {
       throw new Error('Minded connection is required');
     }
@@ -813,7 +874,7 @@ export class Agent {
           voiceSession.sendAudio(audioMessage.audioData);
         } else {
           logger.trace({
-            message: '[Voice] Audio received; voice session not found for sessionId',
+            message: 'Audio received; voice session not found for sessionId',
             sessionId: audioMessage.sessionId,
             activeSessions: Array.from(this.voiceSessions.keys()),
           });
@@ -823,13 +884,13 @@ export class Agent {
       // Hangup / end session handler
       connection.on(mindedConnectionSocketMessageType.DASHBOARD_VOICE_SESSION_END, (message) => {
         const hangup = message as BaseVoiceMessage;
-        logger.debug({ message: '[Voice] Dashboard eneded voice session', sessionId: hangup.sessionId });
+        logger.debug({ message: 'Dashboard eneded voice session', sessionId: hangup.sessionId });
         const voiceSession = this.voiceSessions.get(hangup.sessionId);
         if (voiceSession) {
           voiceSession.hangup();
         } else {
           logger.trace({
-            message: '[Voice] Session ended; voice session not found for sessionId',
+            message: 'Session ended; voice session not found for sessionId',
             sessionId: hangup.sessionId,
             activeSessions: this.voiceSessions.keys(),
           });
@@ -856,7 +917,7 @@ export class Agent {
       voiceId: voiceTrigger.voiceId,
     });
     await voiceSession.init();
-    logger.debug({ message: '[Voice] Voice session initialized', sessionId: params.sessionId });
+    logger.debug({ message: 'Voice session initialized', sessionId: params.sessionId });
     this.voiceSessions.set(params.sessionId, voiceSession);
 
     // Emit voice session start event
@@ -884,7 +945,7 @@ export class Agent {
    To be used by the Lambda wrapper to restore checkpoints
   */
   public async restoreCheckpoint(sessionId: string, checkpointId: string): Promise<void> {
-    logger.info({ msg: '[Agent]Restoring checkpoint', sessionId, checkpointId });
+    logger.info({ message: 'Restoring checkpoint', sessionId, checkpointId });
     const langraphConfig = this.getLangraphConfig(sessionId, checkpointId);
     await this.compiledGraph.invoke(
       new Command({

package/src/checkpointer/checkpointSaverFactory.ts

@@ -13,6 +13,6 @@ export function createCheckpointSaver(): BaseCheckpointSaver {
     return new MemorySaver();
   }
 
-  logger.debug('[Agent] Using remote checkpoint saver');
+  logger.debug('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(`Created ${envPath} and added token`);
+    logger.info({ message: `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(`Updated MINDED_CONNECTION_TOKEN in ${envPath}`);
+      logger.info({ message: `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(`Added MINDED_CONNECTION_TOKEN to ${envPath}`);
+      logger.info({ message: `Added MINDED_CONNECTION_TOKEN to ${envPath}` });
     }
   }
 }
@@ -44,7 +44,7 @@ function generateLambdaHandler(): void {
 
   // Check if minded.json exists
   if (!fs.existsSync(mindedConfigPath)) {
-    logger.error('minded.json not found in the current directory');
+    logger.error({ message: '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('Failed to read or parse minded.json:', error);
+    logger.error({ message: 'Failed to read or parse minded.json:', error });
     process.exit(1);
   }
 
   // Get the agent path
   const agentPath = mindedConfig.agent;
   if (!agentPath) {
-    logger.error('No agent path found in minded.json');
+    logger.error({ message: 'No agent path found in minded.json' });
     process.exit(1);
   }
 
@@ -91,7 +91,7 @@ function generateLambdaHandler(): void {
   }
 
   if (!templateContent) {
-    logger.error('Could not find Lambda handler template file');
+    logger.error({ message: '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(`Generated Lambda handler at ${outputPath}`);
+    logger.info({ message: `Generated Lambda handler at ${outputPath}` });
 
     // Compile the index.ts file using TypeScript
-    logger.info('Compiling the Lambda handler...');
+    logger.info({ message: 'Compiling the Lambda handler...' });
 
     try {
       // Read tsconfig.json to get the outDir
@@ -138,7 +138,7 @@ function generateLambdaHandler(): void {
         cwd: process.cwd(),
       });
 
-      logger.info(`Successfully compiled Lambda handler to ${outDir}/index.js`);
+      logger.info({ message: `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('Please provide a token');
+      logger.error({ message: 'Please provide a token' });
       process.exit(1);
     }
     setToken(token);
   } else if (command === 'generate-lambda-ts-handler') {
     generateLambdaHandler();
   } else {
-    logger.error('Unknown command. Available commands: token, generate-lambda-ts-handler');
+    logger.error({ message: 'Unknown command. Available commands: token, generate-lambda-ts-handler' });
     process.exit(1);
   }
 }

package/src/edges/createDirectEdge.ts

@@ -1,16 +1,11 @@
 import { StepForwardEdge } from '../types/Flows.types';
-import { stateAnnotation } from '../types/LangGraph.types';
 import { logger } from '../utils/logger';
 
 export const createDirectEdge = (edge: StepForwardEdge) => {
-  return async (state: typeof stateAnnotation.State) => {
-    if (state.goto) {
-      console.log('Jumping to node', state.goto);
-      return state.goto;
-    }
+  return async () => {
     // For direct edges, we just return the target of the first edge
     // since there's no conditional logic needed
-    logger.info({ msg: `[Router] Direct edge`, target: edge.target });
+    logger.info({ message: `Executing edge ${JSON.stringify(edge)}` });
     return edge.target;
   };
 };

package/src/edges/createLogicalRouter.ts

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

package/src/edges/createPromptRouter.ts

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

package/src/edges/edgeFactory.ts

@@ -1,14 +1,4 @@
-import {
-  Edge,
-  EdgeType,
-  Node,
-  PromptConditionEdge,
-  LogicalConditionEdge,
-  StepForwardEdge,
-  NodeType,
-  ToolNode,
-  BrowserTaskNode,
-} from '../types/Flows.types';
+import { Edge, EdgeType, Node, PromptConditionEdge, LogicalConditionEdge, StepForwardEdge, NodeType, ToolNode } from '../types/Flows.types';
 import { PreCompiledGraph } from '../types/LangGraph.types';
 import { BaseLanguageModel } from '@langchain/core/language_models/base';
 import { createPromptRouter } from './createPromptRouter';
@@ -16,7 +6,6 @@ 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';
@@ -50,7 +39,7 @@ export const edgeFactory = ({
       // Priority 1: Step forward edge (max 1)
       if (edgesBySource.stepForward) {
         const directRouter = createDirectEdge(edgesBySource.stepForward);
-        return await directRouter(state);
+        return await directRouter();
       }
 
       // Priority 2: Logical condition edges
@@ -60,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' });
         }
       }
 
@@ -80,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;
     };
   };
@@ -103,11 +92,6 @@ 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,12 +7,6 @@ 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';