@minded-ai/mindedjs 1.0.151-beta-1 → 2.0.0

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 | null {
   if (playbooks.length === 0) {
-    return '';
+    return null;
   }
 
   // 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> {