@minded-ai/mindedjs 1.0.128 → 1.0.130

package/src/platform/utils/tools.ts

@@ -0,0 +1,55 @@
+import { logger } from '../../utils/logger';
+
+/**
+ * Convert Zod schema to parameter format
+ * This is a simplified version - you might need to expand based on your needs
+ */
+export const zodSchemaToParams = (zodSchema: any): any[] => {
+  try {
+    // Get the shape of the Zod object
+    const shape = zodSchema._def?.shape?.() || {};
+    const params = [];
+
+    for (const [key, value] of Object.entries(shape)) {
+      const zodValue = value as any; // Zod schema type
+      const param: any = {
+        name: key,
+        type: getZodType(zodValue),
+        required: !zodValue.isOptional?.(),
+        description: zodValue._def?.description || '',
+      };
+
+      params.push(param);
+    }
+
+    return params;
+  } catch (error) {
+    logger.warn({
+      msg: '[ToolExecutor] Error parsing Zod schema',
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return [];
+  }
+};
+
+/**
+ * Get type string from Zod type
+ */
+const getZodType = (zodType: any): string => {
+  const typeName = zodType._def?.typeName;
+
+  switch (typeName) {
+    case 'ZodString':
+      return 'string';
+    case 'ZodNumber':
+      return 'number';
+    case 'ZodBoolean':
+      return 'boolean';
+    case 'ZodArray':
+      return 'array';
+    case 'ZodObject':
+      return 'object';
+    default:
+      return 'any';
+  }
+};

package/src/types/Flows.types.ts

@@ -120,6 +120,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/types/LangGraph.types.ts

@@ -49,6 +49,11 @@ export const createStateAnnotation = <Memory = any>() =>
       default: () => ({}),
       reducer: (a, b) => b,
     }),
+    // Available only when executing browser-use
+    cdpUrl: Annotation<string | null>({
+      default: () => null,
+      reducer: (a, b) => b,
+    }),
   });
 
 // Default state annotation with any memory type

package/src/types/Tools.types.ts

@@ -8,13 +8,14 @@ type StateUpdate<Memory = any> = Omit<Partial<State<Memory>>, 'memory'> & {
 };
 
 // Valid return type for new API
-export type ToolReturnType<Memory = any> = ({ state?: StateUpdate<Memory>; result?: any }) | void;
+export type ToolReturnType<Memory = any> = { state?: StateUpdate<Memory>; result?: any } | void;
 
 export interface Tool<Input extends z.ZodSchema, Memory = any> {
   name: string;
   description: string;
   input: Input;
   isGlobal?: boolean;
+  allowExecutionRequests?: boolean;
   execute: (input: ToolExecuteInput<Input, Memory>) => Promise<ToolReturnType<Memory>>;
 }
 

package/src/utils/agentUtils.ts

@@ -0,0 +1,68 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as yaml from 'js-yaml';
+
+import { getConfig } from '../platform/config';
+import { AppToolNode, Flow, NodeType } from '../types/Flows.types';
+import { mindedConnection } from '../platform/mindedConnection';
+import { mindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
+import libraryActionRunnerToolCreator from '../internalTools/libraryActionRunnerTool';
+
+export async function loadFlows(flowsDirectories: string[]) {
+  const { env, isDeployed } = getConfig();
+  if (['sandbox-staging', 'sandbox'].includes(env) && isDeployed) {
+    const response = await mindedConnection.awaitEmit<object, { flows: Record<string, Flow> }>(
+      mindedConnectionSocketMessageType.GET_FLOWS,
+      {},
+    );
+    if (!response?.flows) {
+      throw new Error('Could not load flows from the platform connection');
+    }
+    return Object.values(response.flows);
+  }
+  return loadFlowsFromDirectory(flowsDirectories);
+}
+
+export function loadFlowsFromDirectory(flowsDirectories: string[]): Flow[] {
+  const flows: Flow[] = [];
+  for (const flowsDirectory of flowsDirectories) {
+    if (!fs.existsSync(flowsDirectory)) {
+      throw new Error(`Flows directory does not exist: ${flowsDirectory}`);
+    }
+
+    const files = fs.readdirSync(flowsDirectory);
+
+    for (const file of files) {
+      if (file.endsWith('.yaml') || file.endsWith('.yml')) {
+        const filePath = path.join(flowsDirectory, file);
+        try {
+          const fileContent = fs.readFileSync(filePath, 'utf8');
+          const parsedFlow = yaml.load(fileContent) as Flow;
+
+          // Validate that the parsed flow has the required structure
+          if (!parsedFlow.name || !parsedFlow.nodes || !parsedFlow.edges) {
+            throw new Error(`Invalid flow structure in ${file}. Flow must have name, nodes, and edges.`);
+          }
+
+          flows.push(parsedFlow);
+        } catch (error) {
+          throw new Error(`Failed to parse flow file ${file}: ${error}`);
+        }
+      }
+    }
+
+    if (flows.length === 0) {
+      throw new Error(`No YAML flow files found in directory: ${flowsDirectory}`);
+    }
+  }
+
+  return flows;
+}
+
+export function initLibraryActionsRunnerTools(flows: Flow[]) {
+  return flows
+    .flatMap((flow) =>
+      flow.nodes.filter((node): node is AppToolNode => node.type === NodeType.APP_TOOL && (node as AppToolNode).appName === 'Minded'),
+    )
+    .map((node) => libraryActionRunnerToolCreator(node.actionKey, node.displayName!));
+}

package/src/utils/history.ts

@@ -1,4 +1,5 @@
-import { HistoryStep } from '../types/Agent.types';
+import { AppTriggerHistoryStep, HistoryStep, TriggerHistoryStep } from '../types/Agent.types';
+import { NodeType } from '../types/Flows.types';
 
 export const createHistoryStep = <T extends HistoryStep>(currentHistory: HistoryStep[], stepPayload: Omit<T, 'step'>): HistoryStep => {
   const lastHistoryStep = currentHistory?.[currentHistory?.length - 1];
@@ -7,3 +8,30 @@ export const createHistoryStep = <T extends HistoryStep>(currentHistory: History
     step: lastHistoryStep?.step + 1 || 0,
   } as HistoryStep;
 };
+
+export function createTriggerHistoryStep(
+  currentHistory: HistoryStep[],
+  nodeId: string,
+  messageIds: string[],
+  triggerName: string,
+  triggerBody: any,
+  appName?: string,
+): HistoryStep {
+  const baseStep = {
+    nodeId: nodeId,
+    nodeDisplayName: triggerName,
+    raw: triggerBody,
+    messageIds,
+  } as HistoryStep;
+
+  return appName
+    ? createHistoryStep<AppTriggerHistoryStep>(currentHistory, {
+        ...baseStep,
+        type: NodeType.TRIGGER,
+        appName,
+      })
+    : createHistoryStep<TriggerHistoryStep>(currentHistory, {
+        ...baseStep,
+        type: NodeType.TRIGGER,
+      });
+}