@minded-ai/mindedjs 1.0.108 → 1.0.109-beta-1

package/src/platform/models/parallelWrapper.ts

@@ -1,141 +0,0 @@
-import { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import { BaseMessage } from '@langchain/core/messages';
-import { ChatGenerationChunk, ChatResult } from '@langchain/core/outputs';
-import { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
-import { logger } from '../../utils/logger';
-
-export interface BaseParallelChatFields {
-  /**
-   * Number of parallel requests to make. Defaults to 1 (no parallelization).
-   * When > 1, multiple identical requests are sent and the fastest response is used.
-   */
-  numParallelRequests?: number;
-
-  /**
-   * Whether to log timing information for parallel requests
-   */
-  logTimings?: boolean;
-}
-
-/**
- * Creates a wrapped version of a chat model with parallel request capabilities
- */
-export function createParallelWrapper<T extends BaseChatModel>(model: T, fields?: BaseParallelChatFields): T {
-  const numParallelRequests = fields?.numParallelRequests || 1;
-  const logTimings = fields?.logTimings || false;
-
-  // If parallel requests are disabled, return the original model
-  if (numParallelRequests <= 1) {
-    return model;
-  }
-
-  // Helper function that returns a promise that resolves with the second fulfilled promise
-  const promiseSecondFulfillment = <T>(promises: Promise<T>[]): Promise<T> => {
-    return new Promise((resolve) => {
-      let fulfillCount = 0;
-
-      for (const p of promises) {
-        Promise.resolve(p)
-          .then((value) => {
-            fulfillCount++;
-            if (fulfillCount === 2) {
-              resolve(value);
-            }
-          })
-          .catch(() => {
-            // Ignoring rejections for second fulfillment tracking
-          });
-      }
-    });
-  };
-
-  // Store original methods
-  const originalGenerate = model._generate.bind(model);
-  const originalStream = model._streamResponseChunks.bind(model);
-
-  // Override _generate
-  model._generate = async function (messages: BaseMessage[], options?: any, runManager?: CallbackManagerForLLMRun): Promise<ChatResult> {
-    const startTime = Date.now();
-
-    // Create array of identical requests
-    const requests = Array.from({ length: numParallelRequests }, () => originalGenerate(messages, options, runManager));
-
-    let fastestRequestTime = 0;
-    let secondFastestRequestTime = 0;
-
-    // Race all requests and return the fastest
-    const racePromise = Promise.race(requests).then((result) => {
-      fastestRequestTime = (Date.now() - startTime) / 1000.0;
-
-      if (logTimings) {
-        logger.debug({
-          msg: '[Model] Fastest request completed',
-          requestTime: fastestRequestTime,
-          numParallelRequests: numParallelRequests,
-        });
-      }
-
-      return result;
-    });
-
-    // Track second fastest if we have 3+ requests
-    if (requests.length >= 3) {
-      promiseSecondFulfillment(requests)
-        .then(() => {
-          secondFastestRequestTime = (Date.now() - startTime) / 1000.0;
-        })
-        .catch(() => {
-          // Ignore errors in timing tracking
-        });
-    }
-
-    // Track all completion times if we have 2+ requests
-    if (requests.length >= 2 && logTimings) {
-      Promise.all(requests)
-        .then(() => {
-          const allFinishTime = (Date.now() - startTime) / 1000.0;
-          const timeSaved = allFinishTime - fastestRequestTime;
-          const timeSavedFromSecond = secondFastestRequestTime > 0 ? secondFastestRequestTime - fastestRequestTime : 0;
-
-          logger.debug({
-            msg: '[Model] Time saved using parallel requests',
-            fastestRequestTime,
-            secondFastestRequestTime: secondFastestRequestTime || 'N/A',
-            allFinishTime,
-            timeSaved,
-            timeSavedFromSecond,
-            numParallelRequests: numParallelRequests,
-          });
-        })
-        .catch(() => {
-          // Ignore errors in timing tracking
-        });
-    }
-
-    return racePromise;
-  };
-
-  // Override _streamResponseChunks
-  model._streamResponseChunks = async function* (
-    messages: BaseMessage[],
-    options?: any,
-    runManager?: CallbackManagerForLLMRun,
-  ): AsyncGenerator<ChatGenerationChunk> {
-    // For streaming, we'll use the original implementation
-    // Parallel streaming is more complex and may not provide the same benefits
-    if (numParallelRequests > 1 && logTimings) {
-      logger.debug({
-        msg: '[Model] Streaming mode - using single request',
-        reason: 'Parallel streaming not implemented',
-      });
-    }
-
-    yield* originalStream(messages, options, runManager);
-  };
-
-  // Add properties for testing
-  (model as any).numParallelRequests = numParallelRequests;
-  (model as any).logTimings = logTimings;
-
-  return model;
-}

package/src/platform/piiGateway/gateway.ts

@@ -1,103 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import * as mindedConnection from '../mindedConnection';
-import { mindedConnectionSocketMessageType, OnPiiHttpRequest, OnPiiHttpResponse } from '../mindedConnectionTypes';
-import { HttpRequestConfig, HttpResponse, PIIGatewayInstance } from './types';
-import { logger } from '../../utils/logger';
-
-export class PIIGateway implements PIIGatewayInstance {
-  constructor() {
-    // No longer needs mindedConnection as parameter
-  }
-
-  private async makeRequest<T = any>(
-    sessionId: string,
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS',
-    url: string,
-    data?: any,
-    config?: HttpRequestConfig,
-  ): Promise<HttpResponse<T>> {
-    if (!mindedConnection.isConnected()) {
-      throw new Error('Minded connection is not established. PII-secured HTTP requests require a connection to the Minded platform.');
-    }
-
-    try {
-      const requestId = uuidv4();
-      const requestPayload: OnPiiHttpRequest = {
-        type: mindedConnectionSocketMessageType.PII_HTTP_REQUEST,
-        requestId,
-        method,
-        url,
-        headers: config?.headers as Record<string, string>,
-        params: config?.params,
-        data,
-        sessionId,
-      };
-
-      const response = await mindedConnection.awaitEmit<OnPiiHttpRequest, OnPiiHttpResponse>(
-        mindedConnectionSocketMessageType.PII_HTTP_REQUEST,
-        requestPayload,
-        30000, // 30 second timeout for HTTP requests
-      );
-
-      if (response.error) {
-        throw new Error(`HTTP request failed: ${response.error}`);
-      }
-
-      // Verify that the response requestId matches our request
-      if (response.requestId && response.requestId !== requestId) {
-        logger.warn(`Response requestId (${response.requestId}) does not match request requestId (${requestId})`);
-      }
-
-      // Return generic HttpResponse format
-      return {
-        data: response.data,
-        status: response.status || 200,
-        statusText: response.statusText || 'OK',
-        headers: response.headers || {},
-        config: config || {},
-      };
-    } catch (error) {
-      logger.error({ msg: 'Secure HTTP request failed', error });
-      return {
-        data: undefined as T,
-        status: 500,
-        statusText: 'Internal Server Error',
-        headers: {},
-        config: config || {},
-      };
-    }
-  }
-
-  async get<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
-    return this.makeRequest<T>(sessionId, 'GET', url, undefined, config);
-  }
-
-  async post<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
-    return this.makeRequest<T>(sessionId, 'POST', url, data, config);
-  }
-
-  async put<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
-    return this.makeRequest<T>(sessionId, 'PUT', url, data, config);
-  }
-
-  async delete<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
-    return this.makeRequest<T>(sessionId, 'DELETE', url, undefined, config);
-  }
-
-  async patch<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
-    return this.makeRequest<T>(sessionId, 'PATCH', url, data, config);
-  }
-
-  async head<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
-    return this.makeRequest<T>(sessionId, 'HEAD', url, undefined, config);
-  }
-
-  async options<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>> {
-    return this.makeRequest<T>(sessionId, 'OPTIONS', url, undefined, config);
-  }
-
-  async request<T = any>(sessionId: string, config: HttpRequestConfig): Promise<HttpResponse<T>> {
-    const method = (config.method?.toUpperCase() || 'GET') as any;
-    return this.makeRequest<T>(sessionId, method, config.url || '', config.data, config);
-  }
-}

package/src/platform/piiGateway/index.ts

@@ -1,5 +0,0 @@
-// Export types
-export type { HttpRequestConfig, HttpResponse, PIIGatewayInstance } from './types';
-
-// Export core gateway class and creation function
-export { PIIGateway } from './gateway';

package/src/platform/piiGateway/types.ts

@@ -1,29 +0,0 @@
-// Generic HTTP types (library-agnostic)
-export interface HttpRequestConfig {
-  method?: string;
-  url?: string;
-  headers?: Record<string, string>;
-  params?: Record<string, any>;
-  data?: any;
-  timeout?: number;
-  [key: string]: any; // Allow additional properties for extensibility
-}
-
-export interface HttpResponse<T = any> {
-  data: T;
-  status: number;
-  statusText: string;
-  headers: Record<string, string>;
-  config: HttpRequestConfig;
-}
-
-export interface PIIGatewayInstance {
-  get<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-  post<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-  put<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-  delete<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-  patch<T = any>(sessionId: string, url: string, data?: any, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-  head<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-  options<T = any>(sessionId: string, url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-  request<T = any>(sessionId: string, config: HttpRequestConfig): Promise<HttpResponse<T>>;
-}

package/src/platform/utils/parseAttachments.ts

@@ -1,56 +0,0 @@
-/**
- * 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/playbooks/playbooks.ts

@@ -1,209 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-import * as ejs from 'ejs';
-import * as mindedConnection from '../platform/mindedConnection';
-import { mindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
-import { getConfig } from '../platform/config';
-import { logger } from '../utils/logger';
-import { OutputBlockData } from '@editorjs/editorjs';
-
-export type Playbook = {
-  id: string;
-  name: string;
-  blocks: OutputBlockData[];
-};
-
-/**
- * Convert EditorJS blocks to markdown
- */
-function editorJsToMarkdown(blocks: OutputBlockData[]): string {
-  if (!blocks || blocks.length === 0) {
-    return '';
-  }
-
-  return blocks
-    .map((block) => {
-      try {
-        switch (block.type) {
-          case 'header': {
-            const level = block.data?.level || 1;
-            const headerPrefix = '#'.repeat(level);
-            return `${headerPrefix} ${block.data?.text || ''}`;
-          }
-
-          case 'paragraph': {
-            return block.data?.text || '';
-          }
-
-          case 'list': {
-            const items = block.data?.items || [];
-            const style = block.data?.style || 'unordered';
-            return items
-              .map((item: string, index: number) => {
-                if (style === 'ordered') {
-                  return `${index + 1}. ${item}`;
-                } else {
-                  return `- ${item}`;
-                }
-              })
-              .join('\n');
-          }
-
-          case 'quote': {
-            const text = block.data?.text || '';
-            const caption = block.data?.caption ? `\n*${block.data.caption}*` : '';
-            return `> ${text}${caption}`;
-          }
-
-          case 'code': {
-            const code = block.data?.code || '';
-            return `\`\`\`\n${code}\n\`\`\``;
-          }
-
-          case 'delimiter': {
-            return '---';
-          }
-
-          default: {
-            logger.warn(`Unknown playbook block type: ${block.type}`);
-            return '';
-          }
-        }
-      } catch (error) {
-        logger.error({ message: 'Error converting EditorJS blocks to markdown', error, block });
-        throw error;
-      }
-    })
-    .join('\n\n');
-}
-
-/**
- * Load playbooks from directories or platform
- */
-export async function loadPlaybooks(playbooksDirectories?: string[]): Promise<Playbook[]> {
-  const { env, isDeployed } = getConfig();
-  let playbooks: Playbook[] = [];
-
-  if (['sandbox-staging', 'sandbox'].includes(env) && isDeployed && mindedConnection.isConnected()) {
-    // Load from platform
-    const response = await mindedConnection.awaitEmit<object, { playbooks?: Playbook[]; error?: string }>(
-      mindedConnectionSocketMessageType.GET_PLAYBOOKS,
-      {},
-    );
-
-    if (response?.error) {
-      throw new Error(`Failed to load playbooks from platform: ${response.error}`);
-    }
-
-    playbooks = response?.playbooks || [];
-  } else if (playbooksDirectories) {
-    // Load from directories
-    playbooks = loadPlaybooksFromDirectories(playbooksDirectories);
-  }
-
-  return playbooks;
-}
-
-/**
- * Load playbooks from local directories
- */
-function loadPlaybooksFromDirectories(directories: string[]): Playbook[] {
-  const playbooks: Playbook[] = [];
-
-  for (const directory of directories) {
-    if (!fs.existsSync(directory)) {
-      logger.info(`Playbooks directory does not exist: ${directory}`);
-      continue;
-    }
-
-    const files = getAllYamlFiles(directory);
-
-    for (const file of files) {
-      try {
-        const fileContent = fs.readFileSync(file, 'utf8');
-        const playbook = yaml.load(fileContent) as Playbook;
-
-        if (playbook && playbook.name && playbook.blocks) {
-          playbooks.push(playbook);
-          logger.info(`Loaded playbook: ${playbook.name} from ${file}`);
-        } else {
-          logger.warn(`Invalid playbook structure in ${file}`);
-        }
-      } catch (error) {
-        logger.error(`Failed to load playbook file ${file}: ${error}`);
-      }
-    }
-  }
-
-  return playbooks;
-}
-
-/**
- * Recursively get all YAML files in a directory
- */
-function getAllYamlFiles(dir: string): string[] {
-  const files: string[] = [];
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...getAllYamlFiles(fullPath));
-    } else if (entry.name.endsWith('.yaml') || entry.name.endsWith('.yml')) {
-      files.push(fullPath);
-    }
-  }
-
-  return files;
-}
-
-/**
- * Compile playbooks into a single string with EJS and placeholders
- */
-export function compilePlaybooks(playbooks: Playbook[], params: Record<string, any> = {}): string {
-  if (playbooks.length === 0) {
-    return '';
-  }
-
-  // Combine all playbooks into sections
-  const sections = playbooks.map((playbook) => {
-    const markdownContent = editorJsToMarkdown(playbook.blocks);
-    return `# ${playbook.name}\n${markdownContent}`;
-  });
-
-  const combinedPlaybooks = sections.join('\n\n');
-
-  try {
-    // First, render with EJS
-    let compiledPlaybooks = ejs.render(combinedPlaybooks, params);
-
-    // Then, replace placeholders in {} format
-    compiledPlaybooks = replacePlaceholders(compiledPlaybooks, params);
-
-    return compiledPlaybooks;
-  } catch (error) {
-    logger.error({ message: 'Error compiling playbooks', error });
-    return combinedPlaybooks; // Return uncompiled if there's an error
-  }
-}
-
-/**
- * Replace placeholders in {key} format
- */
-function replacePlaceholders(text: string, params: Record<string, any>): string {
-  return text.replace(/\{([^}]+)\}/g, (match, key) => {
-    const keys = key.split('.');
-    let value: any = params;
-
-    for (const k of keys) {
-      if (value && typeof value === 'object' && k in value) {
-        value = value[k];
-      } else {
-        return match; // Return original if key not found
-      }
-    }
-
-    return String(value);
-  });
-}

package/src/toolsLibrary/index.ts

@@ -1,6 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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;