@minded-ai/mindedjs 2.0.43 → 2.0.45-beta.1

package/src/types/Flows.types.ts

@@ -104,6 +104,33 @@ export interface ScheduleTriggerNode extends BaseTriggerNode {
   timezone?: string;
 }
 
+/**
+ * Base schema field type for backward compatibility with platform.
+ * Represents simple input/output schema fields (string and number only).
+ */
+export interface SchemaField {
+  name: string;
+  type: 'string' | 'number';
+  description?: string;
+  required?: boolean;
+}
+
+/**
+ * Extended schema field type with support for complex types (boolean, array, object).
+ * Uses Omit to override the 'type' field and intersection type (&) with Partial<> to
+ * elegantly add optional properties for complex types (items, properties).
+ * Filtered for backward compatibility when communicating with platform.
+ */
+export type OutputSchemaField = Omit<SchemaField, 'type'> & {
+  type: 'string' | 'number' | 'boolean' | 'array' | 'object';
+} & Partial<{
+    items: {
+      type: 'string' | 'number' | 'boolean' | 'object';
+      properties?: any;
+    };
+    properties: any;
+  }>;
+
 export interface PromptNode extends BaseNode {
   type: NodeType.PROMPT_NODE;
   prompt: string;
@@ -114,6 +141,7 @@ export interface ThinkingNode extends BaseNode {
   type: NodeType.THINKING;
   prompt: string;
   llmConfig?: LLMConfig;
+  outputSchema?: OutputSchemaField[];
 }
 
 export interface JumpToNode extends BaseNode {
@@ -125,18 +153,8 @@ export interface BrowserTaskNode extends BaseNode {
   type: NodeType.BROWSER_TASK;
   prompt: string;
   model?: string;
-  inputSchema?: {
-    name: string;
-    type: 'string' | 'number';
-    description?: string;
-    required?: boolean;
-  }[];
-  outputSchema?: {
-    name: string;
-    type: 'string' | 'number';
-    description?: string;
-    required?: boolean;
-  }[];
+  inputSchema?: SchemaField[];
+  outputSchema?: OutputSchemaField[];
   autoTrigger?: boolean;
   defaultPayload?: string;
   proxy?: string; // 2-digit country code like 'IL'
@@ -166,17 +184,7 @@ export interface RpaStep {
   shouldReplaceExistingText?: boolean;
   waitTime?: number;
   description?: string;
-  outputSchema?: {
-    name: string;
-    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
-    description?: string;
-    required?: boolean;
-    items?: {
-      type: 'string' | 'number' | 'boolean' | 'object';
-      properties?: any;
-    };
-    properties?: any;
-  }[];
+  outputSchema?: OutputSchemaField[];
 }
 
 export type TriggerNode =
@@ -197,6 +205,13 @@ export interface ToolNode extends BaseNode {
   prompt: string;
   appImgSrc?: string;
   parameters?: Record<string, any>;
+  inputSchema?: {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'array';
+    description?: string;
+    required?: boolean;
+  }[];
+  outputSchema?: OutputSchemaField[];
 }
 
 export interface AppToolNode extends BaseNode, BaseAppNode {
@@ -208,15 +223,7 @@ export interface AppToolNode extends BaseNode, BaseAppNode {
   actionKey: string;
 }
 
-export type Node =
-  | TriggerNode
-  | JunctionNode
-  | ToolNode
-  | AppToolNode
-  | PromptNode
-  | JumpToNode
-  | BrowserTaskNode
-  | ThinkingNode;
+export type Node = TriggerNode | JunctionNode | ToolNode | AppToolNode | PromptNode | JumpToNode | BrowserTaskNode | ThinkingNode;
 
 export interface BaseEdge {
   source: string;

package/src/types/Tools.types.ts

@@ -8,13 +8,16 @@ import { BrowserTaskMode } from '../browserTask/types';
 export type ToolReturnType = { result?: any } | void;
 
 // Tool can be either RPA or Default
-export type Tool<Input extends z.ZodSchema, Memory = any> = RPATool<Input, Memory> | DefaultTool<Input, Memory>;
+export type Tool<Input extends z.ZodSchema, Memory = any, Output extends z.ZodSchema = any> =
+  | RPATool<Input, Memory, Output>
+  | DefaultTool<Input, Memory, Output>;
 
 // RPA Tool - always includes Page
-export interface RPATool<Input extends z.ZodSchema, Memory = any> {
+export interface RPATool<Input extends z.ZodSchema, Memory = any, Output extends z.ZodSchema = any> {
   name: string;
   description: string;
   input: Input;
+  output?: Output;
   isGlobal?: boolean;
   allowExecutionRequests?: boolean;
   type: 'rpa';
@@ -24,10 +27,11 @@ export interface RPATool<Input extends z.ZodSchema, Memory = any> {
 }
 
 // Default Tool - no Page parameter
-export interface DefaultTool<Input extends z.ZodSchema, Memory = any> {
+export interface DefaultTool<Input extends z.ZodSchema, Memory = any, Output extends z.ZodSchema = any> {
   name: string;
   description: string;
   input: Input;
+  output?: Output;
   isGlobal?: boolean;
   allowExecutionRequests?: boolean;
   type?: 'default';

package/src/utils/schemaConverter.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { OutputSchemaField } from '../types/Flows.types';
+import { logger } from './logger';
+
+export function convertArraySchemaToZod(schemaArray: unknown): z.ZodObject<any> {
+  if (schemaArray && typeof schemaArray === 'object' && '_def' in schemaArray) {
+    return schemaArray as z.ZodObject<any>;
+  }
+
+  if (!Array.isArray(schemaArray) || schemaArray.length === 0) {
+    logger.warn({ message: 'Empty or invalid schema array provided to convertArraySchemaToZod', schemaArray });
+    return z.object({});
+  }
+
+  const typeMap: Record<string, (field: OutputSchemaField) => z.ZodTypeAny> = {
+    string: () => z.string(),
+    number: () => z.number(),
+    boolean: () => z.boolean(),
+    // For arrays, check if items are defined, otherwise default to string array
+    array: (field) => {
+      if (field.items?.type) {
+        const itemTypeMap: Record<string, z.ZodTypeAny> = {
+          string: z.string(),
+          number: z.number(),
+          boolean: z.boolean(),
+        };
+        return z.array(itemTypeMap[field.items.type] || z.string());
+      }
+      return z.array(z.string());
+    },
+    // For objects, create a record type that allows any key-value pairs
+    // OpenAI's structured outputs don't support truly dynamic objects well
+    // So we use record(string, string) which is the most flexible allowed format
+    object: (field) => {
+      if (field.properties && Object.keys(field.properties).length > 0) {
+        // If properties are defined, create a structured object
+        const shape = Object.fromEntries(
+          Object.entries(field.properties).map(([key, value]: [string, any]) => {
+            const propType = value.type || 'string';
+            const propTypeMap: Record<string, z.ZodTypeAny> = {
+              string: z.string(),
+              number: z.number(),
+              boolean: z.boolean(),
+            };
+            return [key, propTypeMap[propType] || z.string()];
+          }),
+        );
+        return z.object(shape);
+      }
+      // If no properties defined, use record(string, string) for maximum compatibility
+      // This allows any key-value pairs where values are strings
+      return z.record(z.string(), z.string());
+    },
+  };
+
+  const shape = Object.fromEntries(
+    schemaArray.map((field: OutputSchemaField) => {
+      const typeFunc = typeMap[field.type];
+      let schema = typeFunc ? typeFunc(field) : z.any();
+
+      if (field.description) {
+        schema = schema.describe(field.description);
+      }
+
+      // OpenAI's structured outputs require all fields in the 'required' array
+      // To make a field optional, we use .nullable() which means the field is required but can be null
+      // This satisfies OpenAI's requirement while allowing optional fields
+      if (!field.required) {
+        schema = schema.nullable();
+      }
+
+      return [field.name, schema];
+    }),
+  );
+
+  // Create the final Zod object
+  // Note: All fields will be in the 'required' array for OpenAI's JSON schema
+  // Optional fields are handled by .nullable() above
+  const zodObject = z.object(shape);
+
+  return zodObject;
+}