@minded-ai/mindedjs 1.0.108 → 1.0.109-beta-1

package/src/edges/createPromptRouter.ts

@@ -1,218 +0,0 @@
-import { z } from 'zod';
-import { PromptConditionEdge } from '../types/Flows.types';
-import { BaseLanguageModel } from '@langchain/core/language_models/base';
-import { SystemMessage } from '@langchain/core/messages';
-import { stateAnnotation } from '../types/LangGraph.types';
-import { logger } from '../utils/logger';
-
-const ROUTER_PROMPT = `
-You are a routing agent that decides which node to take in a flow based on the current state.
-Based on the conversation history and memory state, you should classify the next step for the conversation.
-Each step has a nodeId and a condition. You should decide to move to the right step based on the condition.
-
-Here are the available options and their conditions:
-{steps}
-
-Current memory state:
-{memory}
-
-Recent messages:
-{messages}
-
-You MUST respond with the exact nodeId from the options above. Do not use step numbers or any other identifiers.
-
-You should output the result in the following JSON format:
-{
-    "nextNodeId": "exact_node_name_from_options_above",
-    "reasoning": "I think the next step should be exact_node_name_from_options_above because of the following reasons: ..."
-}
-
-Return JSON and nothing more.
-`;
-
-const ROUTER_PROMPT_WITHOUT_REASONING = `
-You are a routing agent that decides which node to take in a flow based on the current state.
-Based on the conversation history and memory state, you should classify the next step for the conversation.
-Each step has a nodeId and a condition. You should decide to move to the right step based on the condition.
-
-Here are the available options and their conditions:
-{steps}
-
-Current memory state:
-{memory}
-
-Recent messages:
-{messages}
-
-You MUST respond with the exact nodeId from the options above. Do not use step numbers or any other identifiers.
-
-You should output the result in the following JSON format:
-{
-    "nextNodeId": "exact_node_name_from_options_above"
-}
-
-Return JSON and nothing more.
-`;
-
-export const createPromptRouter = ({
-  edges,
-  llm,
-  includeReasoning = true,
-  maxRetries = 3,
-  canStayInCurrentNode = false,
-  currentNodeName,
-}: {
-  edges: PromptConditionEdge[];
-  llm: BaseLanguageModel;
-  includeReasoning?: boolean;
-  maxRetries?: number;
-  canStayInCurrentNode?: boolean;
-  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;
-    }
-
-    // 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,
-      });
-      return currentNodeName;
-    }
-
-    // Prepare the steps string
-    let stepsStr = '';
-
-    // Add "stay in current node" option if enabled
-    if (canStayInCurrentNode && currentNodeName) {
-      stepsStr = `- Node: "${currentNodeName}" (stay in current node)\n`;
-    }
-
-    // Add the edge options
-    stepsStr += edges.map((edge) => `- Node: "${edge.target}" - Condition: "${edge.prompt}"`).join('\n');
-
-    // Prepare recent messages (last 10 messages for context)
-    const recentMessages = state.messages.slice(-10);
-    const messagesStr = recentMessages
-      .map((msg) => {
-        const role = msg._getType();
-        const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
-        return `${role}: ${content}`;
-      })
-      .join('\n');
-
-    // Select prompt based on reasoning preference
-    let routerPrompt = includeReasoning ? ROUTER_PROMPT : ROUTER_PROMPT_WITHOUT_REASONING;
-
-    // Replace placeholders in prompt
-    routerPrompt = routerPrompt
-      .replace('{steps}', stepsStr)
-      .replace('{memory}', JSON.stringify(state.memory, null, 2))
-      .replace('{messages}', messagesStr);
-
-    // Define response schema
-    const responseSchema = includeReasoning
-      ? z.object({
-          nextNodeId: z.string(),
-          reasoning: z.string(),
-        })
-      : z.object({
-          nextNodeId: z.string(),
-        });
-
-    let attempts = 0;
-    let lastError: Error | null = null;
-
-    while (attempts < maxRetries) {
-      try {
-        attempts++;
-
-        // Create messages for the LLM
-        const messages = [new SystemMessage(routerPrompt)];
-
-        // If this is a retry, add the error message
-        if (lastError) {
-          messages.push(
-            new SystemMessage(`Previous attempt failed with error: ${lastError.message}. Please provide a valid JSON response.`),
-          );
-        }
-
-        // Call the LLM with structured output
-        const response = await llm.invoke(messages);
-
-        // Extract content from response
-        let content = '';
-        if (typeof response.content === 'string') {
-          content = response.content;
-        } else if (response.content && typeof response.content === 'object' && 'text' in response.content) {
-          content = (response.content as any).text;
-        }
-
-        // Try to parse JSON from the response
-        let parsedResponse;
-        try {
-          // Clean the response - remove markdown code blocks if present
-          content = content
-            .replace(/```json\n?/g, '')
-            .replace(/```\n?/g, '')
-            .trim();
-          parsedResponse = JSON.parse(content);
-        } catch {
-          throw new Error(`Failed to parse JSON response: ${content}`);
-        }
-
-        // Validate the response
-        const validatedResponse = responseSchema.parse(parsedResponse);
-
-        // Check if the selected node is valid
-        const validTargets = edges.map((e) => e.target);
-        if (canStayInCurrentNode && currentNodeName) {
-          validTargets.push(currentNodeName);
-        }
-
-        if (!validTargets.includes(validatedResponse.nextNodeId)) {
-          throw new Error(`Invalid nextNodeId: ${validatedResponse.nextNodeId}. Must be one of: ${validTargets.join(', ')}`);
-        }
-
-        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 });
-
-        return validatedResponse.nextNodeId;
-      } catch (error) {
-        lastError = error instanceof Error ? error : new Error(String(error));
-        logger.warn({
-          msg: `[Router] Prompt router attempt ${attempts} failed`,
-          error: lastError.message,
-          attempt: attempts,
-          maxRetries,
-        });
-
-        if (attempts >= maxRetries) {
-          // 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',
-            fallbackNode,
-            lastError: lastError.message,
-          });
-
-          if (!fallbackNode) {
-            throw new Error('No edges available for routing');
-          }
-
-          return fallbackNode;
-        }
-      }
-    }
-
-    // This should never be reached, but TypeScript needs it
-    throw new Error('Unexpected error in prompt router');
-  };
-};

package/src/edges/edgeFactory.ts

@@ -1,141 +0,0 @@
-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';
-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';
-
-type EdgesBySource = {
-  stepForward?: StepForwardEdge;
-  logical: LogicalConditionEdge[];
-  prompt: PromptConditionEdge[];
-};
-
-export const edgeFactory = ({
-  graph,
-  edges,
-  nodes,
-  tools,
-  llm,
-  agent,
-}: {
-  graph: PreCompiledGraph;
-  edges: Edge[];
-  nodes: Record<string, Node>;
-  tools: Tool<any, any>[];
-  llm: BaseLanguageModel;
-  agent: Agent;
-}) => {
-  /**
-   * Creates a combined router that handles edge priority: step forward > logical > prompt
-   */
-  const createCombinedRouter = (sourceNode: string, edgesBySource: EdgesBySource, originalNode: Node) => {
-    return async (state: any) => {
-      // Priority 1: Step forward edge (max 1)
-      if (edgesBySource.stepForward) {
-        const directRouter = createDirectEdge(edgesBySource.stepForward);
-        return await directRouter(state);
-      }
-
-      // Priority 2: Logical condition edges
-      if (edgesBySource.logical.length > 0) {
-        const logicalRouter = createLogicalRouter({ edges: edgesBySource.logical });
-        const result = await logicalRouter(state);
-        if (result) {
-          return result;
-        } else {
-          logger.debug('No logical conditions matched, continuing to prompt conditions');
-        }
-      }
-
-      // Priority 3: Prompt condition edges
-      if (edgesBySource.prompt.length > 0) {
-        // Use the original node to check canStayOnNode property
-        const canStayInCurrentNode = originalNode?.canStayOnNode === true;
-
-        const promptRouter = createPromptRouter({
-          edges: edgesBySource.prompt,
-          llm,
-          canStayInCurrentNode,
-          currentNodeName: originalNode?.name || sourceNode,
-        });
-        return await promptRouter(state);
-      }
-
-      // Fallback: stay at current source node
-      const source = originalNode?.name || sourceNode;
-      logger.info(`No conditions matched, returning to source: ${source}`);
-      return source;
-    };
-  };
-
-  /**
-   * Processes all edges for a specific source node with enhanced capabilities
-   */
-  const processEdgesForNode = (source: string, edgesBySource: EdgesBySource): void => {
-    let effectiveSource = source;
-    const originalNode = nodes[source];
-
-    // Handle human-in-the-loop enhancement
-    if (originalNode?.humanInTheLoop) {
-      addHumanInTheLoopNode({ graph, attachedToNodeName: source });
-      effectiveSource = buildHumanInTheLoopNodeName(source);
-    }
-
-    if (originalNode?.type === NodeType.TOOL) {
-      addToolRunNode({ graph, tools, llm, toolNode: originalNode as ToolNode, attachedToNodeName: source, agent });
-      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);
-  };
-
-  // Get all unique source nodes and categorize their edges in a single pass
-  const edgesBySource = edges.reduce((acc, edge) => {
-    if (!acc[edge.source]) {
-      acc[edge.source] = {
-        stepForward: undefined,
-        logical: [],
-        prompt: [],
-      };
-    }
-
-    if (edge.type === EdgeType.STEP_FORWARD) {
-      acc[edge.source].stepForward = edge as StepForwardEdge;
-    } else if (edge.type === EdgeType.LOGICAL_CONDITION) {
-      acc[edge.source].logical.push(edge as LogicalConditionEdge);
-    } else if (edge.type === EdgeType.PROMPT_CONDITION) {
-      acc[edge.source].prompt.push(edge as PromptConditionEdge);
-    }
-
-    return acc;
-  }, {} as Record<string, EdgesBySource>);
-
-  // Process edges for each source node
-  Object.entries(edgesBySource).forEach(([source, categorizedEdges]) => {
-    processEdgesForNode(source, categorizedEdges);
-  });
-};

package/src/events/AgentEvents.ts

@@ -1,47 +0,0 @@
-import { BaseMessage } from '@langchain/core/messages';
-import { HistoryStep } from '../types/Agent.types';
-import { State } from '../types/LangGraph.types';
-
-export enum AgentEvents {
-  INIT = 'INIT',
-  AI_MESSAGE = 'AI_MESSAGE',
-  TRIGGER_EVENT = 'TRIGGER_EVENT',
-  VOICE_SESSION_START = 'VOICE_SESSION_START',
-  ERROR = 'ERROR'
-}
-
-export type AgentEventRequestPayloads<Memory> = {
-  [AgentEvents.INIT]: {
-    state: State<Memory>;
-  };
-  [AgentEvents.AI_MESSAGE]: {
-    message: string;
-    state: State<Memory>;
-  };
-  [AgentEvents.TRIGGER_EVENT]: {
-    triggerName: string;
-    triggerBody: any;
-    sessionId?: string;
-  };
-  [AgentEvents.VOICE_SESSION_START]: {
-    sessionId: string;
-  };
-  [AgentEvents.ERROR]: {
-    error: Error;
-    state?: State<Memory>;
-  };
-};
-
-export type AgentEventResponsePayloads<Memory> = {
-  [AgentEvents.INIT]: void;
-  [AgentEvents.AI_MESSAGE]: void;
-  [AgentEvents.TRIGGER_EVENT]: {
-    isQualified: boolean;
-    messages?: BaseMessage[];
-    memory?: Memory;
-    history?: HistoryStep[];
-    sessionId?: string;
-  };
-  [AgentEvents.VOICE_SESSION_START]: void;
-  [AgentEvents.ERROR]: void;
-};

package/src/events/index.ts

@@ -1,3 +0,0 @@
-import { AgentEvents } from './AgentEvents';
-
-export default AgentEvents;

package/src/index.ts

@@ -1,70 +0,0 @@
-import { Agent } from './agent';
-import events from './events';
-import { logger } from './utils/logger';
-import { sendPlaceholderMessage } from './internalTools/sendPlaceholderMessage';
-import { resetTimer, cancelTimer, onTimer } from './internalTools/timer';
-import { retellCall, retellGetCall } from './internalTools/retell';
-
-export type { ElevenLabsContext } from './types/Voice.types';
-export { Agent, events, logger, sendPlaceholderMessage, resetTimer, cancelTimer, onTimer, retellCall, retellGetCall };
-
-// 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';
-
-export type {
-  Flow,
-  Node,
-  Edge,
-  TriggerNode,
-  AppTriggerNode,
-  PromptNode,
-  PromptConditionEdge,
-  LogicalConditionEdge,
-  StepForwardEdge,
-  ManualTriggerNode,
-  JunctionNode,
-  ToolNode,
-  AppToolNode,
-  VoiceTriggerNode,
-  WebhookTriggerNode,
-} from './types/Flows.types';
-export {
-  NodeType,
-  TriggerType,
-  EdgeType,
-  AppNodeMetadata,
-  AppNodeMetadataType,
-  NodeMetadata,
-  KnownTriggerNames,
-} from './types/Flows.types';
-export type { Tool, ToolExecuteInput } from './types/Tools.types';
-
-// Document processing utilities
-export { DocumentProcessor, extractFromDocument } from './internalTools/documentExtraction/documentExtraction';
-export type {
-  DocumentProcessorConfig,
-  DocumentExtractionOptions,
-  DocumentProcessingResult,
-} from './internalTools/documentExtraction/types';
-
-export {
-  HistoryStep,
-  TriggerHistoryStep,
-  AppActionInvocationHistoryStep,
-  AppTriggerHistoryStep,
-  CustomActionInvocationHistoryStep,
-  SessionType,
-} from './types/Agent.types';
-export type { AgentInvokeParams, MindedSDKConfig } from './types/Agent.types';
-export type { Environment } from './types/Platform.types';
-export type { State } from './types/LangGraph.types';
-export { zendesk } from './interfaces/zendesk';
-
-// Export tools library
-export * as toolsLibrary from './toolsLibrary';

package/src/interfaces/zendesk.ts

@@ -1,157 +0,0 @@
-import { Agent } from '../agent';
-import * as mindedConnection from '../platform/mindedConnection';
-import { mindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
-
-export const zendesk = {
-  agent: null as Agent | null,
-  init: async (agent: Agent) => {
-    zendesk.agent = agent;
-  },
-
-  sendMessage: async (sessionId: string, message: string) => {
-    if (!mindedConnection.isConnected()) return;
-    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
-      interfaceName: 'zendesk',
-      sessionId,
-      functionName: 'sendMessage',
-      functionArgs: { message },
-    });
-  },
-
-  sendComment: async (sessionId: string, comment: string) => {
-    if (!mindedConnection.isConnected()) return;
-    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
-      interfaceName: 'zendesk',
-      sessionId,
-      functionName: 'sendComment',
-      functionArgs: { comment },
-    });
-  },
-
-  sendPublicComment: async (sessionId: string, comment: string) => {
-    if (!mindedConnection.isConnected()) return;
-    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
-      interfaceName: 'zendesk',
-      sessionId,
-      functionName: 'sendPublicComment',
-      functionArgs: { comment },
-    });
-  },
-
-  getConversation: async (sessionId: string) => {
-    if (!mindedConnection.isConnected()) return;
-    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
-      interfaceName: 'zendesk',
-      sessionId,
-      functionName: 'getConversation',
-      functionArgs: {},
-    });
-  },
-
-  getConversationMessages: async (sessionId: string) => {
-    if (!mindedConnection.isConnected()) return;
-    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
-      interfaceName: 'zendesk',
-      sessionId,
-      functionName: 'getConversationMessages',
-      functionArgs: {},
-    });
-  },
-
-  addTag: async (sessionId: string, tag: string) => {
-    if (!mindedConnection.isConnected()) return;
-    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
-      interfaceName: 'zendesk',
-      sessionId,
-      functionName: 'addTag',
-      functionArgs: { tag },
-    });
-  },
-
-  getTicket: async (sessionId: string) => {
-    if (!mindedConnection.isConnected()) return;
-    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
-      interfaceName: 'zendesk',
-      sessionId,
-      functionName: 'getTicket',
-      functionArgs: {
-        sessionId,
-      },
-    });
-  },
-
-  createTicket: async ({
-    sessionId,
-    subject,
-    ticketBody,
-    priority,
-    tags,
-    customFields,
-  }: {
-    sessionId: string;
-    subject: string;
-    ticketBody: string;
-    priority: string;
-    tags: string[];
-    customFields: any[];
-  }) => {
-    if (!mindedConnection.isConnected()) return;
-    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
-      interfaceName: 'zendesk',
-      sessionId,
-      functionName: 'createTicket',
-      functionArgs: { subject, ticketBody, priority, tags, customFields },
-    });
-  },
-  markTicketAsSolved: async ({ sessionId }: { sessionId: string }) => {
-    if (!mindedConnection.isConnected()) return;
-    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
-      interfaceName: 'zendesk',
-      sessionId,
-      functionName: 'markTicketAsSolved',
-      functionArgs: { sessionId },
-    });
-  },
-
-  markTicketAsOpen: async ({ sessionId }: { sessionId: string }) => {
-    if (!mindedConnection.isConnected()) return;
-    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
-      interfaceName: 'zendesk',
-      sessionId,
-      functionName: 'markTicketAsOpen',
-      functionArgs: { sessionId },
-    });
-  },
-
-  setCustomFields: async ({ sessionId, fields }: { sessionId: string; fields: any[] }) => {
-    if (!mindedConnection.isConnected()) return;
-    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
-      interfaceName: 'zendesk',
-      sessionId,
-      functionName: 'setCustomFields',
-      functionArgs: { sessionId, fields },
-    });
-  },
-
-  search: async ({ sessionId, query }: { sessionId: string; query: string }) => {
-    if (!mindedConnection.isConnected()) return;
-    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
-      interfaceName: 'zendesk',
-      sessionId,
-      functionName: 'search',
-      functionArgs: { query },
-    });
-  },
-};