@minded-ai/mindedjs 2.0.14-beta-1 → 2.0.15-beta-1

package/src/cli/localOperatorSetup.ts

@@ -0,0 +1,308 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync, spawn } from 'child_process';
+import * as readline from 'readline';
+
+const VENV_DIR = '.venv';
+const SETUP_MARKER_FILE = '.minded-local-operator-setup';
+
+interface SetupPackage {
+  name: string;
+  description: string;
+  command: string;
+  checkCommand?: string;
+}
+
+const REQUIRED_PACKAGES: SetupPackage[] = [
+  {
+    name: 'uv',
+    description: 'Python package manager for fast dependency installation',
+    command: 'curl -LsSf https://astral.sh/uv/install.sh | sh',
+    checkCommand: 'uv --version',
+  },
+  {
+    name: 'Python 3.12',
+    description: 'Python runtime for browser automation',
+    command: 'python3.12 --version',
+    checkCommand: 'python3.12 --version',
+  },
+  {
+    name: 'browser-use',
+    description: 'Browser automation library',
+    command: 'uv pip install browser-use',
+  },
+  {
+    name: 'Playwright Chromium',
+    description: 'Chromium browser for automation',
+    command: 'uvx playwright install chromium --with-deps',
+  },
+];
+
+export function isLocalOperatorSetup(): boolean {
+  const setupMarkerPath = path.join(process.cwd(), SETUP_MARKER_FILE);
+  const venvPath = path.join(process.cwd(), VENV_DIR);
+
+  // Check if both the marker file and venv directory exist
+  return fs.existsSync(setupMarkerPath) && fs.existsSync(venvPath);
+}
+
+function checkCommand(command: string): boolean {
+  try {
+    execSync(command, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function promptUser(question: string): Promise<boolean> {
+  // Check if we're in an interactive terminal
+  if (!process.stdin.isTTY) {
+    console.warn('Non-interactive terminal detected, skipping prompt and cancelling installation');
+    return Promise.resolve(false);
+  }
+
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    // Set a timeout in case the prompt hangs
+    const timeout = setTimeout(() => {
+      console.warn('Prompt timeout (30s), cancelling installation');
+      rl.close();
+      resolve(false);
+    }, 30000); // 30 second timeout
+
+    console.log('Displaying prompt to user');
+
+    rl.question(question, (answer) => {
+      clearTimeout(timeout);
+      console.log(`User answered: "${answer}"`);
+
+      rl.close();
+
+      const confirmed = answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+      console.log(`Prompt result: ${confirmed}`);
+
+      resolve(confirmed);
+    });
+
+    // Handle potential readline errors
+    rl.on('error', (error) => {
+      console.error('Readline error, cancelling installation:', error.message);
+      clearTimeout(timeout);
+      rl.close();
+      resolve(false);
+    });
+  });
+}
+
+async function runCommand(command: string, description: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    console.log(`Installing ${description}...`);
+
+    const isComplexCommand = command.includes('|') || command.includes('&&');
+
+    if (isComplexCommand) {
+      // For complex commands with pipes or &&, use shell
+      const child = spawn('sh', ['-c', command], {
+        stdio: 'inherit',
+        shell: true,
+      });
+
+      child.on('error', (error) => {
+        console.error(`Failed to install ${description}:`, error.message);
+        reject(error);
+      });
+
+      child.on('close', (code) => {
+        if (code === 0) {
+          console.log(`✓ ${description} installed successfully`);
+          resolve();
+        } else {
+          reject(new Error(`Command exited with code ${code}`));
+        }
+      });
+    } else {
+      // For simple commands, use execSync
+      try {
+        execSync(command, { stdio: 'inherit' });
+        console.log(`✓ ${description} installed successfully`);
+        resolve();
+      } catch (error) {
+        console.error(`Failed to install ${description}:`, error);
+        reject(error);
+      }
+    }
+  });
+}
+
+export async function setupLocalOperator(skipPrompt: boolean = false): Promise<void> {
+  console.log('\n🤖 Minded Local Operator Setup\n');
+
+  // Check if already setup
+  if (isLocalOperatorSetup()) {
+    console.log('✓ Local operator is already set up');
+    return;
+  }
+
+  // Display what will be installed
+  console.log('The following packages will be installed for local browser automation:\n');
+  REQUIRED_PACKAGES.forEach((pkg, index) => {
+    console.log(`  ${index + 1}. ${pkg.name} - ${pkg.description}`);
+  });
+  console.log('');
+
+  // Ask for confirmation unless skipped
+  if (!skipPrompt) {
+    console.log('Waiting for user confirmation...');
+    const confirmed = await promptUser('Do you want to proceed with the installation? (y/n): ');
+    if (!confirmed) {
+      console.log('Installation cancelled by user');
+      process.exit(0);
+    }
+    console.log('User confirmed, proceeding with installation');
+  } else {
+    console.log('Skipping confirmation prompt, proceeding with installation...');
+  }
+
+  console.log('\n📦 Starting installation...\n');
+
+  try {
+    // Check and install uv if needed
+    if (!checkCommand('uv --version')) {
+      console.log('Installing uv package manager...');
+      await runCommand('curl -LsSf https://astral.sh/uv/install.sh | sh', 'uv');
+
+      // Add uv to PATH for current session
+      const uvPath = path.join(process.env.HOME || '', '.cargo', 'bin');
+      process.env.PATH = `${uvPath}:${process.env.PATH}`;
+    } else {
+      console.log('✓ uv is already installed');
+    }
+
+    // Check Python 3.12
+    if (!checkCommand('python3.12 --version')) {
+      console.error('Python 3.12 is required but not found');
+      console.log('Please install Python 3.12 manually:');
+      console.log('  macOS: brew install python@3.12');
+      console.log('  Ubuntu/Debian: sudo apt install python3.12');
+      console.log('  Or visit: https://www.python.org/downloads/');
+      process.exit(1);
+    } else {
+      console.log('✓ Python 3.12 is available');
+    }
+
+    // Create virtual environment
+    console.log('Creating Python virtual environment...');
+    execSync(`uv venv --python 3.12 ${VENV_DIR}`, { stdio: 'inherit' });
+    console.log('✓ Virtual environment created');
+
+    // Install browser-use in the venv
+    console.log('Installing browser-use package...');
+    execSync(`uv pip install --python ${path.join(process.cwd(), VENV_DIR, 'bin', 'python')} browser-use`, {
+      stdio: 'inherit',
+    });
+    console.log('✓ browser-use installed');
+
+    // Install Playwright Chromium
+    console.log('Installing Playwright Chromium browser...');
+    execSync(`uvx playwright install chromium --with-deps`, { stdio: 'inherit' });
+    console.log('✓ Playwright Chromium installed');
+
+    // Create setup marker file
+    const setupMarkerPath = path.join(process.cwd(), SETUP_MARKER_FILE);
+    const setupInfo = {
+      version: '1.0.0',
+      setupDate: new Date().toISOString(),
+      packages: REQUIRED_PACKAGES.map((p) => p.name),
+      venvPath: VENV_DIR,
+    };
+    fs.writeFileSync(setupMarkerPath, JSON.stringify(setupInfo, null, 2));
+
+    // Add to .gitignore if not already there
+    const gitignorePath = path.join(process.cwd(), '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+      const gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+      const itemsToIgnore = [VENV_DIR, SETUP_MARKER_FILE, 'downloads/'];
+      const linesToAdd: string[] = [];
+
+      itemsToIgnore.forEach((item) => {
+        if (!gitignoreContent.includes(item)) {
+          linesToAdd.push(item);
+        }
+      });
+
+      if (linesToAdd.length > 0) {
+        const newContent = gitignoreContent.trimEnd() + '\n\n# Minded Local Operator\n' + linesToAdd.join('\n') + '\n';
+        fs.writeFileSync(gitignorePath, newContent);
+        console.log('✓ Updated .gitignore');
+      }
+    }
+
+    // Add BROWSER_TASK_MODE to .env file
+    const envPath = path.join(process.cwd(), '.env');
+    const browserTaskModeVar = 'BROWSER_TASK_MODE=localRun';
+
+    if (fs.existsSync(envPath)) {
+      const envContent = fs.readFileSync(envPath, 'utf8');
+
+      // Check if BROWSER_TASK_MODE is already set
+      if (!envContent.includes('BROWSER_TASK_MODE')) {
+        // Append to existing .env file
+        const newEnvContent = envContent.trimEnd() + '\n' + browserTaskModeVar + '\n';
+        fs.writeFileSync(envPath, newEnvContent);
+        console.log('✓ Added BROWSER_TASK_MODE=localRun to .env');
+      } else if (!envContent.includes('BROWSER_TASK_MODE=localRun')) {
+        // BROWSER_TASK_MODE exists but with different value, update it
+        const updatedEnvContent = envContent.replace(/BROWSER_TASK_MODE=.*$/m, browserTaskModeVar);
+        fs.writeFileSync(envPath, updatedEnvContent);
+        console.log('✓ Updated BROWSER_TASK_MODE to localRun in .env');
+      } else {
+        console.log('✓ BROWSER_TASK_MODE=localRun already configured in .env');
+      }
+    } else {
+      // Create new .env file
+      fs.writeFileSync(envPath, browserTaskModeVar + '\n');
+      console.log('✓ Created .env file with BROWSER_TASK_MODE=localRun');
+    }
+
+    console.log('\n' + '='.repeat(50));
+    console.log('✅ Local operator setup completed successfully!');
+    console.log('='.repeat(50) + '\n');
+
+    console.log('You can now use browser automation features locally.');
+    console.log('The virtual environment will be activated automatically when needed.');
+  } catch (error) {
+    console.error('Setup failed:', error);
+
+    // Clean up partial installation
+    try {
+      if (fs.existsSync(path.join(process.cwd(), VENV_DIR))) {
+        fs.rmSync(path.join(process.cwd(), VENV_DIR), { recursive: true });
+      }
+    } catch {
+      // Ignore cleanup errors
+    }
+
+    process.exit(1);
+  }
+}
+
+export function validateLocalOperatorSetup(): void {
+  if (!isLocalOperatorSetup()) {
+    console.error('Local operator is not set up');
+    console.log('Please run: npx minded setup-local-operator');
+    throw new Error('Local operator not configured');
+  }
+}
+
+export function getVenvPath(): string {
+  return path.join(process.cwd(), VENV_DIR);
+}
+
+export function getVenvBinPath(): string {
+  return path.join(getVenvPath(), 'bin');
+}

package/src/nodes/addBrowserTaskNode.ts

@@ -31,10 +31,10 @@ export const addBrowserTaskNode = async ({ graph, node, agent, llm }: AddBrowser
     const zodSchema = createZodSchemaFromFields(node.inputSchema);
 
     // Create langchain tool
-    const tool = langchainTool(() => { }, {
+    const tool = langchainTool(() => {}, {
       name: 'browser-task',
       description: node.prompt,
-      schema: zodSchema,
+      schema: zodSchema as any,
     });
 
     const combinedPlaybooks = combinePlaybooks(agent.playbooks);

package/src/nodes/addRpaNode.ts

@@ -12,6 +12,8 @@ import { LLMProviders } from '../types/LLM.types';
 import { AIMessage, ToolMessage } from '@langchain/core/messages';
 import { v4 as uuidv4 } from 'uuid';
 import { executeRpaStep } from './rpaStepsExecutor';
+import { createBrowserSession } from '../browserTask/executeBrowserTask';
+import { getConfig } from '../platform/config';
 
 type AddRpaNodeParams = {
   graph: PreCompiledGraph;
@@ -29,13 +31,22 @@ export const addRpaNode = async ({ graph, node, agent, llm }: AddRpaNodeParams)
 
     let browser: Browser | null = null;
     let page: Page | null = null;
+    const { browserTaskMode } = getConfig();
 
+    const session = await createBrowserSession({
+      sessionId: state.sessionId,
+      browserTaskMode,
+    });
+
+    if (!session.sessionId || !session.cdpUrl) {
+      throw new Error('Failed to create browser session: missing session details');
+    }
     // Create tool call for RPA execution
     const toolCallId = uuidv4();
     const aiMessageId = uuidv4();
-
+    state.cdpUrl = session.cdpUrl;
     // Get CDP URL from state
-    const cdpUrl = state.cdpUrl;
+    const cdpUrl = session.cdpUrl;
 
     const toolCall = {
       id: toolCallId,

package/src/toolsLibrary/classifier.ts

@@ -5,6 +5,15 @@ import { JsonOutputParser } from '@langchain/core/output_parsers';
 import { SystemMessage } from '@langchain/core/messages';
 import { BaseLanguageModel } from '@langchain/core/language_models/base';
 
+// Type guard for checking if LLM supports structured output
+interface StructuredOutputLLM extends BaseLanguageModel {
+  withStructuredOutput<T extends z.ZodType>(schema: T): BaseLanguageModel;
+}
+
+function supportsStructuredOutput(llm: BaseLanguageModel): llm is StructuredOutputLLM {
+  return 'withStructuredOutput' in llm && typeof (llm as any).withStructuredOutput === 'function';
+}
+
 // Type definitions for classifier configuration
 export interface ClassDefinition {
   name: string;
@@ -14,53 +23,34 @@ export interface ClassDefinition {
 export interface ClassifierConfig {
   classes: ClassDefinition[];
   systemPrompt?: string;
-  outputFormat?: 'json' | 'text';
-  includeReason?: boolean;
-  defaultClass?: string;
-  defaultReason?: string;
+  defaultClass: string;
+  defaultReason: string;
 }
 
 export interface ClassificationResult {
   class: string;
-  reason?: string;
-  confidence?: number;
+  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',
-};
-
 /**
- * Validates the classification result
- * @param result The classification result to validate
- * @param config The classifier configuration
- * @returns True if the result is valid, false otherwise
+ * Create a dynamic Zod schema for classification result based on valid classes
  */
-function validateClassificationResult(result: ClassificationResult, config: ClassifierConfig): boolean {
-  // Check if result exists and has a class property
-  if (!result || !result.class) {
-    return false;
-  }
+function createClassificationSchema(config: ClassifierConfig): z.ZodSchema {
+  const validClassNames = config.classes.map((c) => c.name);
 
-  // Check if the class is one of the configured classes
-  const validClasses = config.classes.map((c) => c.name);
-  if (!validClasses.includes(result.class)) {
-    return false;
-  }
+  // Create a union type for valid class names
+  const classEnum = z.enum(validClassNames as [string, ...string[]]);
 
-  // If we expect JSON format with confidence, validate it
-  if (config.outputFormat === 'json' && result.confidence !== undefined) {
-    if (typeof result.confidence !== 'number' || result.confidence < 0 || result.confidence > 1) {
-      return false;
-    }
-  }
+  // Build the schema - always include all fields
+  const schemaShape: Record<string, z.ZodTypeAny> = {
+    class: classEnum.describe('The selected classification category'),
+    reason: z.string().describe('Explanation for the classification'),
+    confidence: z.number().min(0).max(1).describe('Confidence score between 0 and 1'),
+  };
 
-  return true;
+  return z.object(schemaShape);
 }
 
 /**
@@ -71,65 +61,49 @@ function validateClassificationResult(result: ClassificationResult, config: Clas
  * @returns The classification result
  */
 export async function classify(content: string, config: ClassifierConfig, llm: BaseLanguageModel): Promise<ClassificationResult> {
-  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
   const MAX_RETRIES = 3;
   let lastError: Error | null = null;
-  let lastInvalidResult: ClassificationResult | null = null;
+
+  // Check if LLM supports structured output upfront
+  if (!supportsStructuredOutput(llm)) {
+    throw new Error('LLM does not support structured output, which is required for classification');
+  }
 
   for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
     try {
       // Build the classification prompt
-      const classesDescription = mergedConfig.classes.map((c) => `${c.name}: ${c.description}`).join('\n');
-      const validClassNames = mergedConfig.classes.map((c) => c.name);
+      const classesDescription = config.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:';
+        config.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`;
 
       // Add retry feedback if this is not the first attempt
-      if (attempt > 1 && lastInvalidResult) {
-        prompt += `\n⚠️ IMPORTANT: Your previous classification attempt was INVALID. `;
-        if (lastInvalidResult.class && !validClassNames.includes(lastInvalidResult.class)) {
-          prompt += `You selected "${lastInvalidResult.class}" which is NOT in the list of valid classes. `;
-        } else if (!lastInvalidResult.class) {
-          prompt += `You did not provide a class value. `;
-        }
+      if (attempt > 1) {
+        const validClassNames = config.classes.map((c) => c.name);
+        prompt += `\n⚠️ IMPORTANT: Your previous classification attempt failed. `;
         prompt += `You MUST select ONLY from these valid classes:\n${validClassNames.join(', ')}\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.';
-      }
+      // Create dynamic schema based on valid classes
+      const classificationSchema = createClassificationSchema(config);
 
+      // Add content to classify to the prompt
       prompt += `\n\nContent to classify:\n${content}`;
 
-      // Make the classification request
-      let result: ClassificationResult;
-      if (mergedConfig.outputFormat === 'json') {
-        const parser = new JsonOutputParser();
-        const parsedResult = await llm.pipe(parser).invoke([new SystemMessage(prompt)]);
-        result = parsedResult as ClassificationResult;
-      } else {
-        const llmResult = await llm.invoke([new SystemMessage(prompt)]);
-        const classText = typeof llmResult.content === 'string' ? llmResult.content.trim() : '';
-        result = { class: classText };
-      }
+      // Use structured output for guaranteed compliance
+      const structuredLLM = llm.withStructuredOutput(classificationSchema);
+      const messages = [new SystemMessage(prompt)];
+      const result = (await structuredLLM.invoke(messages)) as ClassificationResult;
 
-      // Validate the result
-      if (!validateClassificationResult(result, mergedConfig)) {
-        lastInvalidResult = result;
-        throw new Error(`Invalid classification result: ${JSON.stringify(result)}`);
-      }
+      // The result is already validated by withStructuredOutput
+      logger.debug({
+        message: 'Classification successful with structured output',
+        attempt,
+        class: result.class,
+      });
 
-      // Success - return the valid result
       return result;
     } catch (err) {
       lastError = err as Error;
@@ -138,7 +112,6 @@ export async function classify(content: string, config: ClassifierConfig, llm: B
         attempt,
         maxRetries: MAX_RETRIES,
         error: lastError.message,
-        invalidResult: lastInvalidResult,
       });
 
       // If this is not the last attempt, continue to retry
@@ -153,15 +126,14 @@ export async function classify(content: string, config: ClassifierConfig, llm: B
     message: 'Classification failed after max retries, using default class',
     maxRetries: MAX_RETRIES,
     lastError: lastError?.message,
-    lastInvalidResult,
-    defaultClass: mergedConfig.defaultClass,
-    defaultReason: mergedConfig.defaultReason,
+    defaultClass: config.defaultClass,
+    defaultReason: config.defaultReason,
   });
 
   // Return default classification
   return {
-    class: mergedConfig.defaultClass || 'unknown',
-    reason: mergedConfig.defaultReason || `Classification failed after ${MAX_RETRIES} attempts: ${lastError?.message}`,
+    class: config.defaultClass,
+    reason: config.defaultReason,
     confidence: 0,
   };
 }
@@ -169,10 +141,10 @@ export async function classify(content: string, config: ClassifierConfig, llm: B
 /**
  * Create a classifier from a simple class list
  * @param classes Array of class names or [name, description] tuples
- * @param options Additional configuration options
+ * @param options Configuration options (includeReason, defaultClass, defaultReason are required)
  * @returns A configured classify function
  */
-export function createClassifier(classes: string[] | [string, string][], options?: Partial<ClassifierConfig>) {
+export function createClassifier(classes: string[] | [string, string][], options: Omit<ClassifierConfig, 'classes'>) {
   const classDefinitions: ClassDefinition[] = classes.map((c) => {
     if (typeof c === 'string') {
       return { name: c, description: '' };
@@ -205,20 +177,18 @@ export const schema = z.object({
     .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'),
+  defaultClass: z.string().describe('Default class to use if classification fails'),
+  defaultReason: z.string().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.',
+    'Classify content into predefined categories using AI. Supports custom classes and system prompts. Uses structured output for guaranteed schema compliance. Requires default fallback values.',
   input: schema,
   isGlobal: false,
   execute: async ({ input, state, agent }) => {
-    const { content, classes, systemPrompt, includeReason, outputFormat, defaultClass, defaultReason } = input;
+    const { content, classes, systemPrompt, defaultClass, defaultReason } = input;
 
     logger.info({
       message: 'Classifying content',
@@ -253,8 +223,6 @@ const classifierTool: Tool<typeof schema, any> = {
     const config: ClassifierConfig = {
       classes: classDefinitions,
       systemPrompt,
-      includeReason,
-      outputFormat,
       defaultClass,
       defaultReason,
     };
@@ -298,46 +266,50 @@ export async function multiClassify(
   config: ClassifierConfig & { maxClasses?: number },
   llm: BaseLanguageModel,
 ): Promise<ClassificationResult[]> {
-  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
-  const maxClasses = mergedConfig.maxClasses || 3;
+  const maxClasses = config.maxClasses || 3;
+
+  // Check if LLM supports structured output
+  if (!supportsStructuredOutput(llm)) {
+    throw new Error('LLM does not support structured output, which is required for multi-classification');
+  }
 
   try {
-    const classesDescription = mergedConfig.classes.map((c) => `${c.name}: ${c.description}`).join('\n');
+    const classesDescription = config.classes.map((c) => `${c.name}: ${c.description}`).join('\n');
+    const validClassNames = config.classes.map((c) => c.name);
 
-    const basePrompt =
-      mergedConfig.systemPrompt || 'You are a multi-label classifier. Select all applicable categories for the given content:';
+    const basePrompt = config.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.
+Select up to ${maxClasses} classifications, ordered by relevance.
 
 Content to classify:
 ${content}`;
 
-    const parser = new JsonOutputParser();
-    const result = await llm.pipe(parser).invoke([new SystemMessage(prompt)]);
+    // Create schema for array of classifications
+    const classEnum = z.enum(validClassNames as [string, ...string[]]);
+    const multiClassSchema = z
+      .array(
+        z.object({
+          class: classEnum.describe('The selected classification category'),
+          reason: z.string().describe('Explanation for the classification'),
+          confidence: z.number().min(0).max(1).describe('Confidence score between 0 and 1'),
+        }),
+      )
+      .min(1)
+      .max(maxClasses);
 
-    if (Array.isArray(result)) {
-      return result as ClassificationResult[];
-    }
+    const structuredLLM = llm.withStructuredOutput(multiClassSchema);
+    const messages = [new SystemMessage(prompt)];
+    const result = (await structuredLLM.invoke(messages)) as ClassificationResult[];
 
-    // If single result returned, wrap in array
-    return [result as ClassificationResult];
+    return result;
   } catch (err) {
     logger.error({ message: 'Multi-classification failed', err });
 
     return [
       {
-        class: mergedConfig.defaultClass || 'unknown',
-        reason: mergedConfig.defaultReason || (err as Error).message,
+        class: config.defaultClass,
+        reason: config.defaultReason,
         confidence: 0,
       },
     ];