@minded-ai/mindedjs 1.0.150 → 2.0.0-beta1

package/src/nodes/addPromptNode.ts

@@ -9,7 +9,6 @@ import { tool as langchainTool } from '@langchain/core/tools';
 import { AgentEventRequestPayloads, AgentEvents } from '../events/AgentEvents';
 import { EmitSignature, HistoryStep } from '../types/Agent.types';
 import { createLlmInstance } from '../llm/createLlmInstance';
-import extractToolStateResponse from '../utils/extractStateMemoryResponse';
 import { Agent } from '../agent';
 import { logger } from '../utils/logger';
 import { combinePlaybooks } from '../playbooks/playbooks';
@@ -41,19 +40,28 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
         }),
       );
 
-    const combinedPlaybooks = combinePlaybooks(agent.playbooks) || '';
-
     // Get edges for the current node and format them
     const edges = agent.flows?.flatMap((flow: any) => flow.edges) || [];
     const nodeEdges = edges.filter((edge: any) => edge.source === node.name);
     const currentPromptNode = getCurrentPromptNode(node, nodeEdges);
-    const systemMessage = combinedPlaybooks + '\n\n' + currentPromptNode;
-    const compiledPrompt = compilePrompt(systemMessage, { memory: state.memory, system: { currentTime: new Date().toISOString() } });
+
+    let finalMessage = currentPromptNode;
+    const combinedPlaybooks = combinePlaybooks(agent.playbooks);
+    if (combinedPlaybooks) {
+      finalMessage = combinedPlaybooks + '\n\n' + currentPromptNode;
+    }
+    const compiledPrompt = compilePrompt(finalMessage, { memory: state.memory });
+    const systemMessage = new SystemMessage(compiledPrompt);
+    if (state.messages.length === 0 || state.messages[0].getType() === 'system') {
+      state.messages[0] = systemMessage;
+    } else {
+      state.messages.unshift(systemMessage);
+    }
 
     const startTime = Date.now();
-    const result: AIMessage = await llmToUse.bindTools(scopedTools).invoke([new SystemMessage(compiledPrompt), ...state.messages]);
-    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
+    const result: AIMessage = await llmToUse.bindTools(scopedTools).invoke(state.messages);
     const endTime = Date.now();
+    await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
     logger.debug({
       msg: '[Model] Model execution time',
       executionTimeMs: endTime - startTime,
@@ -64,7 +72,6 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
     if (result.tool_calls && result.tool_calls.length > 0) {
       // Execute the tools
       const toolResults = [];
-      let stateUpdates = {};
 
       for (const toolCall of result.tool_calls) {
         const matchedTool = scopedTools.find((t) => t.name === toolCall.name);
@@ -111,13 +118,6 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
                 }),
               ],
             });
-            const toolStateUpdate = extractToolStateResponse(toolResult);
-            // Properly merge memory and other state updates
-            stateUpdates = {
-              ...stateUpdates,
-              ...toolStateUpdate,
-              memory: { ...(stateUpdates as any).memory, ...(toolStateUpdate as any).memory },
-            };
             toolResults.push(toolResult);
           } catch (err: any) {
             if (err?.name === 'GraphInterrupt') throw err;
@@ -144,56 +144,48 @@ export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: Ad
         }
       }
 
-      // Return the tool call message and tool results with state updates spread at top level
-      return {
-        ...stateUpdates,
-        messages: [result, ...toolResults],
-        history: [
+      state.messages.push(result, ...toolResults);
+      state.history.push(
+        createHistoryStep<HistoryStep>(state.history, {
+          type: NodeType.TOOL,
+          nodeId: node.name,
+          nodeDisplayName: node.displayName,
+          raw: result,
+          messageIds: [result.id!],
+        }),
+        ...toolResults.map((toolResult) =>
           createHistoryStep<HistoryStep>(state.history, {
             type: NodeType.TOOL,
             nodeId: node.name,
             nodeDisplayName: node.displayName,
-            raw: result,
-            messageIds: [result.id!],
+            raw: toolResult,
+            messageIds: [toolResult.id!],
           }),
-          ...toolResults.map((toolResult) =>
-            createHistoryStep<HistoryStep>(state.history, {
-              type: NodeType.TOOL,
-              nodeId: node.name,
-              nodeDisplayName: node.displayName,
-              raw: toolResult,
-              messageIds: [toolResult.id!],
-            }),
-          ),
-        ],
-      };
+        ),
+      );
+      return state;
     }
 
     // Model text response
     state.goto = null;
-    //update state so AI_MESSAGE will get the latest state
-    const stateForAIMessage = structuredClone(state);
-    stateForAIMessage.goto = null;
-    stateForAIMessage.messages.push(result);
-    let stateUpdate: any = { goto: null, messages: [result] };
+    state.messages.push(result);
+
     if (result.getType() === 'ai') {
       logger.info({ msg: `[Model] Response`, content: result.content, sessionId: state.sessionId, node: node.displayName });
-      const results = await emit(AgentEvents.AI_MESSAGE, { message: result.content as string, state: stateForAIMessage });
-      const handlerResult = results.find((r) => r !== undefined);
-      if (handlerResult && handlerResult.state) {
-        stateUpdate = { ...stateUpdate, ...handlerResult.state };
-      }
+      await emit(AgentEvents.AI_MESSAGE, { message: result.content as string, state });
     }
-    return {
-      ...stateUpdate,
-      history: createHistoryStep<HistoryStep>(state.history, {
+
+    state.history.push(
+      createHistoryStep<HistoryStep>(state.history, {
         type: NodeType.PROMPT_NODE,
         nodeId: node.name,
         nodeDisplayName: node.displayName,
         raw: result.content,
         messageIds: [result.id!],
       }),
-    };
+    );
+
+    return state;
   };
   graph.addNode(node.name, callback);
 };

package/src/nodes/addToolNode.ts

@@ -40,31 +40,45 @@ export const addToolNode = async ({
       schema: matchedTool.input,
     });
 
-    const combinedPlaybooks = combinePlaybooks(agent.playbooks) || '';
-    const systemPrompt = combinedPlaybooks
-      ? compilePrompt(combinedPlaybooks, { memory: state.memory, system: { currentTime: new Date().toISOString() } })
-      : '';
+    const combinedPlaybooks = combinePlaybooks(agent.playbooks);
+    const toolPrompt = node.prompt;
+
+    let finalMessage = toolPrompt;
+    if (combinedPlaybooks) {
+      if (toolPrompt) {
+        finalMessage = combinedPlaybooks + '\n\n' + toolPrompt;
+      } else {
+        finalMessage = combinedPlaybooks;
+      }
+    }
+    if (finalMessage) {
+      const compiledPrompt = compilePrompt(finalMessage, { memory: state.memory });
+      const systemMessage = new SystemMessage(compiledPrompt);
+      if (state.messages.length === 0 || state.messages[0].getType() === 'system') {
+        state.messages[0] = systemMessage;
+      } else {
+        state.messages.unshift(systemMessage);
+      }
+    }
 
     const startTime = Date.now();
-    const AIToolCallMessage: AIMessage = await llm
-      .bindTools([tool], {
-        tool_choice: tool.name,
-      })
-      .invoke([...state.messages, new SystemMessage(systemPrompt)]);
+    const AIToolCallMessage: AIMessage = await llm.bindTools([tool], { tool_choice: tool.name }).invoke(state.messages);
     const endTime = Date.now();
     logger.debug({ msg: '[Tool] Model execution time', tool: matchedTool.name, executionTimeMs: endTime - startTime });
     await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
-    return {
-      goto: null,
-      messages: [AIToolCallMessage],
-      history: createHistoryStep<HistoryStep>(state.history, {
-        type: NodeType.TOOL,
-        nodeId: node.name,
-        nodeDisplayName: node.displayName,
-        raw: AIToolCallMessage.tool_calls?.[0] || '',
-        messageIds: [AIToolCallMessage.id!],
-      }),
-    };
+    state.goto = null;
+    state.messages.push(AIToolCallMessage);
+
+    const historyMsg = createHistoryStep<HistoryStep>(state.history, {
+      type: NodeType.TOOL,
+      nodeId: node.name,
+      nodeDisplayName: node.displayName,
+      raw: AIToolCallMessage.tool_calls?.[0] || '',
+      messageIds: [AIToolCallMessage.id!],
+    });
+    state.history.push(historyMsg);
+
+    return state;
   };
   graph.addNode(node.name, callback);
 };

package/src/nodes/addToolRunNode.ts

@@ -4,13 +4,12 @@ import { Tool } from '../types/Tools.types';
 import { LLMProviders } from '../types/LLM.types';
 import { internalNodesSuffix, NodeType, ToolNode } from '../types/Flows.types';
 import { tool as langchainTool } from '@langchain/core/tools';
-import { ToolMessage } from '@langchain/core/messages';
 import { z } from 'zod';
-import extractToolStateResponse from '../utils/extractStateMemoryResponse';
 import { Agent } from '../agent';
 import { logger } from '../utils/logger';
-import { createHistoryStep } from '../utils/history';
 import { HistoryStep } from '../types/Agent.types';
+import { createHistoryStep } from '../utils/history';
+import { ToolMessage } from '@langchain/core/messages';
 
 type AddToolRunNodeParams = {
   graph: PreCompiledGraph;
@@ -37,7 +36,7 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
         const response = await matchedTool.execute({ input, state, agent });
         const endTime = Date.now();
         logger.debug({ msg: '[Tool] Tool execution time', tool: matchedTool.name, executionTimeMs: endTime - startTime });
-        return response || {};
+        return response as ToolMessage;
       } catch (err) {
         logger.error({ message: '[Tool] Error executing tool', err, node: toolNode.displayName });
         throw err;
@@ -54,25 +53,26 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
       throw new Error('Tool call not found');
     }
     const toolCallMessage = await tool.invoke(toolCallObj.tool_calls[0]);
-    const toolStateUpdate = extractToolStateResponse(toolCallMessage as ToolMessage);
 
-    // Push the toolCallMessage into the messages array from toolStateUpdate
-    const updatedMessages = [toolCallMessage, ...(toolStateUpdate.messages || [])];
+    // Add the tool message to the state
+    state.messages.push(toolCallMessage);
 
-    // Return the full state update from the tool with the updated messages
-
-    return {
-      goto: null,
-      ...toolStateUpdate,
-      messages: updatedMessages,
-      history: createHistoryStep<HistoryStep>(state.history, {
+    // Add history step
+    state.history.push(
+      createHistoryStep<HistoryStep>(state.history, {
         type: NodeType.TOOL,
         nodeId: toolNode.name,
         nodeDisplayName: toolNode.displayName,
         raw: toolCallMessage,
         messageIds: [toolCallObj.tool_calls[0].id],
       }),
-    };
+    );
+
+    // Clear goto if it was set
+    state.goto = null;
+
+    // Return the entire modified state
+    return state;
   };
 
   graph.addNode(buildToolRunNodeName(attachedToNodeName), callback);

package/src/nodes/addTriggerNode.ts

@@ -9,18 +9,18 @@ export const addTriggerNode = async ({ graph, node }: { graph: PreCompiledGraph;
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
     logger.debug({ msg: `[Trigger] Executing trigger node`, node: node.displayName });
     if (node.triggerType === TriggerType.MANUAL) {
-      return {
-        goto: null,
-        history: createHistoryStep<HistoryStep>(state.history, {
+      state.goto = null;
+      state.history.push(
+        createHistoryStep<HistoryStep>(state.history, {
           type: NodeType.TRIGGER,
           nodeId: node.name,
           nodeDisplayName: node.displayName,
           raw: '',
           messageIds: [],
         }),
-      };
+      );
     }
-    return {};
+    return state;
   };
 
   graph.addNode(node.name, callback);

package/src/nodes/compilePrompt.ts

@@ -6,6 +6,9 @@ import { logger } from '../utils/logger';
  */
 export function compilePrompt(prompt: string, params: Record<string, any> = {}): string {
   try {
+    // Define system parameters
+    params.system = { currentTime: new Date().toISOString() };
+
     // First, render with EJS
     let compiledPrompt = ejs.render(prompt, params);
 

package/src/platform/mindedCheckpointSaver.ts

@@ -49,21 +49,21 @@ export class MindedCheckpointSaver extends BaseCheckpointSaver<number> {
     // Re-serialize and deserialize metadata to restore class information
     const metadata = tuple.metadata
       ? (() => {
-        const [metadataType, serializedMetadata] = this.serde.dumpsTyped(tuple.metadata);
-        return this.serde.loadsTyped(metadataType, serializedMetadata) as CheckpointMetadata;
-      })()
+          const [metadataType, serializedMetadata] = this.serde.dumpsTyped(tuple.metadata);
+          return this.serde.loadsTyped(metadataType, serializedMetadata) as CheckpointMetadata;
+        })()
       : undefined;
 
     // Re-serialize and deserialize pending writes to restore class information
     const pendingWrites: CheckpointPendingWrite[] = tuple.pendingWrites
       ? await Promise.all(
-        tuple.pendingWrites.map(async (write) => {
-          const [taskId, channel, value] = write;
-          const [valueType, serializedValue] = this.serde.dumpsTyped(value);
-          const deserializedValue = await this.serde.loadsTyped(valueType, serializedValue);
-          return [taskId, channel, deserializedValue] as CheckpointPendingWrite;
-        }),
-      )
+          tuple.pendingWrites.map(async (write) => {
+            const [taskId, channel, value] = write;
+            const [valueType, serializedValue] = this.serde.dumpsTyped(value);
+            const deserializedValue = await this.serde.loadsTyped(valueType, serializedValue);
+            return [taskId, channel, deserializedValue] as CheckpointPendingWrite;
+          }),
+        )
       : [];
 
     return {
@@ -93,9 +93,9 @@ export class MindedCheckpointSaver extends BaseCheckpointSaver<number> {
       // Re-serialize and deserialize metadata to restore class information
       const metadata = tuple.metadata
         ? (() => {
-          const [metadataType, serializedMetadata] = this.serde.dumpsTyped(tuple.metadata);
-          return this.serde.loadsTyped(metadataType, serializedMetadata) as CheckpointMetadata;
-        })()
+            const [metadataType, serializedMetadata] = this.serde.dumpsTyped(tuple.metadata);
+            return this.serde.loadsTyped(metadataType, serializedMetadata) as CheckpointMetadata;
+          })()
         : undefined;
 
       yield {

package/src/platform/toolExecutor.ts

@@ -1,8 +1,6 @@
 import { Tool } from '../types/Tools.types';
 import { Agent } from '../agent';
 import { logger } from '../utils/logger';
-import extractToolStateResponse from '../utils/extractStateMemoryResponse';
-import { ToolMessage } from '@langchain/core/messages';
 
 export interface ToolExecutionRequest {
   toolName: string;
@@ -70,7 +68,7 @@ export class ToolExecutor {
         state.cdpUrl = cdpUrl;
       }
 
-      const response = await tool.execute({
+      await tool.execute({
         input: toolParams,
         state,
         agent: this.agent,
@@ -83,25 +81,11 @@ export class ToolExecutor {
         executionTimeMs: endTime - startTime,
       });
 
-      // Extract state updates from the response
-      let stateUpdate = {};
-      let result = response;
-
-      // If the response is a ToolMessage, extract state updates
-      if (response && typeof response === 'object' && 'content' in response) {
-        const toolMessage = response as ToolMessage;
-        stateUpdate = extractToolStateResponse(toolMessage);
-        // Extract the content as the result
-        result = { result: toolMessage.content };
-      }
-
-      // Update the session state if there are state changes
-      if (Object.keys(stateUpdate).length > 0) {
-        await this.agent.updateState({ sessionId, state: stateUpdate });
-      }
+      // Always update the session state after tool execution req
+      await this.agent.updateState({ sessionId, state });
 
       return {
-        result,
+        state,
       };
     } catch (err) {
       logger.error({

package/src/playbooks/playbooks.ts

@@ -183,9 +183,9 @@ function getAllYamlFiles(dir: string): string[] {
 /**
  * Combine playbooks into a single string
  */
-export function combinePlaybooks(playbooks: Playbook[]): string {
+export function combinePlaybooks(playbooks: Playbook[]): string | undefined {
   if (playbooks.length === 0) {
-    return '';
+    return undefined;
   }
 
   // Combine all playbooks into sections

package/src/toolsLibrary/classifier.ts

@@ -191,17 +191,14 @@ const classifierTool: Tool<typeof schema, any> = {
         confidence: result.confidence,
       });
 
+      state.memory.lastClassification = {
+        content: content.substring(0, 100) + (content.length > 100 ? '...' : ''),
+        result,
+        timestamp: new Date().toISOString(),
+      };
+
       return {
         result,
-        state: {
-          memory: {
-            lastClassification: {
-              content: content.substring(0, 100) + (content.length > 100 ? '...' : ''),
-              result,
-              timestamp: new Date().toISOString(),
-            },
-          },
-        },
       };
     } catch (err) {
       logger.error({

package/src/toolsLibrary/extraction.ts

@@ -369,17 +369,14 @@ const extractionTool: Tool<typeof schema, any> = {
         resultKeys: Object.keys(result),
       });
 
+      state.memory.lastExtraction = {
+        content: content.substring(0, 100) + (content.length > 100 ? '...' : ''),
+        result,
+        timestamp: new Date().toISOString(),
+      };
+
       return {
         result,
-        state: {
-          memory: {
-            lastExtraction: {
-              content: content.substring(0, 100) + (content.length > 100 ? '...' : ''),
-              result,
-              timestamp: new Date().toISOString(),
-            },
-          },
-        },
       };
     } catch (err) {
       logger.error({

package/src/toolsLibrary/parseDocument.ts

@@ -101,18 +101,15 @@ const parseDocumentTool: Tool<typeof schema, any> = {
       // Extract from document using the SDK's document extraction capabilities
       const result = await extractFromDocument(extractionOptions);
 
+      state.memory.lastParsedDocument = {
+        source: combinedInput.documentPath || combinedInput.documentUrl || 'content',
+        extractedAt: new Date().toISOString(),
+        extractedRaw: !!combinedInput.extractRaw,
+      };
+
       // Return only the extracted data, not the metadata as requested
       return {
         result: result.data,
-        state: {
-          memory: {
-            lastParsedDocument: {
-              source: combinedInput.documentPath || combinedInput.documentUrl || 'content',
-              extractedAt: new Date().toISOString(),
-              extractedRaw: !!combinedInput.extractRaw,
-            },
-          },
-        },
       };
     } catch (err) {
       logger.error({
@@ -121,13 +118,9 @@ const parseDocumentTool: Tool<typeof schema, any> = {
         err,
       });
 
+      state.memory.documentParsingError = err instanceof Error ? err.message : String(err);
       return {
         result: `Failed to parse document: ${err instanceof Error ? err.message : String(err)}`,
-        state: {
-          memory: {
-            documentParsingError: err instanceof Error ? err.message : String(err),
-          },
-        },
       };
     }
   },

package/src/types/Agent.types.ts

@@ -5,7 +5,7 @@ import { NodeType } from './Flows.types';
 export type EmitSignature<Memory, E extends keyof AgentEventRequestPayloads<Memory>> = (
   event: E,
   payload: AgentEventRequestPayloads<Memory>[E],
-) => Promise<AgentEventResponsePayloads<Memory>[E][]>;
+) => Promise<AgentEventResponsePayloads[E][]>;
 
 export type MindedSDKConfig = {
   flows: string[];

package/src/types/LangGraph.types.ts

@@ -4,36 +4,12 @@ import { HistoryStep, SessionType } from './Agent.types';
 import { z } from 'zod';
 import { logger } from '../utils/logger';
 
-// Define default values once
-const STATE_DEFAULTS = {
-  messages: [] as BaseMessage[],
-  history: [] as HistoryStep[],
-  sessionId: '',
-  goto: null as string | null | undefined,
-  sessionType: SessionType.TEXT,
-  scenario: {} as Record<string, string | boolean>,
-  cdpUrl: null as string | null,
-};
-
 export const createStateAnnotation = <Memory = any>(memorySchema?: z.ZodSchema<Memory>) =>
   Annotation.Root({
     messages: Annotation<Array<BaseMessage>>({
-      default: () => STATE_DEFAULTS.messages,
-      reducer: (prevMessages, newMessages) => {
-        const res = [...prevMessages];
-        for (const message of newMessages) {
-          if (message.additional_kwargs?.update) {
-            const index = res.findIndex((m) => m.id && m.id === message.id);
-            if (index !== -1) {
-              res[index].content = message.content;
-              res[index].additional_kwargs = { ...res[index].additional_kwargs, ...message.additional_kwargs };
-            }
-          } else {
-            res.push(message);
-          }
-        }
-        return res;
-      },
+      default: () => [] as BaseMessage[],
+      // Direct replacement - no reducer, just replace the entire value
+      reducer: (_, newValue) => newValue,
     }),
     memory: Annotation<Memory>({
       default: () => {
@@ -47,32 +23,39 @@ export const createStateAnnotation = <Memory = any>(memorySchema?: z.ZodSchema<M
         }
         return {} as Memory;
       },
-      reducer: (a, b) => ({ ...a, ...b }),
+      // Direct replacement - no reducer, just replace the entire value
+      reducer: (_, newValue) => newValue,
     }),
     history: Annotation<Array<HistoryStep>>({
-      default: () => STATE_DEFAULTS.history,
-      reducer: (a, b) => a.concat(b),
+      default: () => [] as HistoryStep[],
+      // Direct replacement - no reducer, just replace the entire value
+      reducer: (_, newValue) => newValue,
     }),
     sessionId: Annotation<string>({
-      default: () => STATE_DEFAULTS.sessionId,
-      reducer: (a, b) => b || a,
+      default: () => '',
+      // Direct replacement - no reducer, just replace the entire value
+      reducer: (_, newValue) => newValue,
     }),
     goto: Annotation<string | null | undefined>({
-      default: () => STATE_DEFAULTS.goto,
-      reducer: (a, b) => b,
+      default: () => null as string | null | undefined,
+      // Direct replacement - no reducer, just replace the entire value
+      reducer: (_, newValue) => newValue,
     }),
     sessionType: Annotation<SessionType>({
-      default: () => STATE_DEFAULTS.sessionType,
-      reducer: (a, b) => b || a,
+      default: () => SessionType.TEXT,
+      // Direct replacement - no reducer, just replace the entire value
+      reducer: (_, newValue) => newValue,
     }),
     scenario: Annotation<Record<string, string | boolean>>({
-      default: () => STATE_DEFAULTS.scenario,
-      reducer: (a, b) => b,
+      default: () => ({} as Record<string, string | boolean>),
+      // Direct replacement - no reducer, just replace the entire value
+      reducer: (_, newValue) => newValue,
     }),
     // Available only when executing browser-use
     cdpUrl: Annotation<string | null>({
-      default: () => STATE_DEFAULTS.cdpUrl,
-      reducer: (a, b) => b,
+      default: () => null as string | null,
+      // Direct replacement - no reducer, just replace the entire value
+      reducer: (_, newValue) => newValue,
     }),
   });
 
@@ -83,7 +66,13 @@ export const getInitialState = <Memory = any>(memorySchema?: z.ZodSchema<Memory>
   const memory = memorySchema ? memorySchema.parse({}) : ({} as Memory);
 
   return {
-    ...STATE_DEFAULTS,
+    messages: [],
+    history: [],
+    sessionId: '',
+    goto: null,
+    sessionType: SessionType.TEXT,
+    scenario: {},
+    cdpUrl: null,
     memory,
   } as State<Memory>;
 };

package/src/types/Tools.types.ts

@@ -2,13 +2,8 @@ import { z } from 'zod';
 import { Agent } from '../';
 import { State } from './LangGraph.types';
 
-// Type for state updates that allows partial memory
-type StateUpdate<Memory = any> = Omit<Partial<State<Memory>>, 'memory'> & {
-  memory?: Partial<Memory>;
-};
-
 // Valid return type for new API
-export type ToolReturnType<Memory = any> = { state?: StateUpdate<Memory>; result?: any } | void;
+export type ToolReturnType = { result?: any } | void;
 
 export interface Tool<Input extends z.ZodSchema, Memory = any> {
   name: string;
@@ -16,7 +11,7 @@ export interface Tool<Input extends z.ZodSchema, Memory = any> {
   input: Input;
   isGlobal?: boolean;
   allowExecutionRequests?: boolean;
-  execute: (input: ToolExecuteInput<Input, Memory>) => Promise<ToolReturnType<Memory>>;
+  execute: (input: ToolExecuteInput<Input, Memory>) => Promise<ToolReturnType>;
 }
 
 export interface ToolExecuteInput<Input extends z.ZodSchema, Memory = any> {