@minded-ai/mindedjs 1.0.31 → 1.0.33

package/src/nodes/addToolNode.ts

@@ -1,14 +1,11 @@
-import { BaseLanguageModel } from '@langchain/core/language_models/base';
 import { ToolNode } from '../types/Flows.types';
 import { Tool } from '../types/Tools.types';
 import { tool as langchainTool } from '@langchain/core/tools';
 import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { AIMessage, BaseMessage, SystemMessage, ToolMessage } from '@langchain/core/messages';
-import { createReactAgent } from '@langchain/langgraph/prebuilt';
+import { SystemMessage, ToolMessage } from '@langchain/core/messages';
 import { RunnableLike } from '@langchain/core/runnables';
 import { z } from 'zod';
-import { MemorySaver } from '@langchain/langgraph';
-import { v4 as uuidv4 } from 'uuid';
+import { LLMProviders } from '../types/LLM.types';
 
 export const addToolNode = async <Memory>({
   graph,
@@ -19,7 +16,7 @@ export const addToolNode = async <Memory>({
   graph: PreCompiledGraph;
   node: ToolNode;
   tools: Tool<any, any>[];
-  llm: BaseLanguageModel;
+  llm: typeof LLMProviders[keyof typeof LLMProviders];
 }) => {
   const toolNode = node as ToolNode;
   const matchedTool = tools.find((tool) => tool.name === toolNode.toolName);
@@ -27,90 +24,36 @@ export const addToolNode = async <Memory>({
     throw new Error(`Tool not found: ${toolNode.toolName}`);
   }
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    try {
-      console.log(`Executing tool node ${toolNode.name}`);
+    console.log(`Executing tool node ${toolNode.name}`);
 
-      const executeWrapper = async (input: z.infer<typeof matchedTool.input>) => {
-        try {
-          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 = langchainTool(executeWrapper, {
-        name: matchedTool.name,
-        description: matchedTool.description,
-        schema: matchedTool.input,
-      });
-
-      let toolCallMessage;
-      let toolResponseMessage;
-      let attempts = 0;
-      const maxAttempts = 3;
-
-      while ((!toolCallMessage || !toolResponseMessage) && attempts < maxAttempts) {
-        const prompt = `
-        Context:
-          messages: ${JSON.stringify(state.messages)}
+    const executeWrapper = async (input: z.infer<typeof matchedTool.input>) => {
+      try {
+        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 = langchainTool(executeWrapper, {
+      name: matchedTool.name,
+      description: matchedTool.description,
+      schema: matchedTool.input,
+    });
+    const prompt = `
+        Additional context:
           workflow memory: ${JSON.stringify(state.memory)}
-        Instructions:
-          Your ONLY task is to call the tool ${tool.name}(...) using the context above.
-          Do not engage in conversation or provide any other responses.
-          Just make the tool call immediately.
-          You MUST call the tool even if you are uncertain about some parameters - use your best judgment to fill in any missing values.
-          ${toolNode.prompt ? `Tool parameters guidance: ${toolNode.prompt}` : ''}
-          ${
-            attempts > 0
-              ? `Previous attempts failed. You MUST make a tool call now with your best guess at the parameters - this is your only job.`
-              : ''
-          }
         `;
-        const toolCallingAgent = createReactAgent({
-          checkpointer: new MemorySaver(),
-          llm,
-          tools: [tool],
-        });
-
-        const response = await toolCallingAgent.invoke(
-          { messages: [new SystemMessage(prompt)] },
-          { configurable: { thread_id: uuidv4() } },
-        );
-        toolCallMessage = getLastToolCallMessage(response.messages);
-        toolResponseMessage = getLastToolMessage(response.messages);
-
-        if (!toolCallMessage || !toolResponseMessage) {
-          response.messages.push(new SystemMessage('No tool call was made. Please try again and make sure to call the tool.'));
-          attempts++;
-        }
-      }
-
-      if (!toolCallMessage || !toolResponseMessage) {
-        throw new Error('Failed to get tool call or response after multiple attempts');
-      }
-
-      const toolMemory = extractToolMemoryResponse<Memory>(toolResponseMessage);
-      return { memory: toolMemory, messages: [toolCallMessage, toolResponseMessage], triggerInvocations: state.triggerInvocations };
-    } catch (error) {
-      console.error('Error executing tool node', error);
-      throw error;
-    }
-  };
+    const AIToolCallMessage = await llm.bindTools([tool], {
+      tool_choice: tool.name,
+    }).invoke([...state.messages, new SystemMessage(prompt)]);
+    const toolCallMessage = await tool.invoke(AIToolCallMessage.tool_calls[0])
+    const toolMemory = extractToolMemoryResponse<Memory>(toolCallMessage as ToolMessage);
+    return { memory: toolMemory, messages: [AIToolCallMessage, toolCallMessage] };
+  }
   graph.addNode(node.name, callback);
 };
 
-const getLastToolCallMessage = (messages: BaseMessage[]): BaseMessage => {
-  const toolCallMessages = messages.filter((message) => (message as AIMessage).tool_calls?.length || 0 > 0);
-  const lastToolCallMessage = toolCallMessages[toolCallMessages.length - 1];
-  return lastToolCallMessage;
-};
-
-const getLastToolMessage = (messages: BaseMessage[]): ToolMessage => {
-  const toolMessages = messages.filter((message) => message.getType() === 'tool');
-  const lastToolMessage = toolMessages[toolMessages.length - 1];
-  return lastToolMessage as ToolMessage;
-};
 
 const extractToolMemoryResponse = <Memory>(toolMessage: ToolMessage): Partial<Memory> => {
   try {

package/src/nodes/nodeFactory.ts

@@ -8,6 +8,7 @@ import { addPromptNode } from './addPromptNode';
 import { AgentEventRequestPayloads } from '../events/AgentEvents';
 import { EmitSignature } from '../types/Agent.types';
 import { addTriggerNode } from './addTriggerNode';
+import { LLMProviders } from '../types/LLM.types';
 
 const addJunctionNode = ({ graph, node }: { graph: PreCompiledGraph; node: JunctionNode }) => {
   const callback: RunnableLike = async () => { };
@@ -39,7 +40,7 @@ export const nodeFactory = ({
   graph: PreCompiledGraph;
   node: Node;
   tools: Tool<any, any>[];
-  llm: BaseLanguageModel;
+  llm: typeof LLMProviders[keyof typeof LLMProviders];
   emit: EmitSignature<any, keyof AgentEventRequestPayloads<any>>;
 }) => {
   const nodeType = node.type;

package/dist/types/Triggers.types.d.ts

@@ -1 +0,0 @@
-export type TriggerBody = any;

package/dist/types/Triggers.types.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=Triggers.types.js.map

package/dist/types/Triggers.types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Triggers.types.js","sourceRoot":"","sources":["../../src/types/Triggers.types.ts"],"names":[],"mappings":""}