@minded-ai/mindedjs 3.1.43 → 3.1.44

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

@@ -315,6 +315,7 @@ export type ActionInputParam = {
 export enum ActionInputParamType {
   String = 'string',
   Number = 'number',
+  Integer = 'integer',
   Boolean = 'boolean',
   Array = 'array',
   Object = 'object',

package/src/utils/flowSchema.ts

@@ -373,9 +373,13 @@ export function safeParseFlow(flow: unknown): z.ZodSafeParseResult<FlowTypes.Flo
           return `Invalid ${subjectLabel}: "${toDotPath(issuePath)}" must be ${issue.expected}, received ${parsedType(issue.input)}`;
         }
       } else if (issue.code === 'invalid_value') {
-        const { subjectLabel } = getErrorSubject(issuePath, flow);
+        const { subjectLabel, fieldHint } = getErrorSubject(issuePath, flow);
         const allowedValues = `[${issue.values.join(', ')}]`;
-        return `Invalid ${subjectLabel}: "${toDotPath(issuePath)}" must be one of ${allowedValues}, received ${parsedType(issue.input)}`;
+        const receivedValue = typeof issue.input === 'string' ? `"${issue.input}"` : parsedType(issue.input);
+        if (fieldHint) {
+          return `Invalid ${subjectLabel}: ${fieldHint} must be one of ${allowedValues}, received ${receivedValue}`;
+        }
+        return `Invalid ${subjectLabel}: "${toDotPath(issuePath)}" must be one of ${allowedValues}, received ${receivedValue}`;
       } else if (issue.code === 'unrecognized_keys') {
         const { subjectLabel } = getErrorSubject(issuePath, flow);
         return `Invalid ${subjectLabel}: "${toDotPath(issuePath)}" unrecognized key "${issue.keys.join(', ')}"`;
@@ -430,16 +434,28 @@ export function safeParseFlow(flow: unknown): z.ZodSafeParseResult<FlowTypes.Flo
 function getErrorSubject(issuePath: PropertyKey[], flow: any) {
   let subject = 'flow';
   let subjectLabel: string | undefined;
+  let fieldHint: string | undefined;
   if (issuePath.length === 1) {
     subject = 'flow';
   } else if (issuePath.length >= 3 && issuePath[0] === 'nodes') {
     subject = 'node';
     const node = _.get(flow, issuePath.slice(0, 2));
     if (node && 'type' in node) {
+      const nodeName = node.name ? ` "${node.name}"` : '';
       if ('triggerType' in node) {
-        subjectLabel = `${node.triggerType} ${node.type} node`;
+        subjectLabel = `${node.triggerType} ${node.type} node${nodeName}`;
       } else {
-        subjectLabel = `${node.type} node`;
+        subjectLabel = `${node.type} node${nodeName}`;
+      }
+    }
+
+    // Provide human-readable hints for paths deep into metadata.schema[n]
+    if (issuePath.length >= 5 && issuePath[2] === 'metadata' && issuePath[3] === 'schema') {
+      const fieldIndex = issuePath[4] as number;
+      const schemaField = _.get(flow, ['nodes', issuePath[1], 'metadata', 'schema', fieldIndex]);
+      if (schemaField && 'name' in schemaField) {
+        const prop = issuePath.length > 5 ? `, property "${String(issuePath[issuePath.length - 1])}"` : '';
+        fieldHint = `schema field "${schemaField.name}"${prop}`;
       }
     }
   } else if (issuePath.length > 2 && issuePath[0] === 'edges') {
@@ -457,5 +473,6 @@ function getErrorSubject(issuePath: PropertyKey[], flow: any) {
   return {
     subject,
     subjectLabel,
+    fieldHint,
   };
 }

package/src/utils/schemaUtils.ts

@@ -25,6 +25,8 @@ export const mapItemTypeToZod = (
       return z.string();
     case 'number':
       return z.number();
+    case 'integer':
+      return z.number().int();
     case 'boolean':
       return z.boolean();
     case 'any':