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

package/src/agent.ts

@@ -304,9 +304,17 @@ 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 && nodes.length > 0) {
-      this.startingNodeId = nodes[0].name;
-      graph.addEdge('__start__', nodes[0].name as any);
+    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);
+      }
     } else {
       nodes.forEach((node) => {
         if (node.type === NodeType.TRIGGER && node.triggerType !== TriggerType.MANUAL) {
@@ -348,6 +356,7 @@ 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
@@ -421,7 +430,7 @@ export class Agent {
       // 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 });
+        logger.info({ msg: 'Enqueuing message', sessionId, triggerBody, triggerName, appName });
         await this.interruptSessionManager.enqueueMessage(sessionId, {
           triggerBody,
           triggerName,
@@ -458,7 +467,7 @@ export class Agent {
           const handlerResult = results.find((r) => r !== undefined);
           if (handlerResult) {
             if (!handlerResult.isQualified) {
-              logger.info({ message: `Trigger ${triggerName} was disqualified` });
+              logger.info({ message: '[Trigger] Disqualified', triggerName, triggerBody, sessionId });
               await this.interruptSessionManager.release(sessionId);
               return;
             }
@@ -469,7 +478,7 @@ export class Agent {
         }
       }
 
-      logger.info({ message: 'Invoking trigger', triggerName, sessionId, triggerBody });
+      logger.info({ msg: '[Trigger] Received', triggerName, triggerBody, sessionId });
       const langraphConfig = this.getLangraphConfig(sessionId || uuidv4());
       const state = await this.compiledGraph.getState(langraphConfig);
       const suffixes = Object.values(internalNodesSuffix);
@@ -478,7 +487,10 @@ export class Agent {
           ? state.values.overrideStartFromNodeId
             ? state.values.overrideStartFromNodeId
             : state.next[0]
-          : this.startingNodeId!;
+          : this.startingNodeId;
+      if (!nodeToBeInvoked) {
+        throw new Error('No node to be invoked');
+      }
       nodeToBeInvoked = nodeToBeInvoked.replace(new RegExp(suffixes.join('|'), 'g'), '');
       const historyStep = this.createTriggerHistoryStep(
         state.values.history,
@@ -543,7 +555,6 @@ export class Agent {
           langraphConfig,
         );
       }
-
       const nextMessage = await this.interruptSessionManager.dequeue(sessionId);
       if (nextMessage) {
         // Dequeue the first message and process it recursively
@@ -557,7 +568,7 @@ export class Agent {
         if (nextMessage.appName) {
           invokeParams.appName = nextMessage.appName;
         }
-        logger.info({ message: 'Invoking next message in the queue', invokeParams });
+        logger.info({ msg: 'Invoking next message in the queue', invokeParams });
         return await this.invoke(invokeParams);
       }
 
@@ -567,7 +578,7 @@ export class Agent {
       return res;
     } catch (error: any) {
       logger.error({
-        message: 'Invoke error',
+        msg: '[Trigger] Error',
         errorMessage: error.message,
         stack: error.stack,
         sessionId,
@@ -805,7 +816,7 @@ export class Agent {
     // Skip secret loading in local development
     const { runLocally } = getConfig();
     if (runLocally) {
-      logger.info({ message: 'Running locally - skipping secret loading' });
+      logger.debug({ msg: '[Agent] Secrets loaded from local .env file' });
       return {};
     }
     if (!mindedConnection.isConnected()) {
@@ -832,10 +843,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;
@@ -851,7 +862,7 @@ export class Agent {
   }
 
   private setupVoice(): void {
-    logger.info({ message: 'Setting up voice' });
+    logger.info('[Voice] Setting up voice');
     if (!mindedConnection.isConnected()) {
       throw new Error('Minded connection is required');
     }
@@ -874,7 +885,7 @@ export class Agent {
           voiceSession.sendAudio(audioMessage.audioData);
         } else {
           logger.trace({
-            message: 'Audio received; voice session not found for sessionId',
+            message: '[Voice] Audio received; voice session not found for sessionId',
             sessionId: audioMessage.sessionId,
             activeSessions: Array.from(this.voiceSessions.keys()),
           });
@@ -884,13 +895,13 @@ export class Agent {
       // Hangup / end session handler
       connection.on(mindedConnectionSocketMessageType.DASHBOARD_VOICE_SESSION_END, (message) => {
         const hangup = message as BaseVoiceMessage;
-        logger.debug({ message: 'Dashboard eneded voice session', sessionId: hangup.sessionId });
+        logger.debug({ msg: '[Voice] Dashboard eneded voice session', sessionId: hangup.sessionId });
         const voiceSession = this.voiceSessions.get(hangup.sessionId);
         if (voiceSession) {
           voiceSession.hangup();
         } else {
           logger.trace({
-            message: 'Session ended; voice session not found for sessionId',
+            message: '[Voice] Session ended; voice session not found for sessionId',
             sessionId: hangup.sessionId,
             activeSessions: this.voiceSessions.keys(),
           });
@@ -917,7 +928,8 @@ export class Agent {
       voiceId: voiceTrigger.voiceId,
     });
     await voiceSession.init();
-    logger.debug({ message: 'Voice session initialized', sessionId: params.sessionId });
+    logger.debug({ msg: '[Voice] Voice session initialized', sessionId: params.sessionId });
+
     this.voiceSessions.set(params.sessionId, voiceSession);
 
     // Emit voice session start event
@@ -945,7 +957,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({ message: 'Restoring checkpoint', sessionId, checkpointId });
+    logger.info({ msg: '[Agent]Restoring checkpoint', sessionId, checkpointId });
     const langraphConfig = this.getLangraphConfig(sessionId, checkpointId);
     await this.compiledGraph.invoke(
       new Command({

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);