@minded-ai/mindedjs 1.0.124 → 1.0.126-beta-1

package/src/nodes/addToolRunNode.ts

@@ -57,7 +57,8 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
     const toolStateUpdate = extractToolStateResponse(toolCallMessage as ToolMessage);
 
     // Push the toolCallMessage into the messages array from toolStateUpdate
-    const updatedMessages = [toolCallMessage, ...((toolStateUpdate as any).messages || [])];
+    const updatedMessages = [toolCallMessage, ...((toolStateUpdate).messages || [])];
+
     // Return the full state update from the tool with the updated messages
 
     return {

package/src/nodes/compilePrompt.ts

@@ -31,7 +31,7 @@ function replacePlaceholders(text: string, params: Record<string, any>): string
       if (value && typeof value === 'object' && k in value) {
         value = value[k];
       } else {
-        logger.warn({ message: `Placeholder {${key}} in prompt not found in memory. It will remain as placeholder.` });
+        logger.warn({ message: `Placeholder {${key}} in prompt not found in params. It will remain as placeholder.` });
         return match; // Return original if key not found
       }
     }

package/src/platform/mindedConnectionTypes.ts

@@ -441,6 +441,7 @@ export interface UpdateStateRequest extends BasemindedConnectionSocketMessage {
 export interface CreateBrowserSessionRequest extends BasemindedConnectionSocketMessage {
   type: mindedConnectionSocketMessageType.CREATE_BROWSER_SESSION;
   proxy?: string; // 2-digit country code like 'IL'
+  onPrem?: boolean;
 }
 
 export interface CreateBrowserSessionResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {

package/src/playbooks/playbooks.ts

@@ -61,8 +61,8 @@ function editorJsToMarkdown(blocks: OutputBlockData[]): string {
             const items = block.data?.items || [];
             const style = block.data?.style || 'unordered';
             return items
-              .map((item: string, index: number) => {
-                const decodedItem = decodeHtmlEntities(item);
+              .map((item: { content: string }, index: number) => {
+                const decodedItem = decodeHtmlEntities(item.content);
                 if (style === 'ordered') {
                   return `${index + 1}. ${decodedItem}`;
                 } else {

package/src/types/Flows.types.ts

@@ -114,6 +114,7 @@ export interface BrowserTaskNode extends BaseNode {
   defaultPayload?: string;
   proxy?: string; // 2-digit country code like 'IL'
   hooks?: { name: string }[]; // Array of hooks to be passed to the browser-use lambda
+  onPrem?: boolean;
 }
 
 export type TriggerNode = AppTriggerNode | WebhookTriggerNode | ManualTriggerNode | VoiceTriggerNode | InterfaceTriggerNode;

package/src/utils/extractStateMemoryResponse.ts

@@ -1,10 +1,14 @@
-import { ToolMessage } from '@langchain/core/messages';
+import { BaseMessage, ToolMessage, AIMessage, HumanMessage, SystemMessage } from '@langchain/core/messages';
 import { logger } from './logger';
+import { State } from '../types/LangGraph.types';
 
-const extractToolStateResponse = <State>(toolMessage: ToolMessage): Partial<State> => {
+const extractToolStateResponse = (toolMessage: ToolMessage): Partial<State> => {
   try {
     const parsed = JSON.parse(toolMessage.content as string);
     if (typeof parsed === 'object' && parsed !== null && 'state' in parsed) {
+      if (parsed.state.messages) {
+        parsed.state.messages = constructMessagesFromToolMessage(parsed.state.messages);
+      }
       return parsed.state;
     }
   } catch (error) {
@@ -13,4 +17,76 @@ const extractToolStateResponse = <State>(toolMessage: ToolMessage): Partial<Stat
   return {};
 };
 
+const constructMessagesFromToolMessage = (messages: any[]): BaseMessage[] => {
+  if (!Array.isArray(messages)) {
+    logger.error({ msg: 'Expected messages to be an array', messages });
+    return [];
+  }
+
+  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 || {};
+
+      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;
+      }
+    } 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[];
+};
+
 export default extractToolStateResponse;