@minded-ai/mindedjs 3.1.43-beta.3 → 3.1.44

package/src/nodes/addToolRunNode.ts

@@ -35,55 +35,50 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
     const { env, browserTaskMode } = getConfig();
 
     const executeWrapper = async (input: z.infer<typeof matchedTool.input>) => {
-      try {
-        const startTime = Date.now();
-
-        // Check if this is an RPA tool
-        if (matchedTool.type === 'rpa') {
-          // Wrap with browser session and screenshot capture
-          const { result, breakpointHit, breakpointInfo } = await withBrowserSession(
-            {
-              sessionId: state.sessionId,
-              browserTaskMode: matchedTool.browserTaskMode ?? browserTaskMode,
-              toolCallId: toolCallObj.tool_calls[0].id,
-              proxyConfig: matchedTool.proxyConfig,
-              toolName: matchedTool.name,
-              persistSession: matchedTool.persistSession,
-              checkBreakpoints: env === Environment.DEVELOPMENT,
-            },
-            async (page) => {
-              // Pass page directly to RPA tool execution
-              const toolResult = await matchedTool.execute({
-                input,
-                state,
-                agent,
-                page,
-              });
-
-              return toolResult;
-            },
-          );
-
-          const endTime = Date.now();
-          logger.debug({ msg: '[Tool] RPA tool execution time', tool: matchedTool.name, executionTimeMs: endTime - startTime });
-
-          // Check if breakpoint was hit - return special result
-          if (breakpointHit && breakpointInfo) {
-            return { breakpointHit: true, breakpointInfo } as unknown as ToolMessage;
-          }
-
-          return result as ToolMessage;
-        } else {
-          // Non-RPA tool - execute normally
-          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 as ToolMessage;
+      const startTime = Date.now();
+
+      // Check if this is an RPA tool
+      if (matchedTool.type === 'rpa') {
+        // Wrap with browser session and screenshot capture
+        const { result, breakpointHit, breakpointInfo } = await withBrowserSession(
+          {
+            sessionId: state.sessionId,
+            browserTaskMode: matchedTool.browserTaskMode ?? browserTaskMode,
+            toolCallId: toolCallObj.tool_calls[0].id,
+            proxyConfig: matchedTool.proxyConfig,
+            toolName: matchedTool.name,
+            persistSession: matchedTool.persistSession,
+            checkBreakpoints: env === Environment.DEVELOPMENT,
+          },
+          async (page) => {
+            // Pass page directly to RPA tool execution
+            const toolResult = await matchedTool.execute({
+              input,
+              state,
+              agent,
+              page,
+            });
+
+            return toolResult;
+          },
+        );
+
+        const endTime = Date.now();
+        logger.debug({ msg: '[Tool] RPA tool execution time', tool: matchedTool.name, executionTimeMs: endTime - startTime });
+
+        // Check if breakpoint was hit - return special result
+        if (breakpointHit && breakpointInfo) {
+          return { breakpointHit: true, breakpointInfo } as unknown as ToolMessage;
         }
-      } catch (err) {
-        logger.error({ message: '[Tool] Error executing tool', err, node: toolNode.displayName });
-        throw err;
+
+        return result as ToolMessage;
       }
+
+      // Non-RPA tool - execute normally
+      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 as ToolMessage;
     };
 
     const toolCallObj = state.messages[state.messages.length - 1] as any;
@@ -95,72 +90,94 @@ export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeNam
     const toolCall = toolCallObj.tool_calls[0];
     const parsedArgs = matchedTool.input.parse(toolCall.args);
 
-    // Execute the tool with validated args
-    const result = await executeWrapper(parsedArgs);
-
-    // Check if breakpoint was hit - handle gracefully by ending the flow
-    const resultObj = result as unknown as { breakpointHit?: boolean; breakpointInfo?: BreakpointHitResult };
-    if (resultObj?.breakpointHit && resultObj?.breakpointInfo) {
-      logger.info({
-        msg: '[Tool] RPA breakpoint hit - ending flow gracefully',
-        toolName: matchedTool.name,
-        stepNumber: resultObj.breakpointInfo.stepNumber,
-      });
+    try {
+      // Execute the tool with validated args
+      const result = await executeWrapper(parsedArgs);
 
-      // Create a ToolMessage indicating breakpoint was hit
-      const breakpointMessage = new ToolMessage({
-        content: JSON.stringify({
-          breakpointHit: true,
-          message: `RPA breakpoint reached at step ${resultObj.breakpointInfo.stepNumber + 1}`,
-          toolName: resultObj.breakpointInfo.toolName,
+      // Check if breakpoint was hit - handle gracefully by ending the flow
+      const resultObj = result as unknown as { breakpointHit?: boolean; breakpointInfo?: BreakpointHitResult };
+      if (resultObj?.breakpointHit && resultObj?.breakpointInfo) {
+        logger.info({
+          msg: '[Tool] RPA breakpoint hit - ending flow gracefully',
+          toolName: matchedTool.name,
           stepNumber: resultObj.breakpointInfo.stepNumber,
-        }),
+        });
+
+        // Create a ToolMessage indicating breakpoint was hit
+        const breakpointMessage = new ToolMessage({
+          content: JSON.stringify({
+            breakpointHit: true,
+            message: `RPA breakpoint reached at step ${resultObj.breakpointInfo.stepNumber + 1}`,
+            toolName: resultObj.breakpointInfo.toolName,
+            stepNumber: resultObj.breakpointInfo.stepNumber,
+          }),
+          tool_call_id: toolCall.id,
+          name: matchedTool.name,
+        });
+
+        state.messages.push(breakpointMessage);
+        state.history.push(
+          createHistoryStep<HistoryStep>(state.history, {
+            type: NodeType.TOOL,
+            nodeId: toolNode.name,
+            nodeDisplayName: toolNode.displayName,
+            raw: breakpointMessage,
+            messageIds: [toolCall.id],
+          }),
+        );
+
+        // Set goto to __end__ to stop the flow gracefully
+        state.goto = '__end__';
+        return state;
+      }
+
+      // Create a ToolMessage with the result
+      const toolCallMessage = new ToolMessage({
+        content: typeof result === 'string' ? result : JSON.stringify(result),
         tool_call_id: toolCall.id,
         name: matchedTool.name,
       });
 
-      state.messages.push(breakpointMessage);
+      // Add the tool message to the state
+      state.messages.push(toolCallMessage);
+
+      // Add history step
       state.history.push(
         createHistoryStep<HistoryStep>(state.history, {
           type: NodeType.TOOL,
           nodeId: toolNode.name,
           nodeDisplayName: toolNode.displayName,
-          raw: breakpointMessage,
-          messageIds: [toolCallObj.tool_calls[0].id],
+          raw: toolCallMessage,
+          messageIds: [toolCall.id],
         }),
       );
 
-      // Set goto to __end__ to stop the flow gracefully
-      state.goto = '__end__';
+      // Clear goto if it was set
+      state.goto = null;
+
+      // Return the entire modified state
       return state;
-    }
+    } catch (err) {
+      logger.error({ message: '[Tool] Error executing tool', err, node: toolNode.displayName });
+
+      const errorMessage = err instanceof Error ? err.message : JSON.stringify(err);
+      const toolErrorMessage = new ToolMessage({
+        content: JSON.stringify({ error: errorMessage }),
+        tool_call_id: toolCall.id,
+        name: matchedTool.name,
+      });
 
-    // Create a ToolMessage with the result
-    const toolCallMessage = new ToolMessage({
-      content: typeof result === 'string' ? result : JSON.stringify(result),
-      tool_call_id: toolCall.id,
-      name: matchedTool.name,
-    });
-
-    // Add the tool message to the state
-    state.messages.push(toolCallMessage);
-
-    // 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;
+      state.messages.push(toolErrorMessage);
+      state.history.push(
+        createHistoryStep<HistoryStep>(state.history, {
+          type: NodeType.TOOL,
+          nodeId: toolNode.name,
+          nodeDisplayName: toolNode.displayName,
+          raw: toolErrorMessage,
+          messageIds: [toolCall.id],
+        }),
+      );
+    }
   };
 
   graph.addNode(buildToolRunNodeName(attachedToNodeName), callback);

package/src/nodes/compilePrompt.ts

@@ -6,13 +6,6 @@ import { HistoryStep, TriggerHistoryStep } from '../types/Agent.types';
 import { State } from '../types/LangGraph.types';
 import { NodeType } from '../types/Flows.types';
 
-// Matches dotted path identifiers — allows letters, digits, `_`, `$`, `.`, `[`, `]`, spaces, and hyphens
-// (spaces/hyphens support node display names like "Greeting Prompt" and trigger keys like "some-key").
-// Implicitly rejects JSON braces (which contain `"` and `:`) since those chars are not in the set.
-const PLACEHOLDER_PATH_CHARS = String.raw`[A-Za-z0-9_.$\[\] -]`;
-const PLACEHOLDER_REGEX = new RegExp(String.raw`\{\s*([A-Za-z_$]${PLACEHOLDER_PATH_CHARS}*)\s*\}`, 'g');
-const SINGLE_PLACEHOLDER_REGEX = new RegExp(String.raw`^\{\s*([A-Za-z_$]${PLACEHOLDER_PATH_CHARS}*)\s*\}$`);
-
 /**
  * Extract node outputs from state.history and state.messages
  * Returns a map of nodeId/nodeDisplayName -> output object
@@ -136,45 +129,29 @@ export type ExtendedContextData = ContextData & {
  */
 export function compileParameter(parameter: string, context: ContextData = {}, inputKey?: string, inputSchema?: ZodSchema): any {
   try {
-    return compileParameterWithContext(parameter, extendContextData(context), inputKey, inputSchema);
-  } catch (err) {
-    logger.error({ message: 'Error compiling parameter', err, parameter });
-    return parameter;
-  }
-}
+    context = extendContextData(context);
 
-/**
- * Recursively compile placeholders inside nested objects/arrays.
- * Top-level strings get full schema-based coercion; nested string leaves are compiled without schema coercion.
- */
-export function compileValueDeep(value: unknown, context: ContextData = {}, inputKey?: string, inputSchema?: ZodSchema): any {
-  if (typeof value === 'string') return compileParameter(value, context, inputKey, inputSchema);
-  if (!value || typeof value !== 'object') return value;
-  const extCtx = extendContextData(context);
-  return compileValueDeepInternal(value, extCtx);
-}
+    // First, render with EJS
+    let compiledParameter = ejs.render(parameter, context).trim();
 
-function compileValueDeepInternal(value: unknown, context: ExtendedContextData): any {
-  if (typeof value === 'string') return compileParameterWithContext(value, context);
-  if (!value || typeof value !== 'object') return value;
-  if (Array.isArray(value)) return value.map((v) => compileValueDeepInternal(v, context));
-  return Object.fromEntries(Object.entries(value as Record<string, unknown>).map(([k, v]) => [k, compileValueDeepInternal(v, context)]));
-}
+    // Then, replace placeholders in {} format
+    // If the result contains only one set of curly braces, get the native value at that key path, e.g., {state.memory.arrayOfStrings} -> state.memory.arrayOfStrings
+    // Otherwise, compile it into a string.
+    const keyPathMatch = compiledParameter.match(/^\{([^}]+)}$/);
+    if (keyPathMatch) {
+      const keyPath = keyPathMatch[1];
+      compiledParameter = getContextValueFromPath(keyPath, context, compiledParameter);
+    } else {
+      compiledParameter = replacePlaceholders(compiledParameter, context);
+    }
 
-/** Shared implementation — expects already-extended context. */
-function compileParameterWithContext(parameter: string, context: ExtendedContextData, inputKey?: string, inputSchema?: ZodSchema): any {
-  let compiledParameter = ejs.render(parameter, context).trim();
+    compiledParameter = coerceValueWithZodType(compiledParameter, inputKey, inputSchema);
 
-  // Single placeholder → return native value; otherwise replace all placeholders as strings.
-  // Regex matches path identifiers (allows spaces/hyphens for node display names), rejects JSON braces.
-  const keyPathMatch = compiledParameter.match(SINGLE_PLACEHOLDER_REGEX);
-  if (keyPathMatch) {
-    compiledParameter = getContextValueFromPath(keyPathMatch[1].trim(), context, compiledParameter);
-  } else {
-    compiledParameter = replacePlaceholders(compiledParameter, context);
+    return compiledParameter;
+  } catch (err) {
+    logger.error({ message: 'Error compiling parameter', err, parameter });
+    return parameter; // Return uncompiled if there's an error
   }
-
-  return coerceValueWithZodType(compiledParameter, inputKey, inputSchema);
 }
 
 /**
@@ -184,8 +161,12 @@ export function compilePrompt(prompt: string, context: ContextData): string {
   try {
     context = extendContextData(context);
 
+    // First, render with EJS
     let compiledPrompt = ejs.render(prompt, context);
+
+    // Then, replace placeholders in {} format
     compiledPrompt = replacePlaceholders(compiledPrompt, context);
+
     return compiledPrompt;
   } catch (err) {
     logger.error({ message: 'Error compiling prompt', err, prompt });
@@ -234,10 +215,10 @@ function extendContextData(context: ContextData = {}): ExtendedContextData {
  * - {tools.NodeName.field} - node reference with 'tools' prefix (alias)
  */
 function replacePlaceholders(text: string, context: Record<string, any>): string {
-  return text.replace(PLACEHOLDER_REGEX, (match, keyPathRaw) => {
-    const keyPath = String(keyPathRaw).trim();
+  return text.replace(/\{([^}]+)}/g, (match, keyPath) => {
     const value = getContextValueFromPath(keyPath, context, match);
 
+    // In the case of complex values (e.g., arrays or objects), JSON stringify them to ensure all data is preserved.
     if (Array.isArray(value) || (typeof value === 'object' && value !== null)) {
       try {
         return JSON.stringify(value);

package/src/nodes/utils/getSchemaForToolInference.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { logger } from '../../utils/logger';
+
+interface GetSchemaForToolInferenceParams {
+  inputSchema: z.ZodTypeAny;
+  overriddenKeys: string[];
+  toolName: string;
+}
+
+interface GetSchemaForToolInferenceResult {
+  schemaForLLM: z.ZodTypeAny;
+  skipLLMCall: boolean;
+}
+
+export const getSchemaForToolInference = ({
+  inputSchema,
+  overriddenKeys,
+  toolName,
+}: GetSchemaForToolInferenceParams): GetSchemaForToolInferenceResult => {
+  let schemaForLLM = inputSchema;
+  let skipLLMCall = false;
+
+  if (overriddenKeys.length === 0) {
+    return { schemaForLLM, skipLLMCall };
+  }
+
+  try {
+    if (inputSchema instanceof z.ZodObject) {
+      const omitMap = overriddenKeys.reduce((acc, key) => {
+        acc[key] = true;
+        return acc;
+      }, {} as Record<string, true>);
+
+      const filteredSchema = inputSchema.omit(omitMap);
+      schemaForLLM = filteredSchema;
+      const remainingKeys = Object.keys(filteredSchema.shape);
+      skipLLMCall = remainingKeys.length === 0;
+    }
+  } catch (err) {
+    logger.warn({
+      msg: '[Tool] Failed to filter schema, using original',
+      tool: toolName,
+      err,
+    });
+  }
+
+  return { schemaForLLM, skipLLMCall };
+};

package/src/nodes/utils/inferToolCallWithRetry.ts

@@ -0,0 +1,89 @@
+import { AIMessage, BaseMessage, SystemMessage } from '@langchain/core/messages';
+import { z } from 'zod';
+import { logger } from '../../utils/logger';
+
+interface InferToolCallWithRetryParams {
+  llm: any;
+  tool: { name: string };
+  inputSchema: z.ZodTypeAny;
+  messages: BaseMessage[];
+  sessionId: string;
+  mergeArgs?: (args: Record<string, any>) => Record<string, any>;
+  onAfterAttempt?: () => Promise<void>;
+  maxAttempts?: number;
+  toolNameForLogs: string;
+}
+
+export const inferToolCallWithRetry = async ({
+  llm,
+  tool,
+  inputSchema,
+  messages,
+  sessionId,
+  mergeArgs,
+  onAfterAttempt,
+  maxAttempts = 2,
+  toolNameForLogs,
+}: InferToolCallWithRetryParams): Promise<AIMessage> => {
+  let inferenceMessages = [...messages];
+  let aiToolCallMessage: AIMessage = new AIMessage({ content: '', tool_calls: [] });
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    aiToolCallMessage = await llm.bindTools([tool], { tool_choice: tool.name }).invoke(inferenceMessages);
+    if (onAfterAttempt) {
+      await onAfterAttempt();
+    }
+
+    if (!aiToolCallMessage.tool_calls || aiToolCallMessage.tool_calls.length === 0) {
+      throw new Error('No tool calls generated by LLM');
+    }
+
+    const inferredArgs = (aiToolCallMessage.tool_calls[0].args || {}) as Record<string, any>;
+    const mergedArgs = mergeArgs ? mergeArgs(inferredArgs) : inferredArgs;
+    const parseResult = inputSchema.safeParse(mergedArgs);
+
+    if (parseResult.success) {
+      aiToolCallMessage.tool_calls[0].args = parseResult.data;
+      return aiToolCallMessage;
+    }
+
+    if (attempt < maxAttempts) {
+      const validationIssues = parseResult.error.issues
+        .map((issue: z.ZodIssue) => `${issue.path.join('.') || '<root>'}: ${issue.message}`)
+        .join('; ');
+
+      logger.error({
+        msg: '[Tool] Retrying parameter inference due to schema mismatch',
+        tool: toolNameForLogs,
+        sessionId,
+        attempt,
+        validationIssues,
+      });
+
+      inferenceMessages = [
+        ...inferenceMessages,
+        new SystemMessage(
+          `Your previous tool arguments were invalid for tool "${tool.name}".
+Validation issues: ${validationIssues}
+Return arguments that strictly match the tool schema types. Do not wrap scalar values in arrays.`,
+        ),
+      ];
+      continue;
+    }
+
+    logger.error({
+      msg: '[Tool] Inferred parameters remain schema-invalid after retries',
+      tool: toolNameForLogs,
+      sessionId,
+      validationIssues: parseResult.error.issues.map((issue: z.ZodIssue) => ({
+        path: issue.path.join('.') || '<root>',
+        message: issue.message,
+      })),
+    });
+
+    aiToolCallMessage.tool_calls[0].args = mergedArgs;
+    return aiToolCallMessage;
+  }
+
+  return aiToolCallMessage;
+};