@minded-ai/mindedjs 1.0.26 → 1.0.27

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/edge-priority/edge-priority.test.ts

@@ -0,0 +1,182 @@
+import { expect } from 'chai';
+import { Agent } from '../../src/agent';
+import { z } from 'zod';
+import path from 'path';
+import { AgentEvents } from '../../src/events/AgentEvents';
+import { HumanMessage } from '@langchain/core/messages';
+
+const memorySchema = z.object({
+  result: z.string().optional(),
+  userAge: z.number().optional(),
+  userName: z.string().optional(),
+});
+
+const createTestAgent = (flowsPath: string) => {
+  const toolsPath = path.join(__dirname, 'tools');
+  const agent = new Agent({
+    memorySchema,
+    config: {
+      flows: [flowsPath],
+      tools: [toolsPath],
+      llm: {
+        name: 'ChatOpenAI',
+        properties: {
+          model: 'gpt-4.1',
+        },
+      },
+    },
+    tools: [
+      {
+        name: 'stepForwardTool',
+        description: 'Step Forward Tool',
+        input: z.object({
+          message: z.string(),
+        }),
+        execute: async () => ({
+          memory: { result: 'stepForward' },
+        }),
+      },
+      {
+        name: 'logicalTool',
+        description: 'Logical Tool',
+        input: z.object({
+          message: z.string(),
+        }),
+        execute: async () => ({
+          memory: { result: 'logical' },
+        }),
+      },
+      {
+        name: 'promptTool',
+        description: 'Prompt Tool',
+        input: z.object({
+          message: z.string(),
+        }),
+        execute: async () => ({
+          memory: { result: 'prompt' },
+        }),
+      },
+    ],
+  });
+
+  // Add trigger event handler
+  agent.on(AgentEvents.TRIGGER_EVENT, async ({ triggerName, triggerBody }) => {
+    if (triggerName === 'TestTrigger') {
+      return {
+        memory: triggerBody.memory || {},
+        messages: [new HumanMessage(triggerBody.message)],
+      };
+    }
+  });
+
+  return agent;
+};
+
+describe('Edge Priority Logic', () => {
+  describe('All 3 Edge Types (Step Forward > Logical > Prompt)', () => {
+    let agent: Agent;
+
+    beforeEach(() => {
+      const flowsPath = path.join(__dirname, 'flows/all-three-edges');
+      agent = createTestAgent(flowsPath);
+    });
+
+    it('should prioritize step forward over logical and prompt', async function () {
+      this.timeout(20000);
+
+      const result = await agent.invoke({
+        triggerBody: {
+          message: 'Test message',
+          memory: { userAge: 25, userName: 'Test' }, // Satisfies logical condition
+        },
+        triggerName: 'TestTrigger',
+      });
+
+      // Step forward should win regardless of other conditions
+      expect(result.memory.result).to.equal('stepForward');
+    });
+  });
+
+  describe('Logical + Prompt Edges (Logical > Prompt)', () => {
+    let agent: Agent;
+
+    beforeEach(() => {
+      const flowsPath = path.join(__dirname, 'flows/logical-prompt-edges');
+      agent = createTestAgent(flowsPath);
+    });
+
+    it('should prioritize logical over prompt when logical condition is met', async function () {
+      this.timeout(20000);
+
+      const result = await agent.invoke({
+        triggerBody: {
+          message: 'Test message',
+          memory: { userAge: 25 }, // Satisfies logical condition (age >= 18)
+        },
+        triggerName: 'TestTrigger',
+      });
+
+      expect(result.memory.result).to.equal('logical');
+    });
+
+    it('should fall back to prompt when logical condition is not met', async function () {
+      this.timeout(20000);
+
+      const result = await agent.invoke({
+        triggerBody: {
+          message: 'Test message',
+          memory: { userAge: 15 }, // Does not satisfy logical condition (age < 18)
+        },
+        triggerName: 'TestTrigger',
+      });
+
+      expect(result.memory.result).to.equal('prompt');
+    });
+  });
+
+  describe('Step Forward + Prompt Edges (Step Forward > Prompt)', () => {
+    let agent: Agent;
+
+    beforeEach(() => {
+      const flowsPath = path.join(__dirname, 'flows/stepforward-prompt-edges');
+      agent = createTestAgent(flowsPath);
+    });
+
+    it('should prioritize step forward over prompt', async function () {
+      this.timeout(20000);
+
+      const result = await agent.invoke({
+        triggerBody: {
+          message: 'Test message',
+          memory: { userName: 'TestUser' }, // Would satisfy prompt condition
+        },
+        triggerName: 'TestTrigger',
+      });
+
+      expect(result.memory.result).to.equal('stepForward');
+    });
+  });
+
+  describe('Step Forward + Logical Edges (Step Forward > Logical)', () => {
+    let agent: Agent;
+
+    beforeEach(() => {
+      const flowsPath = path.join(__dirname, 'flows/stepforward-logical-edges');
+      agent = createTestAgent(flowsPath);
+    });
+
+    it('should prioritize step forward over logical', async function () {
+      this.timeout(20000);
+
+      const result = await agent.invoke({
+        triggerBody: {
+          message: 'Test message',
+          memory: { userAge: 25 }, // Would satisfy logical condition
+        },
+        triggerName: 'TestTrigger',
+      });
+
+      expect(result.memory.result).to.equal('stepForward');
+    });
+  });
+});

package/test/edge-priority/flows/all-three-edges/test-flow.yaml

@@ -0,0 +1,35 @@
+name: All Three Edges Priority Test
+nodes:
+  - type: 'trigger'
+    triggerType: 'manual'
+    name: 'TestTrigger'
+
+  - type: 'tool'
+    name: 'Step Forward Tool'
+    toolName: 'stepForwardTool'
+
+  - type: 'tool'
+    name: 'Logical Tool'
+    toolName: 'logicalTool'
+
+  - type: 'tool'
+    name: 'Prompt Tool'
+    toolName: 'promptTool'
+
+edges:
+  # Prompt condition edge (Priority 3)
+  - source: 'TestTrigger'
+    target: 'Prompt Tool'
+    type: 'promptCondition'
+    prompt: 'User wants to use prompt tool'
+
+  # Step forward edge (Priority 1 - should win)
+  - source: 'TestTrigger'
+    target: 'Step Forward Tool'
+    type: 'stepForward'
+
+  # Logical condition edge (Priority 2)
+  - source: 'TestTrigger'
+    target: 'Logical Tool'
+    type: 'logicalCondition'
+    condition: '({ memory }) => memory.userAge >= 18'

package/test/edge-priority/flows/logical-prompt-edges/test-flow.yaml

@@ -0,0 +1,26 @@
+name: Logical + Prompt Edges Priority Test
+nodes:
+  - type: 'trigger'
+    triggerType: 'manual'
+    name: 'TestTrigger'
+
+  - type: 'tool'
+    name: 'Logical Tool'
+    toolName: 'logicalTool'
+
+  - type: 'tool'
+    name: 'Prompt Tool'
+    toolName: 'promptTool'
+
+edges:
+  # Prompt condition edge (Priority 3 - fallback when logical fails)
+  - source: 'TestTrigger'
+    target: 'Prompt Tool'
+    type: 'promptCondition'
+    prompt: 'User wants to use prompt tool'
+
+  # Logical condition edge (Priority 2 - should win when condition met)
+  - source: 'TestTrigger'
+    target: 'Logical Tool'
+    type: 'logicalCondition'
+    condition: '({ memory }) => memory.userAge >= 18'

package/test/edge-priority/flows/stepforward-logical-edges/test-flow.yaml

@@ -0,0 +1,25 @@
+name: Step Forward + Logical Edges Priority Test
+nodes:
+  - type: 'trigger'
+    triggerType: 'manual'
+    name: 'TestTrigger'
+
+  - type: 'tool'
+    name: 'Step Forward Tool'
+    toolName: 'stepForwardTool'
+
+  - type: 'tool'
+    name: 'Logical Tool'
+    toolName: 'logicalTool'
+
+edges:
+  # Logical condition edge (Priority 2)
+  - source: 'TestTrigger'
+    target: 'Logical Tool'
+    type: 'logicalCondition'
+    condition: '({ memory }) => memory.userAge >= 18'
+
+  # Step forward edge (Priority 1 - should win)
+  - source: 'TestTrigger'
+    target: 'Step Forward Tool'
+    type: 'stepForward'

package/test/edge-priority/flows/stepforward-prompt-edges/test-flow.yaml

@@ -0,0 +1,25 @@
+name: Step Forward + Prompt Edges Priority Test
+nodes:
+  - type: 'trigger'
+    triggerType: 'manual'
+    name: 'TestTrigger'
+
+  - type: 'tool'
+    name: 'Step Forward Tool'
+    toolName: 'stepForwardTool'
+
+  - type: 'tool'
+    name: 'Prompt Tool'
+    toolName: 'promptTool'
+
+edges:
+  # Prompt condition edge (Priority 3)
+  - source: 'TestTrigger'
+    target: 'Prompt Tool'
+    type: 'promptCondition'
+    prompt: 'User wants to use prompt tool'
+
+  # Step forward edge (Priority 1 - should win)
+  - source: 'TestTrigger'
+    target: 'Step Forward Tool'
+    type: 'stepForward'

package/dist/internalTools/appActionRunnerTool.d.ts

@@ -1,25 +0,0 @@
-import { z } from 'zod';
-import { Tool } from '../types/Tools.types';
-declare const memorySchema: z.ZodObject<{
-    appName: z.ZodString;
-    actionName: z.ZodString;
-    actionOutput: z.ZodAny;
-}, "strip", z.ZodTypeAny, {
-    appName: string;
-    actionName: string;
-    actionOutput?: any;
-}, {
-    appName: string;
-    actionName: string;
-    actionOutput?: any;
-}>;
-export type AppActionRunnerMemory = z.infer<typeof memorySchema>;
-declare const schema: z.ZodObject<{
-    actionInput: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    actionInput: string;
-}, {
-    actionInput: string;
-}>;
-declare const appActionRunnerToolCreator: Tool<typeof schema, AppActionRunnerMemory>;
-export default appActionRunnerToolCreator;

package/dist/internalTools/appActionRunnerTool.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const zod_1 = require("zod");
-const memorySchema = zod_1.z.object({
-    appName: zod_1.z.string(),
-    actionName: zod_1.z.string(),
-    actionOutput: zod_1.z.any(), // TODO: output schema from pipedream actions output ?
-});
-const schema = zod_1.z.object({
-    actionInput: zod_1.z.string(), // TODO: input schema from pipedream actions input - mandatory for the model to call with the correct input parameters
-});
-const appActionRunnerToolCreator = {
-    name: 'appActionRunnerTool',
-    description: 'App action runner tool',
-    input: schema,
-    execute: async ({ input }) => {
-        console.log('*Action: App action runner*');
-        console.log('input', input);
-        const appActionRunnerInput = input;
-        return {
-            memory: {
-                appName: appActionRunnerInput.appName,
-                actionName: appActionRunnerInput.actionName,
-                actionOutput: input.actionInput,
-            },
-        };
-    },
-};
-exports.default = appActionRunnerToolCreator;
-//# sourceMappingURL=appActionRunnerTool.js.map

package/dist/internalTools/appActionRunnerTool.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"appActionRunnerTool.js","sourceRoot":"","sources":["../../src/internalTools/appActionRunnerTool.ts"],"names":[],"mappings":";;AAAA,6BAAwB;AAExB,MAAM,YAAY,GAAG,OAAC,CAAC,MAAM,CAAC;IAC1B,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE;IACnB,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE;IACtB,YAAY,EAAE,OAAC,CAAC,GAAG,EAAE,EAAE,sDAAsD;CAChF,CAAC,CAAC;AAGH,MAAM,MAAM,GAAG,OAAC,CAAC,MAAM,CAAC;IACpB,WAAW,EAAE,OAAC,CAAC,MAAM,EAAE,EAAE,sHAAsH;CAClJ,CAAC,CAAC;AAEH,MAAM,0BAA0B,GAA+C;IAC3E,IAAI,EAAE,qBAAqB;IAC3B,WAAW,EAAE,wBAAwB;IACrC,KAAK,EAAE,MAAM;IACb,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;QACzB,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,CAAC;QAC3C,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC5B,MAAM,oBAAoB,GAAG,KAA6B,CAAC;QAC3D,OAAO;YACH,MAAM,EAAE;gBACJ,OAAO,EAAE,oBAAoB,CAAC,OAAO;gBACrC,UAAU,EAAE,oBAAoB,CAAC,UAAU;gBAC3C,YAAY,EAAE,KAAK,CAAC,WAAW;aAClC;SACJ,CAAC;IACN,CAAC;CACJ,CAAC;AAEF,kBAAe,0BAA0B,CAAC"}

package/dist/nodes/actionRunnerTool.d.ts

@@ -1,11 +0,0 @@
-import { AppToolNode, ToolNode } from "../types/Flows.types";
-import { stateAnnotation } from "../types/LangGraph.types";
-import { Tool } from "../types/Tools.types";
-import { BaseLanguageModel } from "@langchain/core/language_models/base";
-import { BaseMessage, ToolMessage } from "@langchain/core/messages";
-declare const actionRunnerTool: <Memory>(matchedTool: Tool<any, Memory>, toolNode: ToolNode | AppToolNode, llm: BaseLanguageModel) => (state: typeof stateAnnotation.State) => Promise<{
-    memory: Partial<Memory>;
-    messages: (BaseMessage | ToolMessage)[];
-    triggerInvocations: import("..").TriggerInvocationHistory[];
-}>;
-export default actionRunnerTool;

package/dist/nodes/actionRunnerTool.js

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Flows_types_1 = require("../types/Flows.types");
-const prebuilt_1 = require("@langchain/langgraph/prebuilt");
-const langgraph_1 = require("@langchain/langgraph");
-const messages_1 = require("@langchain/core/messages");
-const uuid_1 = require("uuid");
-const tools_1 = require("@langchain/core/tools");
-const actionRunnerTool = (matchedTool, toolNode, llm) => {
-    return async (state) => {
-        try {
-            console.log(`Executing tool node ${toolNode.name}`);
-            const executeWrapper = async (input) => {
-                try {
-                    if (toolNode.type === Flows_types_1.NodeType.APP_TOOL) {
-                        input.appName = toolNode.appName;
-                        input.actionName = toolNode.actionName;
-                    }
-                    const response = await matchedTool.execute({ input, memory: state.memory, triggerInvocations: state.triggerInvocations });
-                    return response || {};
-                }
-                catch (error) {
-                    console.error('Error executing tool', error);
-                    throw error;
-                }
-            };
-            const tool = (0, tools_1.tool)(executeWrapper, {
-                name: matchedTool.name,
-                description: matchedTool.description,
-                schema: matchedTool.input,
-            });
-            const prompt = `
-      Context:
-        messages: ${JSON.stringify(state.messages)}
-        workflow memory: ${JSON.stringify(state.memory)}
-      Instructions:
-        Call immediately tool ${tool.name}(...)
-        ${toolNode.prompt && `Tool execution instructions: ${toolNode.prompt}`}
-      `;
-            const toolCallingAgent = (0, prebuilt_1.createReactAgent)({
-                checkpointer: new langgraph_1.MemorySaver(),
-                llm,
-                tools: [tool],
-            });
-            const response = await toolCallingAgent.invoke({ messages: [new messages_1.SystemMessage(prompt)] }, { configurable: { thread_id: (0, uuid_1.v4)() } });
-            const toolCallMessage = getLastToolCallMessage(response.messages);
-            const toolResponseMessage = getLastToolMessage(response.messages);
-            if (!toolCallMessage || !toolResponseMessage) {
-                throw new Error('Tool call or tool response message not found');
-            }
-            const toolMemory = extractToolMemoryResponse(toolResponseMessage);
-            return { memory: toolMemory, messages: [toolCallMessage, toolResponseMessage], triggerInvocations: state.triggerInvocations };
-        }
-        catch (error) {
-            console.error('Error executing tool node', error);
-            throw error;
-        }
-    };
-};
-exports.default = actionRunnerTool;
-const getLastToolCallMessage = (messages) => {
-    const toolCallMessages = messages.filter((message) => { var _a; return ((_a = message.tool_calls) === null || _a === void 0 ? void 0 : _a.length) || 0 > 0; });
-    const lastToolCallMessage = toolCallMessages[toolCallMessages.length - 1];
-    return lastToolCallMessage;
-};
-const getLastToolMessage = (messages) => {
-    const toolMessages = messages.filter((message) => message.getType() === 'tool');
-    const lastToolMessage = toolMessages[toolMessages.length - 1];
-    return lastToolMessage;
-};
-const extractToolMemoryResponse = (toolMessage) => {
-    try {
-        const parsed = JSON.parse(toolMessage.content);
-        if (typeof parsed === 'object' && parsed !== null && 'memory' in parsed) {
-            return parsed.memory;
-        }
-    }
-    catch (error) {
-        console.error('Error parsing tool memory response', error);
-    }
-    return {};
-};
-//# sourceMappingURL=actionRunnerTool.js.map

package/dist/nodes/actionRunnerTool.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"actionRunnerTool.js","sourceRoot":"","sources":["../../src/nodes/actionRunnerTool.ts"],"names":[],"mappings":"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"}

package/dist/nodes/addAppTool.d.ts

@@ -1,8 +0,0 @@
-import { AppToolNode } from '../types/Flows.types';
-import { PreCompiledGraph } from "../types/LangGraph.types";
-import { BaseLanguageModel } from "@langchain/core/language_models/base";
-export declare const addAppToolNode: <Memory>({ graph, node, llm, }: {
-    graph: PreCompiledGraph;
-    node: AppToolNode;
-    llm: BaseLanguageModel;
-}) => void;

package/dist/nodes/addAppTool.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addAppToolNode = void 0;
-const appToolRunner_1 = require("../tools/appToolRunner");
-const toolNodeRunner_1 = require("./toolNodeRunner");
-const addAppToolNode = ({ graph, node, llm, }) => {
-    const toolNode = node;
-    const callback = (0, toolNodeRunner_1.getToolNodeRunner)(toolNode, appToolRunner_1.appToolRunnerTool, llm);
-    graph.addNode(node.name, callback);
-};
-exports.addAppToolNode = addAppToolNode;
-//# sourceMappingURL=addAppTool.js.map

package/dist/nodes/addAppTool.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"addAppTool.js","sourceRoot":"","sources":["../../src/nodes/addAppTool.ts"],"names":[],"mappings":";;;AAGA,0DAA2D;AAC3D,qDAAqD;AAG9C,MAAM,cAAc,GAAG,CAAS,EACnC,KAAK,EACL,IAAI,EACJ,GAAG,GAKN,EAAE,EAAE;IACD,MAAM,QAAQ,GAAG,IAAmB,CAAC;IACrC,MAAM,QAAQ,GAAiB,IAAA,kCAAiB,EAAS,QAAQ,EAAE,iCAAiB,EAAE,GAAG,CAAC,CAAC;IAC3F,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AACvC,CAAC,CAAC;AAZW,QAAA,cAAc,kBAYzB"}

package/dist/nodes/addAppToolNode.d.ts

@@ -1,8 +0,0 @@
-import { BaseLanguageModel } from "@langchain/core/language_models/base";
-import { AppToolNode } from "../types/Flows.types";
-import { PreCompiledGraph } from "../types/LangGraph.types";
-export declare const addAppToolNode: ({ graph, node, llm, }: {
-    graph: PreCompiledGraph;
-    node: AppToolNode;
-    llm: BaseLanguageModel;
-}) => void;

package/dist/nodes/addAppToolNode.js

@@ -1,14 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addAppToolNode = void 0;
-const appActionRunnerTool_1 = __importDefault(require("../internalTools/appActionRunnerTool"));
-const actionRunnerTool_1 = __importDefault(require("./actionRunnerTool"));
-const addAppToolNode = ({ graph, node, llm, }) => {
-    const callback = (0, actionRunnerTool_1.default)(appActionRunnerTool_1.default, node, llm);
-    graph.addNode(node.name, callback);
-};
-exports.addAppToolNode = addAppToolNode;
-//# sourceMappingURL=addAppToolNode.js.map