@minded-ai/mindedjs 1.0.129 → 1.0.131

package/src/platform/toolExecutor.ts

@@ -0,0 +1,118 @@
+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;
+  toolParams: any;
+  sessionId: string;
+  requestId: string;
+  cdpUrl?: string;
+}
+
+export interface ToolExecutionResponse {
+  result?: any;
+  state?: any;
+  error?: string;
+}
+
+export class ToolExecutor {
+  private tools: Map<string, Tool<any, any>> = new Map();
+
+  constructor(private agent: Agent) {}
+
+  /**
+   * Register tools for standalone execution
+   */
+  registerTools(tools: Tool<any, any>[]) {
+    tools.forEach((tool) => {
+      if (tool.allowExecutionRequests === true) {
+        this.tools.set(tool.name, tool);
+      }
+    });
+  }
+
+  /**
+   * Execute a tool by name with given parameters
+   * This is called when browser-use requests tool execution via socket
+   */
+  async executeTool(request: ToolExecutionRequest): Promise<ToolExecutionResponse> {
+    const { toolName, toolParams, sessionId, cdpUrl } = request;
+
+    try {
+      // Find the tool
+      const tool = this.tools.get(toolName);
+      if (!tool) {
+        throw new Error(`Tool not found: ${toolName}`);
+      }
+
+      // We only allow to execute tools that are marked as allowed to be executed
+
+      logger.debug({
+        msg: '[ToolExecutor] Executing tool',
+        toolName,
+        sessionId,
+        hasCdpUrl: !!cdpUrl,
+      });
+
+      // Get the current state for the session
+      const state = await this.agent.getState(sessionId);
+      if (!state) {
+        throw new Error(`Session state not found: ${sessionId}`);
+      }
+
+      // Execute the tool
+      const startTime = Date.now();
+
+      if (cdpUrl) {
+        state.cdpUrl = cdpUrl;
+      }
+
+      const response = await tool.execute({
+        input: toolParams,
+        state,
+        agent: this.agent,
+      });
+      const endTime = Date.now();
+
+      logger.debug({
+        msg: '[ToolExecutor] Tool execution completed',
+        toolName,
+        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 });
+      }
+
+      return {
+        result,
+      };
+    } catch (err) {
+      logger.error({
+        message: '[ToolExecutor] Error executing tool',
+        toolName,
+        err,
+      });
+
+      return {
+        error: err instanceof Error ? err.message : String(err),
+      };
+    }
+  }
+}

package/src/platform/utils/tools.ts

@@ -0,0 +1,55 @@
+import { logger } from '../../utils/logger';
+
+/**
+ * Convert Zod schema to parameter format
+ * This is a simplified version - you might need to expand based on your needs
+ */
+export const zodSchemaToParams = (zodSchema: any): any[] => {
+  try {
+    // Get the shape of the Zod object
+    const shape = zodSchema._def?.shape?.() || {};
+    const params = [];
+
+    for (const [key, value] of Object.entries(shape)) {
+      const zodValue = value as any; // Zod schema type
+      const param: any = {
+        name: key,
+        type: getZodType(zodValue),
+        required: !zodValue.isOptional?.(),
+        description: zodValue._def?.description || '',
+      };
+
+      params.push(param);
+    }
+
+    return params;
+  } catch (err) {
+    logger.warn({
+      message: '[ToolExecutor] Error parsing Zod schema',
+      err,
+    });
+    return [];
+  }
+};
+
+/**
+ * Get type string from Zod type
+ */
+const getZodType = (zodType: any): string => {
+  const typeName = zodType._def?.typeName;
+
+  switch (typeName) {
+    case 'ZodString':
+      return 'string';
+    case 'ZodNumber':
+      return 'number';
+    case 'ZodBoolean':
+      return 'boolean';
+    case 'ZodArray':
+      return 'array';
+    case 'ZodObject':
+      return 'object';
+    default:
+      return 'any';
+  }
+};

package/src/playbooks/playbooks.ts

@@ -92,9 +92,9 @@ function editorJsToMarkdown(blocks: OutputBlockData[]): string {
             return '';
           }
         }
-      } catch (error) {
-        logger.error({ msg: 'Error converting EditorJS blocks to markdown', error, block });
-        throw error;
+      } catch (err) {
+        logger.error({ message: 'Error converting EditorJS blocks to markdown', err, block });
+        throw err;
       }
     })
     .join('\n\n');
@@ -152,8 +152,8 @@ function loadPlaybooksFromDirectories(directories: string[]): Playbook[] {
         } else {
           logger.warn({ msg: `Invalid playbook structure in ${file}` });
         }
-      } catch (error) {
-        logger.error({ msg: `Failed to load playbook file ${file}: ${error}` });
+      } catch (err) {
+        logger.error({ message: `Failed to load playbook file ${file}: ${err}` });
       }
     }
   }

package/src/toolsLibrary/classifier.ts

@@ -76,14 +76,13 @@ export async function classify(content: string, config: ClassifierConfig, llm: B
       const classText = typeof result.content === 'string' ? result.content.trim() : '';
       return { class: classText };
     }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.error({ message: 'Classification failed, using default', error: errorMessage });
+  } catch (err) {
+    logger.error({ message: 'Classification failed, using default', err });
 
     // Return default classification on error
     return {
       class: mergedConfig.defaultClass || 'unknown',
-      reason: mergedConfig.defaultReason || errorMessage,
+      reason: mergedConfig.defaultReason || (err as Error).message,
       confidence: 0,
     };
   }
@@ -204,15 +203,14 @@ const classifierTool: Tool<typeof schema, any> = {
           },
         },
       };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
+    } catch (err) {
       logger.error({
         message: 'Classification failed',
         sessionId: state.sessionId,
-        error: errorMessage,
+        err,
       });
 
-      throw error;
+      throw err;
     }
   },
 };
@@ -258,14 +256,13 @@ ${content}`;
 
     // If single result returned, wrap in array
     return [result as ClassificationResult];
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.error({ message: 'Multi-classification failed', error: errorMessage });
+  } catch (err) {
+    logger.error({ message: 'Multi-classification failed', err });
 
     return [
       {
         class: mergedConfig.defaultClass || 'unknown',
-        reason: mergedConfig.defaultReason || errorMessage,
+        reason: mergedConfig.defaultReason || (err as Error).message,
         confidence: 0,
       },
     ];

package/src/toolsLibrary/parseDocument.ts

@@ -114,18 +114,18 @@ const parseDocumentTool: Tool<typeof schema, any> = {
           },
         },
       };
-    } catch (error) {
+    } catch (err) {
       logger.error({
-        msg: 'Failed to parse document',
+        message: 'Failed to parse document',
         sessionId: state.sessionId,
-        error: error instanceof Error ? error.message : String(error),
+        err,
       });
 
       return {
-        result: `Failed to parse document: ${error instanceof Error ? error.message : String(error)}`,
+        result: `Failed to parse document: ${err instanceof Error ? err.message : String(err)}`,
         state: {
           memory: {
-            documentParsingError: error instanceof Error ? error.message : String(error),
+            documentParsingError: err instanceof Error ? err.message : String(err),
           },
         },
       };

package/src/types/LangGraph.types.ts

@@ -49,6 +49,11 @@ export const createStateAnnotation = <Memory = any>() =>
       default: () => ({}),
       reducer: (a, b) => b,
     }),
+    // Available only when executing browser-use
+    cdpUrl: Annotation<string | null>({
+      default: () => null,
+      reducer: (a, b) => b,
+    }),
   });
 
 // Default state annotation with any memory type

package/src/types/Tools.types.ts

@@ -8,13 +8,14 @@ type StateUpdate<Memory = any> = Omit<Partial<State<Memory>>, 'memory'> & {
 };
 
 // Valid return type for new API
-export type ToolReturnType<Memory = any> = ({ state?: StateUpdate<Memory>; result?: any }) | void;
+export type ToolReturnType<Memory = any> = { state?: StateUpdate<Memory>; result?: any } | void;
 
 export interface Tool<Input extends z.ZodSchema, Memory = any> {
   name: string;
   description: string;
   input: Input;
   isGlobal?: boolean;
+  allowExecutionRequests?: boolean;
   execute: (input: ToolExecuteInput<Input, Memory>) => Promise<ToolReturnType<Memory>>;
 }
 

package/src/utils/agentUtils.ts

@@ -0,0 +1,68 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+
+import { getConfig } from '../platform/config';
+import { AppToolNode, Flow, NodeType } from '../types/Flows.types';
+import { mindedConnection } from '../platform/mindedConnection';
+import { mindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
+import libraryActionRunnerToolCreator from '../internalTools/libraryActionRunnerTool';
+
+export async function loadFlows(flowsDirectories: string[]) {
+  const { env, isDeployed } = getConfig();
+  if (['sandbox-staging', 'sandbox'].includes(env) && isDeployed) {
+    const response = await mindedConnection.awaitEmit<object, { flows: Record<string, Flow> }>(
+      mindedConnectionSocketMessageType.GET_FLOWS,
+      {},
+    );
+    if (!response?.flows) {
+      throw new Error('Could not load flows from the platform connection');
+    }
+    return Object.values(response.flows);
+  }
+  return loadFlowsFromDirectory(flowsDirectories);
+}
+
+export function loadFlowsFromDirectory(flowsDirectories: string[]): Flow[] {
+  const flows: Flow[] = [];
+  for (const flowsDirectory of flowsDirectories) {
+    if (!fs.existsSync(flowsDirectory)) {
+      throw new Error(`Flows directory does not exist: ${flowsDirectory}`);
+    }
+
+    const files = fs.readdirSync(flowsDirectory);
+
+    for (const file of files) {
+      if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+        const filePath = path.join(flowsDirectory, file);
+        try {
+          const fileContent = fs.readFileSync(filePath, 'utf8');
+          const parsedFlow = yaml.load(fileContent) as Flow;
+
+          // Validate that the parsed flow has the required structure
+          if (!parsedFlow.name || !parsedFlow.nodes || !parsedFlow.edges) {
+            throw new Error(`Invalid flow structure in ${file}. Flow must have name, nodes, and edges.`);
+          }
+
+          flows.push(parsedFlow);
+        } catch (err) {
+          throw new Error(`Failed to parse flow file ${file}: ${err}`);
+        }
+      }
+    }
+
+    if (flows.length === 0) {
+      throw new Error(`No YAML flow files found in directory: ${flowsDirectory}`);
+    }
+  }
+
+  return flows;
+}
+
+export function initLibraryActionsRunnerTools(flows: Flow[]) {
+  return flows
+    .flatMap((flow) =>
+      flow.nodes.filter((node): node is AppToolNode => node.type === NodeType.APP_TOOL && (node as AppToolNode).appName === 'Minded'),
+    )
+    .map((node) => libraryActionRunnerToolCreator(node.actionKey, node.displayName!));
+}

package/src/utils/extractStateMemoryResponse.ts

@@ -11,8 +11,8 @@ const extractToolStateResponse = (toolMessage: ToolMessage): Partial<State> => {
       }
       return parsed.state;
     }
-  } catch (error) {
-    logger.error({ msg: 'Error parsing tool state response', error });
+  } catch (err) {
+    logger.error({ message: 'Error parsing tool state response', err });
   }
   return {};
 };
@@ -23,70 +23,72 @@ const constructMessagesFromToolMessage = (messages: any[]): BaseMessage[] => {
     return [];
   }
 
-  return messages.map((messageObj) => {
-    try {
-      // Handle case where message is already a BaseMessage instance
-      if (messageObj instanceof BaseMessage) {
-        return messageObj;
-      }
+  return messages
+    .map((messageObj) => {
+      try {
+        // Handle case where message is already a BaseMessage instance
+        if (messageObj instanceof BaseMessage) {
+          return messageObj;
+        }
 
-      // Handle case where message is a plain object that needs reconstruction
-      const messageType = messageObj.id[2];
-      const content = messageObj.kwargs.content || '';
-      const id = messageObj.kwargs.id;
-      const additionalKwargs = messageObj.additional_kwargs || {};
+        // Handle case where message is a plain object that needs reconstruction
+        const messageType = messageObj.id[2];
+        const content = messageObj.kwargs.content || '';
+        const id = messageObj.kwargs.id;
+        const additionalKwargs = messageObj.additional_kwargs || {};
 
-      switch (messageType) {
-        case 'AIMessage':
-          return new AIMessage({
-            content,
-            id,
-            additional_kwargs: additionalKwargs,
-            tool_calls: messageObj.tool_calls || [],
-            invalid_tool_calls: messageObj.invalid_tool_calls || [],
-          });
-        case 'HumanMessage':
-          return new HumanMessage({
-            content,
-            id,
-            additional_kwargs: additionalKwargs,
-          });
-        case 'SystemMessage':
-          return new SystemMessage({
-            content,
-            id,
-            additional_kwargs: additionalKwargs,
-          });
-        case 'ToolMessage':
-          return new ToolMessage({
-            content,
-            id,
-            additional_kwargs: additionalKwargs,
-            tool_call_id: messageObj.tool_call_id || '',
-          });
+        switch (messageType) {
+          case 'AIMessage':
+            return new AIMessage({
+              content,
+              id,
+              additional_kwargs: additionalKwargs,
+              tool_calls: messageObj.tool_calls || [],
+              invalid_tool_calls: messageObj.invalid_tool_calls || [],
+            });
+          case 'HumanMessage':
+            return new HumanMessage({
+              content,
+              id,
+              additional_kwargs: additionalKwargs,
+            });
+          case 'SystemMessage':
+            return new SystemMessage({
+              content,
+              id,
+              additional_kwargs: additionalKwargs,
+            });
+          case 'ToolMessage':
+            return new ToolMessage({
+              content,
+              id,
+              additional_kwargs: additionalKwargs,
+              tool_call_id: messageObj.tool_call_id || '',
+            });
 
-        default:
-          // Default to HumanMessage for unknown types
-          logger.warn({
-            msg: 'Unknown message type, defaulting to HumanMessage',
-            messageType,
-            messageObj
-          });
-          return null;
+          default:
+            // Default to HumanMessage for unknown types
+            logger.warn({
+              msg: 'Unknown message type, defaulting to HumanMessage',
+              messageType,
+              messageObj,
+            });
+            return null;
+        }
+      } catch (err) {
+        logger.error({
+          msg: 'Error reconstructing message',
+          err,
+          messageObj,
+        });
+        // Return a fallback HumanMessage in case of error
+        return new HumanMessage({
+          content: messageObj.content || 'Error reconstructing message',
+          id: messageObj.id,
+        });
       }
-    } catch (error) {
-      logger.error({
-        msg: 'Error reconstructing message',
-        error,
-        messageObj
-      });
-      // Return a fallback HumanMessage in case of error
-      return new HumanMessage({
-        content: messageObj.content || 'Error reconstructing message',
-        id: messageObj.id,
-      });
-    }
-  }).filter(Boolean) as BaseMessage[];
+    })
+    .filter(Boolean) as BaseMessage[];
 };
 
 export default extractToolStateResponse;

package/src/utils/history.ts

@@ -1,4 +1,5 @@
-import { HistoryStep } from '../types/Agent.types';
+import { AppTriggerHistoryStep, HistoryStep, TriggerHistoryStep } from '../types/Agent.types';
+import { NodeType } from '../types/Flows.types';
 
 export const createHistoryStep = <T extends HistoryStep>(currentHistory: HistoryStep[], stepPayload: Omit<T, 'step'>): HistoryStep => {
   const lastHistoryStep = currentHistory?.[currentHistory?.length - 1];
@@ -7,3 +8,30 @@ export const createHistoryStep = <T extends HistoryStep>(currentHistory: History
     step: lastHistoryStep?.step + 1 || 0,
   } as HistoryStep;
 };
+
+export function createTriggerHistoryStep(
+  currentHistory: HistoryStep[],
+  nodeId: string,
+  messageIds: string[],
+  triggerName: string,
+  triggerBody: any,
+  appName?: string,
+): HistoryStep {
+  const baseStep = {
+    nodeId: nodeId,
+    nodeDisplayName: triggerName,
+    raw: triggerBody,
+    messageIds,
+  } as HistoryStep;
+
+  return appName
+    ? createHistoryStep<AppTriggerHistoryStep>(currentHistory, {
+        ...baseStep,
+        type: NodeType.TRIGGER,
+        appName,
+      })
+    : createHistoryStep<TriggerHistoryStep>(currentHistory, {
+        ...baseStep,
+        type: NodeType.TRIGGER,
+      });
+}

package/src/utils/logger.ts

@@ -19,4 +19,7 @@ export const logger = pino({
       return { level: label };
     },
   },
+  serializers: {
+    err: pino.stdSerializers.err,
+  },
 });

package/src/voice/voiceSession.ts

@@ -173,8 +173,8 @@ export class VoiceSession {
                 sessionId: this.sessionId,
                 timestamp: Date.now(),
               });
-            } catch (error) {
-              logger.error({ msg: '[Voice] Error sending interruption to dashboard', sessionId: this.sessionId, error });
+            } catch (err) {
+              logger.error({ message: '[Voice] Error sending interruption to dashboard', sessionId: this.sessionId, err });
             }
           }
           break;
@@ -191,8 +191,8 @@ export class VoiceSession {
                 timestamp: Date.now(),
                 type: mindedConnectionSocketMessageType.VOICE_AGENT_AUDIO,
               });
-            } catch (error) {
-              logger.error({ msg: '[Voice] Error sending audio to dashboard', sessionId: this.sessionId, error });
+            } catch (err) {
+              logger.error({ message: '[Voice] Error sending audio to dashboard', sessionId: this.sessionId, err });
             }
           }
           break;
@@ -210,8 +210,8 @@ export class VoiceSession {
               data.agent_response_correction_event.original_agent_response,
               data.agent_response_correction_event.corrected_agent_response,
             );
-          } catch (error) {
-            logger.error({ msg: '[Voice] Error updating agent response', sessionId: this.sessionId, error });
+          } catch (err) {
+            logger.error({ message: '[Voice] Error updating agent response', sessionId: this.sessionId, err });
           }
           break;
         default: