@minded-ai/mindedjs 3.1.43 → 3.1.45

package/src/nodes/addToolNode.ts

@@ -10,10 +10,11 @@ import { Agent } from '../agent';
 import { createHistoryStep } from '../utils/history';
 import { HistoryStep } from '../types/Agent.types';
 import { combinePlaybooks } from '../playbooks/playbooks';
-import { compileParameter, compilePrompt } from './compilePrompt';
+import { compilePrompt, compileNodeParameters } from './compilePrompt';
 import { AnalyticsEventName } from '../types/Analytics.types';
 import { trackAnalyticsEvent } from '../internalTools/analytics';
-import { z } from 'zod';
+import { inferToolCallWithRetry } from './utils/inferToolCallWithRetry';
+import { getSchemaForToolInference } from './utils/getSchemaForToolInference';
 
 export const addToolNode = async ({
   graph,
@@ -50,51 +51,18 @@ export const addToolNode = async ({
     await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
     logger.debug({ msg: `[Node] Executing tool node`, node: toolNode.displayName });
 
-    // Compile parameters with variable injection support
-    const compiledParameters: Record<string, any> = {};
-    const compileContext = { state, memory: state.memory, env: process.env };
-
-    for (const [key, value] of Object.entries(node.parameters || {})) {
-      if (value !== '') {
-        // If the value is a string, compile it to allow variable injection
-        if (typeof value === 'string') {
-          compiledParameters[key] = compileParameter(value, compileContext, key, matchedTool.input);
-        } else {
-          compiledParameters[key] = value;
-        }
-      }
-    }
+    const compiledParameters = compileNodeParameters(
+      node.parameters,
+      { state, memory: state.memory, env: process.env },
+      matchedTool.input,
+    );
 
-    // Create a filtered schema for the LLM (exclude overridden parameters)
-    let schemaForLLM = matchedTool.input;
     const overriddenKeys = Object.keys(compiledParameters);
-    let skipLLMCall = false;
-
-    if (overriddenKeys.length > 0) {
-      try {
-        // Only filter if it's a ZodObject
-        if (matchedTool.input instanceof z.ZodObject) {
-          // Create omit map: { key1: true, key2: true, ... }
-          const omitMap = overriddenKeys.reduce((acc, key) => {
-            acc[key] = true;
-            return acc;
-          }, {} as Record<string, true>);
-
-          schemaForLLM = matchedTool.input.omit(omitMap);
-
-          // Check if all parameters are overridden
-          const remainingKeys = Object.keys(schemaForLLM.shape);
-          skipLLMCall = remainingKeys.length === 0;
-        }
-      } catch (err) {
-        logger.warn({
-          msg: '[Tool] Failed to filter schema, using original',
-          tool: matchedTool.name,
-          err,
-        });
-        // Fall back to original schema on error
-      }
-    }
+    const { schemaForLLM, skipLLMCall } = getSchemaForToolInference({
+      inputSchema: matchedTool.input,
+      overriddenKeys,
+      toolName: matchedTool.name,
+    });
 
     let AIToolCallMessage: AIMessage;
 
@@ -115,12 +83,12 @@ export const addToolNode = async ({
       const tool = langchainTool(() => {}, {
         name: matchedTool.name,
         description: matchedTool.description,
-        schema: schemaForLLM, // Use filtered schema
+        schema: schemaForLLM as any, // Use filtered schema
       });
 
       const combinedPlaybooks = combinePlaybooks(agent.playbooks) || '';
-      const compiledNodePrompt = node.prompt ? compilePrompt(node.prompt, compileContext) : null;
-      const hasOverriddenParameters = overriddenKeys.length > 0;
+      const compiledNodePrompt = node.prompt ? compilePrompt(node.prompt, { state, memory: state.memory, env: process.env }) : null;
+      const hasOverriddenParameters = Object.keys(compiledParameters).length > 0;
 
       // Only build system message if there's actual content (playbooks, prompt, or overridden parameters)
       if (combinedPlaybooks || compiledNodePrompt || hasOverriddenParameters) {
@@ -172,20 +140,21 @@ export const addToolNode = async ({
           state.messages.unshift(systemMessage);
         }
       }
-
-      const startTime = Date.now();
-      AIToolCallMessage = 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);
-
-      // Merge AI-generated parameters with user-set parameters
-      if (AIToolCallMessage.tool_calls && AIToolCallMessage.tool_calls.length > 0) {
-        AIToolCallMessage.tool_calls[0].args = {
-          ...AIToolCallMessage.tool_calls[0].args,
+      AIToolCallMessage = await inferToolCallWithRetry({
+        llm,
+        tool,
+        inputSchema: matchedTool.input,
+        messages: state.messages,
+        sessionId: state.sessionId,
+        mergeArgs: (args) => ({
+          ...args,
           ...compiledParameters, // User-set parameters have priority over AI-generated parameters
-        };
-      }
+        }),
+        onAfterAttempt: async () => {
+          await agent.interruptSessionManager.checkQueueAndInterrupt(state.sessionId);
+        },
+        toolNameForLogs: matchedTool.name,
+      });
     }
 
     state.goto = null;

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,6 +6,13 @@ 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
@@ -129,29 +136,72 @@ export type ExtendedContextData = ContextData & {
  */
 export function compileParameter(parameter: string, context: ContextData = {}, inputKey?: string, inputSchema?: ZodSchema): any {
   try {
-    context = extendContextData(context);
+    return compileParameterWithContext(parameter, extendContextData(context), inputKey, inputSchema);
+  } catch (err) {
+    logger.error({ message: 'Error compiling parameter', err, parameter });
+    return parameter;
+  }
+}
 
-    // First, render with EJS
-    let compiledParameter = ejs.render(parameter, context).trim();
+/**
+ * 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);
+}
 
-    // 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);
+function compileValueDeepInternal(value: unknown, context: ExtendedContextData): any {
+  if (typeof value === 'string') {
+    try {
+      return compileParameterWithContext(value, context);
+    } catch (err) {
+      logger.error({ message: 'Error compiling nested parameter', err, value });
+      return value;
     }
+  }
+  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)]));
+}
 
-    compiledParameter = coerceValueWithZodType(compiledParameter, inputKey, inputSchema);
+/** Shared implementation — expects already-extended context. */
+function compileParameterWithContext(parameter: string, context: ExtendedContextData, inputKey?: string, inputSchema?: ZodSchema): any {
+  let compiledParameter = ejs.render(parameter, context).trim();
 
-    return compiledParameter;
-  } catch (err) {
-    logger.error({ message: 'Error compiling parameter', err, parameter });
-    return parameter; // Return uncompiled if there's an error
+  // 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 coerceValueWithZodType(compiledParameter, inputKey, inputSchema);
+}
+
+/**
+ * Compile node parameters with placeholder replacement and type coercion.
+ * Use getSchemaForToolInference() separately to filter the schema for the LLM.
+ */
+export function compileNodeParameters(
+  parameters: Record<string, any> | undefined,
+  context: ContextData,
+  schema?: ZodSchema,
+): Record<string, any> {
+  const compiledParameters: Record<string, any> = {};
+
+  for (const [key, value] of Object.entries(parameters || {})) {
+    if (value !== '') {
+      compiledParameters[key] = compileValueDeep(value, context, key, schema);
+    }
+  }
+
+  return compiledParameters;
 }
 
 /**
@@ -161,12 +211,8 @@ 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 });
@@ -215,10 +261,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(/\{([^}]+)}/g, (match, keyPath) => {
+  return text.replace(PLACEHOLDER_REGEX, (match, keyPathRaw) => {
+    const keyPath = String(keyPathRaw).trim();
     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;
+};

package/src/types/Flows.types.ts

@@ -158,6 +158,7 @@ export interface BrowserTaskNode extends BaseNode {
   model?: string;
   inputSchema?: SchemaField[];
   outputSchema?: OutputSchemaField[];
+  parameters?: Record<string, any>;
   autoTrigger?: boolean;
   defaultPayload?: string;
   proxyConfig?: ProxyConfig; // Proxy configuration supporting all proxy types
@@ -315,6 +316,7 @@ export type ActionInputParam = {
 export enum ActionInputParamType {
   String = 'string',
   Number = 'number',
+  Integer = 'integer',
   Boolean = 'boolean',
   Array = 'array',
   Object = 'object',