@minded-ai/mindedjs 1.0.115 → 1.0.117

package/src/toolsLibrary/classifier.ts

@@ -0,0 +1,273 @@
+import { z } from 'zod';
+import { Tool } from '../types/Tools.types';
+import { logger } from '../utils/logger';
+import { JsonOutputParser } from '@langchain/core/output_parsers';
+import { SystemMessage } from '@langchain/core/messages';
+import { BaseLanguageModel } from '@langchain/core/language_models/base';
+
+// Type definitions for classifier configuration
+export interface ClassDefinition {
+  name: string;
+  description: string;
+}
+
+export interface ClassifierConfig {
+  classes: ClassDefinition[];
+  systemPrompt?: string;
+  outputFormat?: 'json' | 'text';
+  includeReason?: boolean;
+  defaultClass?: string;
+  defaultReason?: string;
+}
+
+export interface ClassificationResult {
+  class: string;
+  reason?: string;
+  confidence?: number;
+  [key: string]: any; // Allow additional fields
+}
+
+// Default configuration
+const DEFAULT_CONFIG: Partial<ClassifierConfig> = {
+  outputFormat: 'json',
+  includeReason: true,
+  defaultClass: 'unknown',
+  defaultReason: 'Unable to determine classification',
+};
+
+/**
+ * Generic classifier utility that can be used standalone
+ * @param content The content to classify
+ * @param config The classifier configuration
+ * @param llm The language model to use for classification
+ * @returns The classification result
+ */
+export async function classify(content: string, config: ClassifierConfig, llm: BaseLanguageModel): Promise<ClassificationResult> {
+  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+
+  try {
+    // Build the classification prompt
+    const classesDescription = mergedConfig.classes.map((c) => `${c.name}: ${c.description}`).join('\n');
+
+    const basePrompt =
+      mergedConfig.systemPrompt || 'You are a classifier. Your task is to classify the given content into one of the following categories:';
+
+    let prompt = `${basePrompt}\n\n${classesDescription}\n\n`;
+
+    if (mergedConfig.outputFormat === 'json') {
+      prompt += `You should output the result in the following JSON format: {
+        "class": "<selected class name>",
+        ${mergedConfig.includeReason ? '"reason": "<explanation for the classification>",' : ''}
+        "confidence": <confidence score between 0 and 1>
+      }.\nReturn JSON and nothing more.`;
+    } else {
+      prompt += 'Return only the class name.';
+    }
+
+    prompt += `\n\nContent to classify:\n${content}`;
+
+    // Make the classification request
+    if (mergedConfig.outputFormat === 'json') {
+      const parser = new JsonOutputParser();
+      const result = await llm.pipe(parser).invoke([new SystemMessage(prompt)]);
+      return result as ClassificationResult;
+    } else {
+      const result = await llm.invoke([new SystemMessage(prompt)]);
+      const classText = typeof result.content === 'string' ? result.content.trim() : '';
+      return { class: classText };
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error({ message: 'Classification failed, using default', error: errorMessage });
+
+    // Return default classification on error
+    return {
+      class: mergedConfig.defaultClass || 'unknown',
+      reason: mergedConfig.defaultReason || errorMessage,
+      confidence: 0,
+    };
+  }
+}
+
+/**
+ * Create a classifier from a simple class list
+ * @param classes Array of class names or [name, description] tuples
+ * @param options Additional configuration options
+ * @returns A configured classify function
+ */
+export function createClassifier(classes: string[] | [string, string][], options?: Partial<ClassifierConfig>) {
+  const classDefinitions: ClassDefinition[] = classes.map((c) => {
+    if (typeof c === 'string') {
+      return { name: c, description: '' };
+    }
+    return { name: c[0], description: c[1] };
+  });
+
+  const config: ClassifierConfig = {
+    ...options,
+    classes: classDefinitions,
+  };
+
+  return (content: string, llm: BaseLanguageModel) => classify(content, config, llm);
+}
+
+// Schema for the classifier tool
+export const schema = z.object({
+  content: z.string().describe('The content to classify'),
+  classes: z
+    .array(
+      z.union([
+        z.string(),
+        z.tuple([z.string(), z.string()]),
+        z.object({
+          name: z.string(),
+          description: z.string(),
+        }),
+      ]),
+    )
+    .optional()
+    .describe('Classes to classify into. Can be strings, [name, description] tuples, or objects with name and description'),
+  systemPrompt: z.string().optional().describe('Custom system prompt for classification'),
+  includeReason: z.boolean().optional().default(true).describe('Whether to include reasoning in the response'),
+  outputFormat: z.enum(['json', 'text']).optional().default('json').describe('Output format for the classification'),
+  defaultClass: z.string().optional().describe('Default class to use if classification fails'),
+  defaultReason: z.string().optional().describe('Default reason to use if classification fails'),
+});
+
+const classifierTool: Tool<typeof schema, any> = {
+  name: 'minded-classifier',
+  description:
+    'Classify content into predefined categories using AI. Supports custom classes, system prompts, and various output formats. Can be configured with default fallback values.',
+  input: schema,
+  isGlobal: false,
+  execute: async ({ input, state, agent }) => {
+    const { content, classes, systemPrompt, includeReason, outputFormat, defaultClass, defaultReason } = input;
+
+    logger.info({
+      message: 'Classifying content',
+      sessionId: state.sessionId,
+      contentLength: content.length,
+      classCount: classes?.length,
+    });
+
+    // Convert input classes to ClassDefinition format
+    let classDefinitions: ClassDefinition[] = [];
+    if (classes) {
+      classDefinitions = classes.map((c) => {
+        if (typeof c === 'string') {
+          return { name: c, description: '' };
+        } else if (Array.isArray(c)) {
+          return { name: c[0], description: c[1] };
+        } else {
+          return c as ClassDefinition;
+        }
+      });
+    }
+
+    // If no classes provided, try to get from state memory
+    if (classDefinitions.length === 0 && state.memory?.classifierConfig?.classes) {
+      classDefinitions = state.memory.classifierConfig.classes;
+    }
+
+    if (classDefinitions.length === 0) {
+      throw new Error('No classes provided for classification');
+    }
+
+    const config: ClassifierConfig = {
+      classes: classDefinitions,
+      systemPrompt,
+      includeReason,
+      outputFormat,
+      defaultClass,
+      defaultReason,
+    };
+
+    try {
+      const result = await classify(content, config, agent.llm);
+
+      logger.info({
+        message: 'Classification completed',
+        sessionId: state.sessionId,
+        class: result.class,
+        confidence: result.confidence,
+      });
+
+      return {
+        result,
+        state: {
+          memory: {
+            lastClassification: {
+              content: content.substring(0, 100) + (content.length > 100 ? '...' : ''),
+              result,
+              timestamp: new Date().toISOString(),
+            },
+          },
+        },
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error({
+        message: 'Classification failed',
+        sessionId: state.sessionId,
+        error: errorMessage,
+      });
+
+      throw error;
+    }
+  },
+};
+
+export default classifierTool;
+
+// Export utility for multi-label classification
+export async function multiClassify(
+  content: string,
+  config: ClassifierConfig & { maxClasses?: number },
+  llm: BaseLanguageModel,
+): Promise<ClassificationResult[]> {
+  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+  const maxClasses = mergedConfig.maxClasses || 3;
+
+  try {
+    const classesDescription = mergedConfig.classes.map((c) => `${c.name}: ${c.description}`).join('\n');
+
+    const basePrompt =
+      mergedConfig.systemPrompt || 'You are a multi-label classifier. Select all applicable categories for the given content:';
+
+    const prompt = `${basePrompt}\n\n${classesDescription}\n\n
+You should output the result as a JSON array of up to ${maxClasses} classifications, ordered by relevance:
+[
+  {
+    "class": "<class name>",
+    ${mergedConfig.includeReason ? '"reason": "<explanation>",' : ''}
+    "confidence": <confidence score between 0 and 1>
+  },
+  ...
+]
+Return JSON and nothing more.
+
+Content to classify:
+${content}`;
+
+    const parser = new JsonOutputParser();
+    const result = await llm.pipe(parser).invoke([new SystemMessage(prompt)]);
+
+    if (Array.isArray(result)) {
+      return result as ClassificationResult[];
+    }
+
+    // If single result returned, wrap in array
+    return [result as ClassificationResult];
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error({ message: 'Multi-classification failed', error: errorMessage });
+
+    return [
+      {
+        class: mergedConfig.defaultClass || 'unknown',
+        reason: mergedConfig.defaultReason || errorMessage,
+        confidence: 0,
+      },
+    ];
+  }
+}

package/src/toolsLibrary/index.ts

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

package/src/types/Flows.types.ts

@@ -67,6 +67,10 @@ export interface WebhookTriggerNode extends BaseTriggerNode {
 export interface InterfaceTriggerNode extends BaseTriggerNode {
   triggerType: TriggerType.INTERFACE;
   parameters: Record<string, any>;
+  appName: string;
+  appImgSrc: string;
+  actionName: string;
+  actionKey: string;
 }
 
 export interface VoiceTriggerNode extends BaseTriggerNode {
@@ -106,6 +110,8 @@ export interface BrowserTaskNode extends BaseNode {
     description?: string;
     required?: boolean;
   }[];
+  autoTrigger?: boolean;
+  defaultPayload?: string;
 }
 
 export type TriggerNode = AppTriggerNode | WebhookTriggerNode | ManualTriggerNode | VoiceTriggerNode | InterfaceTriggerNode;