@minded-ai/mindedjs 1.0.25 → 1.0.27

package/src/edges/edgeFactory.ts

@@ -6,9 +6,10 @@ import { createLogicalRouter } from './createLogicalRouter';
 import { createDirectEdge } from './createDirectEdge';
 import { addHumanInTheLoopNode, buildHumanInTheLoopNodeName } from '../nodes/addHumanInTheLoopNode';
 
-type EdgeProcessor<T extends Edge> = {
-  edges: T[];
-  router: (params: { edges: T[]; llm: BaseLanguageModel }) => any;
+type EdgesBySource = {
+  stepForward?: StepForwardEdge;
+  logical: LogicalConditionEdge[];
+  prompt: PromptConditionEdge[];
 };
 
 export const edgeFactory = ({
@@ -23,63 +24,87 @@ export const edgeFactory = ({
   llm: BaseLanguageModel;
 }) => {
   /**
-   * Processes edges with enhanced node capabilities (humanInTheLoop, canStayOnNode)
-   * This elegant abstraction handles both prompt and logical edges uniformly
+   * Creates a combined router that handles edge priority: step forward > logical > prompt
    */
-  const processEdges = <T extends Edge>(edgeProcessor: EdgeProcessor<T>): void => {
-    const { edges: filteredEdges, router } = edgeProcessor;
-    const uniqueSources = [...new Set(filteredEdges.map((edge) => edge.source))];
+  const createCombinedRouter = (sourceNode: string, edgesBySource: EdgesBySource) => {
+    return async (state: any) => {
+      // Priority 1: Step forward edge (max 1)
+      if (edgesBySource.stepForward) {
+        const directRouter = createDirectEdge(edgesBySource.stepForward);
+        return await directRouter();
+      }
 
-    uniqueSources.forEach((source) => {
-      const edgesForSource: T[] = [...filteredEdges.filter((edge) => edge.source === source)];
-      let effectiveSource = source;
+      // Priority 2: Logical condition edges
+      if (edgesBySource.logical.length > 0) {
+        const logicalRouter = createLogicalRouter({ edges: edgesBySource.logical });
+        const result = await logicalRouter(state);
+        if (result && result !== edgesBySource.logical[0].source) {
+          return result;
+        }
+      }
 
-      // Handle human-in-the-loop enhancement
-      if (nodes[source]?.humanInTheLoop) {
-        addHumanInTheLoopNode({ graph, attachedToNodeName: source });
-        effectiveSource = buildHumanInTheLoopNodeName(source);
+      // Priority 3: Prompt condition edges
+      if (edgesBySource.prompt.length > 0) {
+        const promptRouter = createPromptRouter({ edges: edgesBySource.prompt, llm });
+        return await promptRouter(state);
       }
 
-      // Handle stay-on-node capability
-      if (nodes[source]?.canStayOnNode) {
-        const stayEdge = {
-          source,
-          target: source,
-          type: EdgeType.PROMPT_CONDITION,
-          prompt: 'stay at current node if still relevant',
-        } as T;
+      // Fallback: stay at current source node
+      return sourceNode;
+    };
+  };
 
-        edgesForSource.push(stayEdge);
-      }
+  /**
+   * Processes all edges for a specific source node with enhanced capabilities
+   */
+  const processEdgesForNode = (source: string, edgesBySource: EdgesBySource): void => {
+    let effectiveSource = source;
+
+    // Handle human-in-the-loop enhancement
+    if (nodes[source]?.humanInTheLoop) {
+      addHumanInTheLoopNode({ graph, attachedToNodeName: source });
+      effectiveSource = buildHumanInTheLoopNodeName(source);
+    }
 
-      graph.addConditionalEdges(effectiveSource as any, router({ edges: edgesForSource, llm }));
-    });
+    // Handle stay-on-node capability
+    if (nodes[source]?.canStayOnNode) {
+      const stayEdge: PromptConditionEdge = {
+        source,
+        target: source,
+        type: EdgeType.PROMPT_CONDITION,
+        prompt: 'stay at current node if still relevant',
+      };
+      edgesBySource.prompt.push(stayEdge);
+    }
+
+    // Create and add the combined conditional edge
+    const combinedRouter = createCombinedRouter(effectiveSource, edgesBySource);
+    graph.addConditionalEdges(effectiveSource as any, combinedRouter);
   };
 
-  // Direct edges - simple and straightforward
-  const directEdges = edges.filter((edge) => edge.type === EdgeType.STEP_FORWARD) as StepForwardEdge[];
-  if (directEdges.length > 0) {
-    processEdges({
-      edges: directEdges,
-      router: createDirectEdge,
-    });
-  }
+  // 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);
+    }
 
-  // Prompt condition edges - enhanced with AI-driven routing
-  const promptEdges = edges.filter((edge) => edge.type === EdgeType.PROMPT_CONDITION) as PromptConditionEdge[];
-  if (promptEdges.length > 0) {
-    processEdges({
-      edges: promptEdges,
-      router: createPromptRouter,
-    });
-  }
+    return acc;
+  }, {} as Record<string, EdgesBySource>);
 
-  // Logical condition edges - enhanced with programmatic routing
-  const logicalEdges = edges.filter((edge) => edge.type === EdgeType.LOGICAL_CONDITION) as LogicalConditionEdge[];
-  if (logicalEdges.length > 0) {
-    processEdges({
-      edges: logicalEdges,
-      router: createLogicalRouter,
-    });
-  }
+  // Process edges for each source node
+  Object.entries(edgesBySource).forEach(([source, categorizedEdges]) => {
+    processEdgesForNode(source, categorizedEdges);
+  });
 };

package/src/events/AgentEvents.ts

@@ -10,6 +10,7 @@ export type AgentEventRequestPayloads<Memory> = {
   [AgentEvents.AI_MESSAGE]: {
     message: string;
     memory: Memory;
+    sessionId: string;
   };
   [AgentEvents.TRIGGER_EVENT]: {
     triggerName: string;

package/src/nodes/addPromptNode.ts

@@ -22,7 +22,7 @@ type AddPromptNodeParams = {
 };
 
 export const addPromptNode = async ({ graph, node, llm, tools, emit }: AddPromptNodeParams) => {
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
+  const callback: RunnableLike = async (state: typeof stateAnnotation.State, { configurable }) => {
     console.log(`Executing prompt node ${node.name}`);
     const llmToUse = node.llmConfig ? createLlmInstance(node.llmConfig) : llm;
 
@@ -62,6 +62,7 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit }: AddPrompt
       await emit(AgentEvents.AI_MESSAGE, {
         message: lastMessage.content as string,
         memory: state.memory,
+        sessionId: configurable.thread_id,
       });
     }
     return {

package/src/platform/config.ts

@@ -0,0 +1,42 @@
+type MindedConfig = {
+  baseUrl: string;
+  env: Environment;
+  token: string;
+  runLocally: boolean;
+};
+
+type Environment = 'development' | 'sandbox' | 'production' | 'test';
+
+export const getConfig = (): MindedConfig => {
+  const environment = (process.env.NODE_ENV as Environment) || 'sandbox';
+  switch (environment) {
+    case 'test':
+      return {
+        baseUrl: 'http://localhost:8888',
+        env: 'test',
+        token: process.env.MINDED_CONNECTION_TOKEN || '',
+        runLocally: true,
+      };
+    case 'development':
+      return {
+        baseUrl: 'http://localhost:8888',
+        env: 'development',
+        token: process.env.MINDED_CONNECTION_TOKEN || '',
+        runLocally: process.env.RUN_LOCALLY === 'true',
+      };
+    case 'sandbox':
+      return {
+        baseUrl: 'https://dashboard-api.minded.com',
+        env: 'sandbox',
+        token: process.env.MINDED_CONNECTION_TOKEN || '',
+        runLocally: false,
+      };
+    case 'production':
+      return {
+        baseUrl: 'https://api.minded.com',
+        env: 'production',
+        token: process.env.MINDED_CONNECTION_TOKEN || '',
+        runLocally: false,
+      };
+  }
+};

package/src/platform/mindedChatOpenAI.ts

@@ -0,0 +1,16 @@
+import { ChatOpenAI, ChatOpenAIFields } from "@langchain/openai";
+import { getConfig } from "./config";
+
+export class MindedChatOpenAI extends ChatOpenAI {
+  constructor(fields?: ChatOpenAIFields) {
+    const { token, baseUrl } = getConfig();
+    const mindedBaseUrl = `${baseUrl}/sdk/llmGateway/chatOpenAI`;
+    super({
+      ...fields,
+      apiKey: token,
+      configuration: {
+        baseURL: mindedBaseUrl,
+      },
+    });
+  }
+}

package/src/platform/mindedConnection.ts

@@ -4,6 +4,7 @@ import { BaseMindedConnectionSocketMessage, MindedConnectionSocketMessageType }
 import * as fs from 'fs';
 import * as path from 'path';
 import { stringify } from 'flatted';
+import { getConfig } from './config';
 
 export class MindedConnection {
   private socket: Socket | null = null;
@@ -14,7 +15,7 @@ export class MindedConnection {
   } = {};
 
   constructor() {
-    if (!process.env.MINDED_CONNECTION_TOKEN && !this.getSavedToken()) {
+    if (!getConfig().token && !this.getSavedToken()) {
       this.initializeReadline();
     }
   }
@@ -46,7 +47,7 @@ export class MindedConnection {
   }
 
   private async getMindedToken(): Promise<string> {
-    const envToken = process.env.MINDED_CONNECTION_TOKEN;
+    const envToken = getConfig().token;
     if (envToken) {
       this.saveToken(envToken);
       return envToken;
@@ -110,7 +111,7 @@ export class MindedConnection {
   };
 
   private async connect(token: string) {
-    this.socket = io(process.env.MINDED_SERVER, {
+    this.socket = io(getConfig().baseUrl, {
       path: '/minded-connect',
       query: {
         token,

package/src/types/LLM.types.ts

@@ -1,13 +1,15 @@
 import { AzureChatOpenAI, ChatOpenAI } from '@langchain/openai';
+import { MindedChatOpenAI } from '../platform/mindedChatOpenAI';
 
 export type LLMConfig = {
   name: string,
   properties: Record<string, any>
 }
 
-export type LLMProvider = 'ChatOpenAI' | 'AzureChatOpenAI';
+export type LLMProvider = 'ChatOpenAI' | 'AzureChatOpenAI' | 'MindedChatOpenAI';
 
-export const LLMProviders = {
+export const LLMProviders: Record<LLMProvider, any> = {
   ChatOpenAI: ChatOpenAI,
   AzureChatOpenAI: AzureChatOpenAI,
+  MindedChatOpenAI,
 }

package/src/types/LangGraph.types.ts

@@ -19,10 +19,6 @@ export const stateAnnotation = Annotation.Root({
     name: string;
     triggerBody: any;
   } | null>,
-  interruptedNode: Annotation<string | null>({
-    default: () => null,
-    reducer: (a, b) => b,
-  }),
   history: Annotation<Array<FlowHistory>>({
     default: () => [],
     reducer: (a, b) => a.concat(b),

package/test/can-stay-on-node/can-stay-on-node.test.ts

@@ -5,7 +5,6 @@ import { v4 as uuidv4 } from 'uuid';
 import path from 'path';
 import { AgentEvents } from '../../src/events/AgentEvents';
 import { HumanMessage } from '@langchain/core/messages';
-import { MindedConnectionSocketMessageType } from '../../src/platform/mindedConnectionTypes';
 
 const memorySchema = z.object({
   success: z.boolean(),
@@ -66,14 +65,12 @@ describe('Can Stay On Node', function () {
 
     // First invocation - triggers the flow and reaches the human-in-the-loop pause
     const result1 = await agent.invoke({
-      name: 'Trigger',
-      body: {
+      triggerBody: {
         message: 'Initial input for processing',
       },
-      cnvId: sessionId,
-      agentId: 'test',
+      triggerName: 'Trigger',
+      sessionId: sessionId,
       appName: 'test',
-      type: MindedConnectionSocketMessageType.OnAppTrigger,
     });
 
     // Should pause at human-in-the-loop, not reach success tool yet
@@ -82,14 +79,12 @@ describe('Can Stay On Node', function () {
 
     // Second invocation - provide "stay" instruction
     const result2 = await agent.invoke({
-      name: 'Trigger',
-      body: {
+      triggerBody: {
         message: 'stay',
       },
-      cnvId: sessionId,
-      agentId: 'test',
+      triggerName: 'Trigger',
+      sessionId: sessionId,
       appName: 'test',
-      type: MindedConnectionSocketMessageType.OnAppTrigger,
     });
 
     // Should stay on the node, pause again, not reach success tool
@@ -98,14 +93,12 @@ describe('Can Stay On Node', function () {
 
     // Third invocation - provide another "stay" instruction
     const result3 = await agent.invoke({
-      name: 'Trigger',
-      body: {
+      triggerBody: {
         message: 'stay',
       },
-      cnvId: sessionId,
-      agentId: 'test',
+      triggerName: 'Trigger',
+      sessionId: sessionId,
       appName: 'test',
-      type: MindedConnectionSocketMessageType.OnAppTrigger,
     });
 
     // Should still stay on the node, pause again
@@ -114,14 +107,12 @@ describe('Can Stay On Node', function () {
 
     // Fourth invocation - provide "continue" instruction
     const result4 = await agent.invoke({
-      name: 'Trigger',
-      body: {
+      triggerBody: {
         message: 'continue',
       },
-      cnvId: sessionId,
-      agentId: 'test',
+      triggerName: 'Trigger',
+      sessionId: sessionId,
       appName: 'test',
-      type: MindedConnectionSocketMessageType.OnAppTrigger,
     });
 
     // Should now move to success tool and complete
@@ -135,14 +126,12 @@ describe('Can Stay On Node', function () {
 
     // First invocation - triggers the flow and reaches the human-in-the-loop pause
     const result1 = await agent.invoke({
-      name: 'Trigger',
-      body: {
+      triggerBody: {
         message: 'Initial input for processing',
       },
-      cnvId: sessionId,
-      agentId: 'test',
+      triggerName: 'Trigger',
+      sessionId: sessionId,
       appName: 'test',
-      type: MindedConnectionSocketMessageType.OnAppTrigger,
     });
 
     // Should pause at human-in-the-loop, not reach success tool yet
@@ -151,14 +140,12 @@ describe('Can Stay On Node', function () {
 
     // Second invocation - provide "continue" instruction
     const result2 = await agent.invoke({
-      name: 'Trigger',
-      body: {
+      triggerBody: {
         message: 'continue',
       },
-      cnvId: sessionId,
-      agentId: 'test',
+      triggerName: 'Trigger',
+      sessionId: sessionId,
       appName: 'test',
-      type: MindedConnectionSocketMessageType.OnAppTrigger,
     });
 
     // Should now move to success tool and complete

package/test/cannot-stay-on-node/cannot-stay-on-node.test.ts

@@ -5,7 +5,6 @@ import { v4 as uuidv4 } from 'uuid';
 import path from 'path';
 import { AgentEvents } from '../../src/events/AgentEvents';
 import { HumanMessage } from '@langchain/core/messages';
-import { MindedConnectionSocketMessageType } from '../../src/platform/mindedConnectionTypes';
 
 const memorySchema = z.object({
   success: z.boolean(),
@@ -80,14 +79,12 @@ describe('Cannot Stay On Node', function () {
 
     // First invocation - triggers the flow and reaches the human-in-the-loop pause
     const result1 = await agent.invoke({
-      name: 'Trigger',
-      body: {
+      triggerBody: {
         message: 'Initial input for processing',
       },
-      cnvId: sessionId,
-      agentId: 'test',
+      triggerName: 'Trigger',
+      sessionId: sessionId,
       appName: 'test',
-      type: MindedConnectionSocketMessageType.OnAppTrigger,
     });
 
     // Should pause at human-in-the-loop, not reach any tool yet
@@ -97,14 +94,12 @@ describe('Cannot Stay On Node', function () {
 
     // Second invocation - explicitly request to stay on the node
     const result2 = await agent.invoke({
-      name: 'Trigger',
-      body: {
+      triggerBody: {
         message: 'You must stay at the node! Do not move to the next step. Stay here and continue processing on this same node.',
       },
-      cnvId: sessionId,
-      agentId: 'test',
+      triggerName: 'Trigger',
+      sessionId: sessionId,
       appName: 'test',
-      type: MindedConnectionSocketMessageType.OnAppTrigger,
     });
 
     // Should NOT stay on the node - should move to one of the target nodes
@@ -119,14 +114,12 @@ describe('Cannot Stay On Node', function () {
 
     // First invocation - initial trigger
     const result1 = await agent.invoke({
-      name: 'Trigger',
-      body: {
+      triggerBody: {
         message: 'Start processing',
       },
-      cnvId: sessionId,
-      agentId: 'test',
+      triggerName: 'Trigger',
+      sessionId: sessionId,
       appName: 'test',
-      type: MindedConnectionSocketMessageType.OnAppTrigger,
     });
 
     expect(result1.memory.success).to.not.equal(true);
@@ -134,14 +127,12 @@ describe('Cannot Stay On Node', function () {
 
     // Second invocation - request main workflow
     const result2 = await agent.invoke({
-      name: 'Trigger',
-      body: {
+      triggerBody: {
         message: 'Proceed with the main workflow',
       },
-      cnvId: sessionId,
-      agentId: 'test',
+      triggerName: 'Trigger',
+      sessionId: sessionId,
       appName: 'test',
-      type: MindedConnectionSocketMessageType.OnAppTrigger,
     });
 
     // Should move to success node
@@ -156,14 +147,12 @@ describe('Cannot Stay On Node', function () {
 
     // First invocation - initial trigger
     const result1 = await agent.invoke({
-      name: 'Trigger',
-      body: {
+      triggerBody: {
         message: 'Begin workflow',
       },
-      cnvId: sessionId,
-      agentId: 'test',
+      triggerName: 'Trigger',
+      sessionId: sessionId,
       appName: 'test',
-      type: MindedConnectionSocketMessageType.OnAppTrigger,
     });
 
     expect(result1.memory.success).to.not.equal(true);
@@ -171,14 +160,12 @@ describe('Cannot Stay On Node', function () {
 
     // Second invocation - request alternative approach
     const result2 = await agent.invoke({
-      name: 'Trigger',
-      body: {
+      triggerBody: {
         message: 'I want an alternative approach instead',
       },
-      cnvId: sessionId,
-      agentId: 'test',
+      triggerName: 'Trigger',
+      sessionId: sessionId,
       appName: 'test',
-      type: MindedConnectionSocketMessageType.OnAppTrigger,
     });
 
     // Should move to alternative node
@@ -193,14 +180,12 @@ describe('Cannot Stay On Node', function () {
 
     // First invocation - initial trigger
     const result1 = await agent.invoke({
-      name: 'Trigger',
-      body: {
+      triggerBody: {
         message: 'Process this data',
       },
-      cnvId: sessionId,
-      agentId: 'test',
+      triggerName: 'Trigger',
+      sessionId: sessionId,
       appName: 'test',
-      type: MindedConnectionSocketMessageType.OnAppTrigger,
     });
 
     expect(result1.memory.success).to.not.equal(true);
@@ -208,15 +193,13 @@ describe('Cannot Stay On Node', function () {
 
     // Second invocation - very strong request to stay
     const result2 = await agent.invoke({
-      name: 'Trigger',
-      body: {
+      triggerBody: {
         message:
           'STAY! Do not proceed! You must remain on this current node and not move forward. Keep processing here. Do not go to any other node.',
       },
-      cnvId: sessionId,
-      agentId: 'test',
+      triggerName: 'Trigger',
+      sessionId: sessionId,
       appName: 'test',
-      type: MindedConnectionSocketMessageType.OnAppTrigger,
     });
 
     // Should still be forced to move to one of the available target nodes