@minded-ai/mindedjs 1.0.108 → 1.0.109

package/src/edges/createLogicalRouter.ts

@@ -1,12 +1,14 @@
 import { LogicalConditionEdge } from '../types/Flows.types';
 import { stateAnnotation } from '../types/LangGraph.types';
 import { logger } from '../utils/logger';
+import { Agent } from '../agent';
+import { AgentEvents } from '../events/AgentEvents';
 import * as vm from 'vm';
 
 // Default timeout for condition evaluation (in milliseconds)
 const CONDITION_TIMEOUT = 5000; // 5 seconds
 
-export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }) => {
+export const createLogicalRouter = ({ edges, agent }: { edges: LogicalConditionEdge[]; agent: Agent }) => {
   return async (state: typeof stateAnnotation.State) => {
     logger.debug({ msg: `[Router] Evaluating logical conditions for ${edges.length} edges` });
 
@@ -21,7 +23,19 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
 
     // First, evaluate all regular conditions
     for (const edge of regularEdges) {
+      const startTime = Date.now();
+
       try {
+        // Log condition start if in debug mode
+        logger.debug({ msg: '[LogicalCondition] Evaluating condition', edge, state });
+
+        // Emit ON_LOGICAL_CONDITION event
+        await agent.emit(AgentEvents.ON_LOGICAL_CONDITION, {
+          edge,
+          state,
+          condition: edge.condition,
+        });
+
         // Customer is responsible for providing valid JavaScript syntax
         // We execute their condition in a sandboxed VM with timeout protection
         const conditionCode = `
@@ -63,7 +77,28 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
           new Promise((_, reject) => setTimeout(() => reject(new Error('Condition execution timeout')), CONDITION_TIMEOUT)),
         ]);
 
-        if (result === true) {
+        const executionTime = Date.now() - startTime;
+        const booleanResult = result === true;
+
+        // Log condition result if in debug mode
+        logger.debug({
+          msg: '[LogicalCondition] Condition evaluated',
+          edge,
+          result: booleanResult,
+          executionTimeMs: executionTime,
+          nextNode: booleanResult ? edge.target : null,
+        });
+
+        // Emit ON_LOGICAL_CONDITION_RESULT event
+        await agent.emit(AgentEvents.ON_LOGICAL_CONDITION_RESULT, {
+          edge,
+          state,
+          condition: edge.condition,
+          result: booleanResult,
+          executionTimeMs: executionTime,
+        });
+
+        if (booleanResult) {
           if (edge.source == edge.target) {
             logger.info({ msg: `[Router] Stay at node ${edge.source}`, node: edge.source, condition: edge.condition });
           } else {
@@ -77,6 +112,9 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
           return edge.target;
         }
       } catch (error) {
+        const executionTime = Date.now() - startTime;
+        const errorObj = error instanceof Error ? error : new Error(String(error));
+
         // Provide detailed error information back to the customer
         const errorMessage = error instanceof Error ? error.message : String(error);
         const conditionPreview = edge.condition.length > 100 ? `${edge.condition.substring(0, 100)}...` : edge.condition;
@@ -89,6 +127,16 @@ export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }
           timeout: CONDITION_TIMEOUT,
         });
 
+        // Emit ON_LOGICAL_CONDITION_RESULT event with error
+        await agent.emit(AgentEvents.ON_LOGICAL_CONDITION_RESULT, {
+          edge,
+          state,
+          condition: edge.condition,
+          result: false,
+          executionTimeMs: executionTime,
+          error: errorObj,
+        });
+
         // Continue to next edge instead of failing completely
         // This allows other conditions to be evaluated even if one fails
         continue;

package/src/edges/edgeFactory.ts

@@ -55,7 +55,7 @@ export const edgeFactory = ({
 
       // Priority 2: Logical condition edges
       if (edgesBySource.logical.length > 0) {
-        const logicalRouter = createLogicalRouter({ edges: edgesBySource.logical });
+        const logicalRouter = createLogicalRouter({ edges: edgesBySource.logical, agent });
         const result = await logicalRouter(state);
         if (result) {
           return result;
@@ -67,7 +67,12 @@ export const edgeFactory = ({
       // Priority 3: Prompt condition edges
       if (edgesBySource.prompt.length > 0) {
         // Use the original node to check canStayOnNode property
-        const canStayInCurrentNode = originalNode?.canStayOnNode === true;
+        // For PROMPT_NODE: default to true when undefined
+        // For other types: default to false when undefined
+        let canStayInCurrentNode = originalNode?.canStayOnNode;
+        if (canStayInCurrentNode === undefined) {
+          canStayInCurrentNode = originalNode?.type === NodeType.PROMPT_NODE;
+        }
 
         const promptRouter = createPromptRouter({
           edges: edgesBySource.prompt,

package/src/events/AgentEvents.ts

@@ -1,13 +1,16 @@
 import { BaseMessage } from '@langchain/core/messages';
 import { HistoryStep } from '../types/Agent.types';
 import { State } from '../types/LangGraph.types';
+import { LogicalConditionEdge } from '../types/Flows.types';
 
 export enum AgentEvents {
   INIT = 'INIT',
   AI_MESSAGE = 'AI_MESSAGE',
   TRIGGER_EVENT = 'TRIGGER_EVENT',
   VOICE_SESSION_START = 'VOICE_SESSION_START',
-  ERROR = 'ERROR'
+  ERROR = 'ERROR',
+  ON_LOGICAL_CONDITION = 'ON_LOGICAL_CONDITION',
+  ON_LOGICAL_CONDITION_RESULT = 'ON_LOGICAL_CONDITION_RESULT',
 }
 
 export type AgentEventRequestPayloads<Memory> = {
@@ -30,6 +33,19 @@ export type AgentEventRequestPayloads<Memory> = {
     error: Error;
     state?: State<Memory>;
   };
+  [AgentEvents.ON_LOGICAL_CONDITION]: {
+    edge: LogicalConditionEdge;
+    state: State<Memory>;
+    condition: string;
+  };
+  [AgentEvents.ON_LOGICAL_CONDITION_RESULT]: {
+    edge: LogicalConditionEdge;
+    state: State<Memory>;
+    condition: string;
+    result: boolean;
+    executionTimeMs: number;
+    error?: Error;
+  };
 };
 
 export type AgentEventResponsePayloads<Memory> = {
@@ -44,4 +60,6 @@ export type AgentEventResponsePayloads<Memory> = {
   };
   [AgentEvents.VOICE_SESSION_START]: void;
   [AgentEvents.ERROR]: void;
+  [AgentEvents.ON_LOGICAL_CONDITION]: void;
+  [AgentEvents.ON_LOGICAL_CONDITION_RESULT]: void;
 };

package/src/index.ts

@@ -68,3 +68,7 @@ export { zendesk } from './interfaces/zendesk';
 
 // Export tools library
 export * as toolsLibrary from './toolsLibrary';
+
+// Export event types
+export { AgentEvents } from './events/AgentEvents';
+export type { AgentEventRequestPayloads, AgentEventResponsePayloads } from './events/AgentEvents';

package/src/internalTools/timer.ts

@@ -2,26 +2,29 @@ import * as mindedConnection from '../platform/mindedConnection';
 import { mindedConnectionSocketMessageType, TimerResetResponse, TimerCancelResponse } from '../platform/mindedConnectionTypes';
 
 // Store timer handlers by timer name
-export const timerHandlers = new Map<string, Array<{
-  handler: (params: { sessionId: string; payload: Record<string, any> }) => void | Promise<void>;
-}>>();
+export const timerHandlers = new Map<
+  string,
+  Array<{
+    handler: (params: { sessionId: string; payload: Record<string, any> }) => void | Promise<void>;
+  }>
+>();
 
 /**
  * Reset or set a timer for a specific session.
  * When the timer expires, all registered timer handlers will be called.
- * 
+ *
  * @param params - The timer configuration
  * @param params.sessionId - The session ID to associate the timer with
  * @param params.seconds - Number of seconds until the timer expires
  * @param params.timerName - Unique name for this timer (used for cancellation and identification)
- * @param params.eventArgs - Additional data to pass to the timer handler when it triggers
+ * @param params.payload - Additional data to pass to the timer handler when it triggers
  * @returns Promise resolving to timer reset response
  * @throws {Error} When the Minded connection is not established
- * 
+ *
  * @example
  * ```typescript
  * import { resetTimer } from '@minded-ai/mindedjs';
- * 
+ *
  * // Set a timer to follow up in 10 seconds
  * await resetTimer({
  *   sessionId: 'session-123',
@@ -37,7 +40,7 @@ export async function resetTimer({
   sessionId,
   seconds,
   timerName,
-  payload = {}
+  payload = {},
 }: {
   sessionId: string;
   seconds: number;
@@ -54,16 +57,16 @@ export async function resetTimer({
 
 /**
  * Cancel an existing timer for a specific session.
- * 
+ *
  * @param sessionId - The session ID the timer is associated with
  * @param timerName - The name of the timer to cancel
  * @returns Promise resolving to timer cancel response
  * @throws {Error} When the Minded connection is not established
- * 
+ *
  * @example
  * ```typescript
  * import { cancelTimer } from '@minded-ai/mindedjs';
- * 
+ *
  * // Cancel a previously set timer
  * await cancelTimer('session-123', 'followup');
  * ```
@@ -81,21 +84,21 @@ export async function cancelTimer(sessionId: string, timerName: string): Promise
 /**
  * Register a handler for timer trigger events for a specific timer name.
  * The handler will be called when the specified timer expires for any session.
- * 
+ *
  * @param params - The configuration for the timer handler
  * @param params.timerName - The name of the timer to handle
  * @param params.handler - Function to call when the timer triggers
- * 
+ *
  * @example
  * ```typescript
  * import { onTimer } from '@minded-ai/mindedjs';
- * 
+ *
  * // Register a handler for the 'followup' timer
  * onTimer({
  *   timerName: 'followup',
  *   handler: async ({ sessionId, payload }) => {
  *     console.log(`Followup timer triggered for session ${sessionId}`);
- *     
+ *
  *     // Handle the followup timer
  *     await agent.invoke({
  *       triggerName: 'timerFollowup',
@@ -108,7 +111,7 @@ export async function cancelTimer(sessionId: string, timerName: string): Promise
  */
 export function onTimer({
   timerName,
-  handler
+  handler,
 }: {
   timerName: string;
   handler: (params: { sessionId: string; payload: Record<string, any> }) => void | Promise<void>;
@@ -134,4 +137,4 @@ mindedConnection.on(mindedConnectionSocketMessageType.TIMER_TRIGGER, async (time
       payload: timerTriggerMessage.eventArgs,
     });
   }
-});
+});