@minded-ai/mindedjs 1.0.103 → 1.0.105

package/src/internalTools/documentExtraction/types.ts

@@ -0,0 +1,59 @@
+import { ZodType as ZodSchema, ZodTypeAny } from 'zod';
+
+export interface DocumentProcessorConfig {
+  llamaCloudApiKey?: string;
+  useBase64?: boolean;
+  maxImageWidth?: number;
+  imageQuality?: number;
+}
+export interface DocumentExtractionOptions {
+  documentPath?: string;
+  documentContent?: Buffer | string;
+  documentUrl?: string;
+  schema?: ZodSchema<any> | ZodTypeAny;
+  llmConfig?: {
+    model?: string;
+    temperature?: number;
+  };
+  systemPrompt?: string;
+}
+export interface DocumentProcessingResult<T = any> {
+  data: T;
+  metadata: {
+    fileSize?: number;
+    fileType: string;
+    processingTime: number;
+    contentLength: number;
+  };
+}
+export const SUPPORTED_DOCUMENT_TYPES = [
+  // Images
+  '.jpg',
+  '.jpeg',
+  '.png',
+  '.gif',
+  '.bmp',
+  '.webp',
+  '.tiff',
+  // Documents
+  '.pdf',
+  '.doc',
+  '.docx',
+  '.txt',
+  '.rtf',
+  '.odt',
+  // Spreadsheets
+  '.xls',
+  '.xlsx',
+  '.csv',
+  '.ods',
+  // Presentations
+  '.ppt',
+  '.pptx',
+  '.odp',
+  // Other formats
+  '.html',
+  '.htm',
+  '.md',
+  '.xml',
+];

package/src/internalTools/libraryActionRunnerTool.ts

@@ -0,0 +1,63 @@
+import { Tool, ToolExecuteInput } from '../types/Tools.types';
+import { tools } from '../toolsLibrary';
+import { logger } from '../utils/logger';
+
+const libraryActionRunnerToolCreator = (actionKey: string, nodeTitle: string): Tool<any, any> => {
+  // Find the corresponding library tool by key name (e.g., "parseDocument")
+  const libraryTool = (tools as any)[actionKey];
+
+  if (!libraryTool?.default) {
+    throw new Error(`Library tool '${actionKey}' not found in toolsLibrary`);
+  }
+
+  if (!libraryTool.schema) {
+    throw new Error(`Schema not found for library tool '${actionKey}'. Make sure the tool exports a 'schema' object.`);
+  }
+
+  const zodSchema = libraryTool.schema;
+
+  // Create a description using the library tool's own description
+  const description = libraryTool.default.description || `Run ${nodeTitle} action from Minded Tools library.`;
+
+  const tool = {
+    name: nodeTitle,
+    description,
+    input: zodSchema,
+    execute: async ({ input, state, agent }: ToolExecuteInput<typeof zodSchema>) => {
+      try {
+        // Find the corresponding library tool
+        const libraryTool = Object.values(tools).find((toolModule) => toolModule.default && toolModule.default.name === actionKey);
+
+        if (!libraryTool?.default) {
+          throw new Error(`Library tool '${actionKey}' not found in toolsLibrary`);
+        }
+
+        logger.debug({
+          msg: `[Tool] Executing library tool`,
+          toolName: actionKey,
+          nodeTitle,
+        });
+
+        // Execute the library tool directly
+        const result = await libraryTool.default.execute({ input, state, agent });
+
+        return {
+          state: result?.state,
+          result: result?.result,
+        };
+      } catch (error) {
+        logger.error({
+          msg: `[Tool] Error executing library tool`,
+          error,
+          toolName: actionKey,
+          nodeTitle,
+        });
+        throw error;
+      }
+    },
+  };
+
+  return tool;
+};
+
+export default libraryActionRunnerToolCreator;

package/src/nodes/addAppToolNode.ts

@@ -5,26 +5,35 @@ import { SystemMessage } from '@langchain/core/messages';
 import { RunnableLike } from '@langchain/core/runnables';
 import { z } from 'zod';
 import { LLMProviders } from '../types/LLM.types';
-import { getAppActionRunnerTool } from '../internalTools/appActionRunnerTool';
 import { AppActionInvocationHistoryStep } from '../types/Agent.types';
 import { Agent } from '../agent';
 import { logger } from '../utils/logger';
 import { compilePlaybooks } from '../playbooks/playbooks';
 import { createHistoryStep } from '../utils/history';
+import { Tool } from '../types/Tools.types';
 
 export const addAppToolNode = async ({
   graph,
   node,
   llm,
   agent,
+  tools,
 }: {
   graph: PreCompiledGraph;
   node: AppToolNode;
   llm: (typeof LLMProviders)[keyof typeof LLMProviders];
   agent: Agent;
+  tools: Tool<any, any>[];
 }) => {
   const cleanedParameters = Object.fromEntries(Object.entries(node.parameters || {}).filter(([, value]) => value !== ''));
-  const appRunnerTool = getAppActionRunnerTool(node.displayName!);
+
+  // Find the tool from the tools array by name
+  const appRunnerTool = tools.find((tool) => tool.name === node.displayName);
+
+  if (!appRunnerTool) {
+    throw new Error(`Tool not found for node: ${node.displayName}`);
+  }
+
   const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
     logger.debug({ msg: `[Node] Executing tool node`, node: appRunnerTool.name });
 
@@ -45,6 +54,7 @@ export const addAppToolNode = async ({
     // Get compiled playbooks with proper parameters
     const playbookParams = {
       ...state.memory, // Spread memory fields at the top level
+      currentTime: new Date().toISOString(),
     };
     const compiledPlaybooks = compilePlaybooks(agent.playbooks, playbookParams) || '';
 
@@ -76,7 +86,7 @@ export const addAppToolNode = async ({
     const toolCallMessage = await tool.invoke(AIToolCallMessage.tool_calls[0]);
     AIToolCallMessage.additional_kwargs = {
       mindedMetadata: {
-        nodeType: NodeType.APP_TOOL
+        nodeType: NodeType.APP_TOOL,
       },
     };
     return {

package/src/nodes/addToolNode.ts

@@ -41,7 +41,6 @@ export const addToolNode = async ({
     // Get compiled playbooks with proper parameters
     const playbookParams = {
       ...state.memory, // Spread memory fields at the top level
-      state, // Keep the full state for backward compatibility
       currentTime: new Date().toISOString(),
       // Add any other common parameters that playbooks might need
     };

package/src/nodes/nodeFactory.ts

@@ -40,7 +40,7 @@ export const nodeFactory = ({
       addJunctionNode({ graph, node });
       break;
     case NodeType.APP_TOOL:
-      addAppToolNode({ graph, node, llm, agent });
+      addAppToolNode({ graph, node, llm, agent, tools });
       break;
     case NodeType.PROMPT_NODE:
       addPromptNode({ graph, node, tools, llm, emit, agent });
@@ -54,4 +54,4 @@ export const nodeFactory = ({
     default:
       throw new Error(`Unsupported node type: ${nodeType}`);
   }
-};
+};

package/src/platform/utils/parseAttachments.ts

@@ -0,0 +1,56 @@
+/**
+ * Parses attachments from a trigger body and formats them as a string
+ * @param triggerBody - The trigger body containing potential attachments
+ * @returns Formatted string of attachments or empty string if no attachments
+ */
+export const parseAttachments = (triggerBody: any): string => {
+  // Check if triggerBody has attachments in meta
+  const attachments = triggerBody?.meta?.attachments;
+
+  if (!attachments || !Array.isArray(attachments) || attachments.length === 0) {
+    return '';
+  }
+
+  // Format attachments
+  const attachmentStrings = attachments
+    .map((attachment: any) => {
+      const lines: string[] = [];
+
+      if (attachment.originalname) {
+        lines.push(`originalName: ${attachment.originalname}`);
+      } else if (attachment.name) {
+        lines.push(`originalName: ${attachment.name}`);
+      }
+
+      if (attachment.path) {
+        lines.push(`localPath: ${attachment.path}`);
+      }
+
+      return lines.join('\n');
+    })
+    .filter((str) => str.length > 0);
+
+  if (attachmentStrings.length === 0) {
+    return '';
+  }
+
+  return 'Attachments:\n' + attachmentStrings.join('\n\n');
+};
+
+/**
+ * Combines content with attachments string
+ * @param content - The main content string
+ * @param attachmentsString - The formatted attachments string
+ * @returns Combined content with attachments
+ */
+export const combineContentWithAttachments = (content: string, attachmentsString: string): string => {
+  if (!attachmentsString) {
+    return content;
+  }
+
+  if (!content) {
+    return attachmentsString;
+  }
+
+  return `${content}\n${attachmentsString}`;
+};

package/src/toolsLibrary/index.ts

@@ -0,0 +1,6 @@
+import * as parseDocument from './parseDocument';
+
+// Export all tools as a collection for easy discovery
+export const tools = {
+  'minded-parse-documents': parseDocument,
+};

package/src/toolsLibrary/parseDocument.ts

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+import { Tool } from '../types/Tools.types';
+import { extractFromDocument } from '../internalTools/documentExtraction/documentExtraction';
+import { logger } from '../utils/logger';
+
+// Schema for the tool - these are the parameters that can be inferred by LLM
+export const schema = z.object({
+  // Document source parameters - only one should be provided based on loadFrom setting
+  documentPath: z.string().optional().nullable().describe('Path to the document file to parse (when loadFrom is "path")'),
+  documentContent: z
+    .union([z.instanceof(Buffer), z.string()])
+    .optional()
+    .nullable()
+    .describe('Document content as Buffer or string (when loadFrom is "buffer" or "string")'),
+  documentUrl: z.string().optional().nullable().describe('URL to fetch the document from (when loadFrom is "url")'),
+
+  // Processing parameters - these can be predefined in the UI
+  extractRaw: z.boolean().optional().nullable().describe('Extract raw text without AI processing'),
+  schema: z.any().optional().nullable().describe('Zod schema for structured data extraction (when not extracting raw)'),
+
+  // Load source indicator - this would be set from UI
+  loadFrom: z.enum(['url', 'path', 'buffer', 'string']).optional().nullable().describe('Source type for the document'),
+  systemPrompt: z.string().optional().nullable().describe('Prompt for guiding extraction (when not using schema or extracting raw)'),
+});
+
+const parseDocumentTool: Tool<typeof schema, any> = {
+  name: 'minded-parse-documents',
+  description:
+    'Parse and extract data from documents (PDFs, images, Word docs, etc.). Supports multiple input sources (URL, file path, buffer, or string) and can extract raw text, structured data with a schema, or unstructured data with a prompt. Parameters can be predefined in the flow configuration.',
+  input: schema,
+  isGlobal: false,
+  execute: async ({ input, state, agent }) => {
+    // The input here will be the combined input from both LLM and UI properties
+    const combinedInput = input as z.infer<typeof schema>;
+
+    logger.info({
+      msg: '*Action: Parse document*',
+      sessionId: state.sessionId,
+      loadFrom: combinedInput.loadFrom,
+      hasPath: !!combinedInput.documentPath,
+      hasContent: !!combinedInput.documentContent,
+      hasUrl: !!combinedInput.documentUrl,
+      hasSchema: !!combinedInput.schema,
+      hasPrompt: !!combinedInput.systemPrompt,
+      extractRaw: combinedInput.extractRaw,
+    });
+
+    try {
+      // Validate document source based on loadFrom parameter
+      if (combinedInput.loadFrom) {
+        switch (combinedInput.loadFrom) {
+          case 'url':
+            if (!combinedInput.documentUrl) {
+              throw new Error('documentUrl is required when loadFrom is "url"');
+            }
+            break;
+          case 'path':
+            if (!combinedInput.documentPath) {
+              throw new Error('documentPath is required when loadFrom is "path"');
+            }
+            break;
+          case 'buffer':
+          case 'string':
+            if (!combinedInput.documentContent) {
+              throw new Error('documentContent is required when loadFrom is "buffer" or "string"');
+            }
+            break;
+        }
+      } else {
+        // Fallback to original validation if loadFrom is not specified
+        if (!combinedInput.documentPath && !combinedInput.documentContent && !combinedInput.documentUrl) {
+          throw new Error('At least one document source must be provided: documentPath, documentContent, or documentUrl');
+        }
+      }
+
+      // Prepare extraction options, filtering out null/undefined values
+      const extractionOptions: Parameters<typeof extractFromDocument>[0] = {};
+
+      if (combinedInput.documentPath) {
+        extractionOptions.documentPath = combinedInput.documentPath;
+      }
+      if (combinedInput.documentContent) {
+        extractionOptions.documentContent = combinedInput.documentContent;
+      }
+      if (combinedInput.documentUrl) {
+        extractionOptions.documentUrl = combinedInput.documentUrl;
+      }
+
+      // Only include LLM if not extracting raw text
+      if (!combinedInput.extractRaw) {
+        extractionOptions.llm = agent.llm;
+
+        // Include schema or system prompt if provided
+        if (combinedInput.schema) {
+          extractionOptions.schema = combinedInput.schema;
+        } else if (combinedInput.systemPrompt) {
+          extractionOptions.systemPrompt = combinedInput.systemPrompt;
+        }
+      }
+
+      // Extract from document using the SDK's document extraction capabilities
+      const result = await extractFromDocument(extractionOptions);
+
+      // Return only the extracted data, not the metadata as requested
+      return {
+        result: result.data,
+        state: {
+          memory: {
+            lastParsedDocument: {
+              source: combinedInput.documentPath || combinedInput.documentUrl || 'content',
+              extractedAt: new Date().toISOString(),
+              extractedRaw: !!combinedInput.extractRaw,
+            },
+          },
+        },
+      };
+    } catch (error) {
+      logger.error({
+        msg: 'Failed to parse document',
+        sessionId: state.sessionId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+
+      return {
+        result: `Failed to parse document: ${error instanceof Error ? error.message : String(error)}`,
+        state: {
+          memory: {
+            documentParsingError: error instanceof Error ? error.message : String(error),
+          },
+        },
+      };
+    }
+  },
+};
+
+export default parseDocumentTool;