@minded-ai/mindedjs 1.0.96 → 1.0.97-beta-1235

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,51 +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';
-
-export type { ElevenLabsContext } from './types/Voice.types';
-export { Agent, events, logger, sendPlaceholderMessage, resetTimer, cancelTimer, onTimer };
-
-// 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';
-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';

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

package/src/internalTools/appActionRunnerTool.ts

@@ -1,75 +0,0 @@
-import * as mindedConnection from '../platform/mindedConnection';
-import { mindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
-import { ActionInputParam } from '../types/Flows.types';
-import { Tool, ToolExecuteInput } from '../types/Tools.types';
-import { z } from 'zod';
-
-const typeToZodMap = {
-  string: z.string(),
-  number: z.number(),
-  boolean: z.boolean(),
-  array: z.array(z.any()),
-  object: z.record(z.any()),
-  any: z.any(),
-} as const;
-
-const convertToZodSchema = (schema: Record<string, { type: string; example?: any }>) => {
-  const zodSchema: Record<string, z.ZodType> = {};
-  for (const [key, { type }] of Object.entries(schema)) {
-    const zodType = typeToZodMap[type.toLowerCase() as keyof typeof typeToZodMap] ?? z.string();
-    zodSchema[key] = zodType;
-  }
-  return z.object(zodSchema);
-};
-
-const createdTools: Record<string, Tool<any, any>> = {};
-
-const appActionRunnerToolCreator = (schema: ActionInputParam[], nodeTitle: string): Tool<any, any> => {
-  const zodSchema = convertToZodSchema(
-    schema.reduce((acc, param) => {
-      if (param.required) {
-        acc[param.name] = { type: param.type, example: param.example };
-      }
-      return acc;
-    }, {} as Record<string, { type: string; example?: any }>),
-  );
-  // Create a description that includes examples
-  const description = `Run ${nodeTitle} action. Example input: ${JSON.stringify(
-    schema.reduce((acc, param) => {
-      if (param.example !== undefined) {
-        acc[param.name] = param.example;
-      }
-      return acc;
-    }, {} as Record<string, any>),
-    null,
-    2,
-  )}`;
-
-  const tool = {
-    name: nodeTitle,
-    description,
-    input: zodSchema,
-    execute: async ({ input, state }: ToolExecuteInput<typeof zodSchema>) => {
-      const response = await mindedConnection.awaitEmit(
-        mindedConnectionSocketMessageType.OnAppAction,
-        {
-          nodeTitle,
-          actionInput: input,
-        },
-        20000,
-      );
-      return {
-        state,
-        result: response as { result?: any },
-      };
-    },
-  };
-  createdTools[nodeTitle] = tool;
-  return tool;
-};
-
-export const getAppActionRunnerTool = (nodeTitle: string) => {
-  return createdTools[nodeTitle];
-};
-
-export default appActionRunnerToolCreator;

package/src/internalTools/sendPlaceholderMessage.ts

@@ -1,27 +0,0 @@
-import * as mindedConnection from '../platform/mindedConnection';
-import { mindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
-
-/**
- * Send a placeholder message to the dashboard voice session.
- * This is typically used for voice sessions to provide immediate feedback to users.
- * 
- * @param params - The parameters for sending the placeholder message
- * @param params.sessionId - The session ID of the voice session
- * @param params.message - The placeholder message to send
- * @throws {Error} When the Minded connection is not established
- */
-export async function sendPlaceholderMessage(params: { sessionId: string; message: string }): Promise<void> {
-  const { sessionId, message } = params;
-
-  if (!mindedConnection.isConnected()) {
-    throw new Error('Minded connection is not established when trying to send placeholder message');
-  }
-
-  const connection = mindedConnection;
-  connection.emit(mindedConnectionSocketMessageType.DASHBOARD_VOICE_PLACEHOLDER_MESSAGES, {
-    sessionId,
-    message,
-    timestamp: Date.now(),
-    type: mindedConnectionSocketMessageType.DASHBOARD_VOICE_PLACEHOLDER_MESSAGES,
-  });
-} 

package/src/internalTools/timer.ts

@@ -1,137 +0,0 @@
-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>;
-}>>();
-
-/**
- * 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
- * @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',
- *   seconds: 10,
- *   timerName: 'followup',
- *   payload: {
- *     message: 'Are you still there?'
- *   }
- * });
- * ```
- */
-export async function resetTimer({
-  sessionId,
-  seconds,
-  timerName,
-  payload = {}
-}: {
-  sessionId: string;
-  seconds: number;
-  timerName: string;
-  payload?: Record<string, any>;
-}): Promise<TimerResetResponse> {
-  return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.TIMER_RESET, {
-    sessionId,
-    seconds,
-    timerName,
-    eventArgs: payload,
-  });
-}
-
-/**
- * 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');
- * ```
- */
-export async function cancelTimer(sessionId: string, timerName: string): Promise<TimerCancelResponse> {
-  if (!mindedConnection.isConnected()) {
-    throw new Error('Minded connection is not established when trying to cancel timer');
-  }
-  return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.TIMER_CANCEL, {
-    sessionId,
-    timerName,
-  });
-}
-
-/**
- * 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',
- *       triggerBody: { message: payload.message },
- *       sessionId
- *     });
- *   }
- * });
- * ```
- */
-export function onTimer({
-  timerName,
-  handler
-}: {
-  timerName: string;
-  handler: (params: { sessionId: string; payload: Record<string, any> }) => void | Promise<void>;
-}): void {
-  // Initialize handlers array for this timer name if it doesn't exist
-  if (!timerHandlers.has(timerName)) {
-    timerHandlers.set(timerName, []);
-  }
-
-  // Add the handler to the array for this timer name
-  const handlers = timerHandlers.get(timerName)!;
-  handlers.push({ handler });
-}
-
-mindedConnection.on(mindedConnectionSocketMessageType.TIMER_TRIGGER, async (timerTriggerMessage) => {
-  // Get handlers for the specific timer name
-  const handlers = timerHandlers.get(timerTriggerMessage.timerName) || [];
-
-  // Call all handlers registered for this timer name
-  for (const { handler } of handlers) {
-    await handler({
-      sessionId: timerTriggerMessage.sessionId,
-      payload: timerTriggerMessage.eventArgs,
-    });
-  }
-});

package/src/llm/createLlmInstance.ts

@@ -1,10 +0,0 @@
-import { LLMConfig, LLMProviders, LLMProvider } from "../types/LLM.types";
-
-export const createLlmInstance = (llmConfig: LLMConfig) => {
-  const { name, properties } = llmConfig;
-  const LLMClass = LLMProviders[name as LLMProvider];
-  if (!LLMClass) {
-    throw new Error(`Unsupported LLM provider: ${name}`);
-  }
-  return new LLMClass(properties);
-};

package/src/nodes/addAppToolNode.ts

@@ -1,95 +0,0 @@
-import { AppToolNode, NodeType } from '../types/Flows.types';
-import { tool as langchainTool } from '@langchain/core/tools';
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { SystemMessage } from '@langchain/core/messages';
-import { RunnableLike } from '@langchain/core/runnables';
-import { z } from 'zod';
-import { LLMProviders } from '../types/LLM.types';
-import { getAppActionRunnerTool } from '../internalTools/appActionRunnerTool';
-import { AppActionInvocationHistoryStep } from '../types/Agent.types';
-import { Agent } from '../agent';
-import { logger } from '../utils/logger';
-import { compilePlaybooks } from '../playbooks/playbooks';
-import { createHistoryStep } from '../utils/history';
-
-export const addAppToolNode = async ({
-  graph,
-  node,
-  llm,
-  agent,
-}: {
-  graph: PreCompiledGraph;
-  node: AppToolNode;
-  llm: (typeof LLMProviders)[keyof typeof LLMProviders];
-  agent: Agent;
-}) => {
-  const cleanedParameters = Object.fromEntries(Object.entries(node.parameters || {}).filter(([, value]) => value !== ''));
-  const appRunnerTool = getAppActionRunnerTool(node.displayName!);
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing tool node ${appRunnerTool.name}`);
-
-    const executeWrapper = async (input: z.infer<typeof appRunnerTool.input>) => {
-      try {
-        const response = await appRunnerTool.execute({ input, state, agent });
-        return response || {};
-      } catch (error) {
-        logger.error({ msg: 'Error executing tool', error });
-        throw error;
-      }
-    };
-    const tool = langchainTool(executeWrapper, {
-      name: appRunnerTool.name,
-      description: appRunnerTool.description,
-      schema: appRunnerTool.input,
-    });
-    // Get compiled playbooks with proper parameters
-    const playbookParams = {
-      ...state.memory, // Spread memory fields at the top level
-    };
-    const compiledPlaybooks = compilePlaybooks(agent.playbooks, playbookParams) || '';
-
-    const message = `${compiledPlaybooks ? compiledPlaybooks + '\n\n' : ''}
-    Additional context:
-    previous messages are available for context.
-    Your goal is execute the tool with the correct parameters, some of them already chosen by the user and the rest should be generated.
-    You have 4 things to base your parameters on:
-    - Previous messages
-    - Parameters manually configured by the user (if any)
-    - User instructions for choosing tool parameters that are not set by the user (if any)
-    - Workflow memory
-    Parameters manually configured by the user are:
-    ${JSON.stringify(cleanedParameters)}
-    User instructions for choosing tool parameters are:
-        ${node.prompt ? `${node.prompt}` : 'no instructions set by the user'}
-        Workflow memory is:
-        ${JSON.stringify(state.memory)}
-        `;
-    const AIToolCallMessage = await llm
-      .bindTools([tool], {
-        tool_choice: tool.name,
-      })
-      .invoke([...state.messages, new SystemMessage(message)]);
-    AIToolCallMessage.tool_calls[0].args = {
-      ...AIToolCallMessage.tool_calls[0].args,
-      ...cleanedParameters, //user set parameters have priority over ai generated parameters
-    };
-    const toolCallMessage = await tool.invoke(AIToolCallMessage.tool_calls[0]);
-    AIToolCallMessage.additional_kwargs = {
-      appActionInvocation: {
-        nodeTitle: node.name,
-      },
-    };
-    return {
-      messages: [AIToolCallMessage, toolCallMessage],
-      history: createHistoryStep<AppActionInvocationHistoryStep>(state.history, {
-        type: NodeType.APP_TOOL,
-        nodeId: node.name,
-        nodeDisplayName: node.displayName!,
-        raw: AIToolCallMessage.tool_calls[0],
-        appName: node.appName,
-        messageIds: [AIToolCallMessage.id!],
-      }),
-    };
-  };
-  graph.addNode(node.name, callback);
-};

package/src/nodes/addHumanInTheLoopNode.ts

@@ -1,25 +0,0 @@
-import { interrupt } from '@langchain/langgraph';
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { RunnableLike } from '@langchain/core/runnables';
-import { logger } from '../utils/logger';
-import { internalNodesSuffix } from '../types/Flows.types';
-
-type AddHumanInTheLoopNodeParams = {
-  graph: PreCompiledGraph;
-  attachedToNodeName: string;
-};
-
-export const buildHumanInTheLoopNodeName = (nodeName: string) => `${nodeName}${internalNodesSuffix.HUMAN_IN_THE_LOOP}`;
-
-export const addHumanInTheLoopNode = async ({ graph, attachedToNodeName }: AddHumanInTheLoopNodeParams) => {
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing "human in the loop" node for the attached node${attachedToNodeName}`);
-
-    if (state.messages[state.messages.length - 1].getType() === 'ai') {
-      const value = interrupt('input from human in the loop');
-      return value;
-    }
-  };
-  graph.addNode(buildHumanInTheLoopNodeName(attachedToNodeName), callback);
-  graph.addEdge(attachedToNodeName as any, buildHumanInTheLoopNodeName(attachedToNodeName) as any);
-};

package/src/nodes/addJumpToNode.ts

@@ -1,24 +0,0 @@
-import { RunnableLike } from '@langchain/core/runnables';
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { JumpToNode, NodeType } from '../types/Flows.types';
-import { logger } from '../utils/logger';
-import { HistoryStep } from '../types/Agent.types';
-import { createHistoryStep } from '../utils/history';
-
-export const addJumpToNode = async ({ graph, node }: { graph: PreCompiledGraph; node: JumpToNode }) => {
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing jump node ${node.displayName} – jumping to ${node.targetNodeId}`);
-    // No state modifications are necessary; control flow is handled via edges.
-    return {
-      history: createHistoryStep<HistoryStep>(state.history, {
-        type: NodeType.JUMP_TO_NODE,
-        nodeId: node.name,
-        nodeDisplayName: node.displayName,
-        raw: '',
-      }),
-    };
-  };
-
-  graph.addNode(node.name, callback);
-  graph.addEdge(node.name as any, node.targetNodeId as any);
-};

package/src/nodes/addJunctionNode.ts

@@ -1,19 +0,0 @@
-import { JunctionNode, NodeType } from '../types/Flows.types';
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { RunnableLike } from '@langchain/core/runnables';
-import { createHistoryStep } from '../utils/history';
-import { HistoryStep } from '../types/Agent.types';
-
-export const addJunctionNode = ({ graph, node }: { graph: PreCompiledGraph; node: JunctionNode }) => {
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    return {
-      history: createHistoryStep<HistoryStep>(state.history, {
-        type: NodeType.JUNCTION,
-        nodeId: node.name,
-        nodeDisplayName: node.displayName,
-        raw: '',
-      }),
-    };
-  };
-  graph.addNode(node.name, callback);
-};