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

package/src/browserTask/executeBrowserTask.ts

@@ -1,213 +0,0 @@
-import { logger } from '../utils/logger';
-
-// Browser Use Cloud API configuration
-const BROWSER_USE_API_BASE_URL = 'https://api.browser-use.com/api/v1';
-
-// Types for Browser Use Cloud API
-export interface CloudTaskResponse {
-  id: string;
-  status: string;
-  live_url?: string;
-  steps?: any[];
-  output?: string;
-}
-
-// Browser Use Cloud API methods
-export const createCloudTask = async (prompt: string, model?: string): Promise<string> => {
-  const apiKey = process.env.BROWSER_USE_API_KEY;
-  if (!apiKey) {
-    throw new Error('BROWSER_USE_API_KEY environment variable is required');
-  }
-
-  logger.debug({ msg: 'Creating cloud browser task', prompt: prompt.substring(0, 100) + '...' });
-
-  const response = await fetch(`${BROWSER_USE_API_BASE_URL}/run-task`, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({
-      task: prompt,
-      use_proxy: false,
-      llm_model: model || 'gpt-4o',
-    }),
-  });
-
-  if (!response.ok) {
-    logger.error({ msg: 'Failed to create cloud browser task', status: response.status, statusText: response.statusText });
-    throw new Error(`Failed to create browser task: ${response.statusText}`);
-  }
-
-  const data = await response.json();
-  logger.debug({ msg: 'Cloud browser task created', taskId: data.id });
-  return data.id;
-};
-
-export const getTaskDetails = async (taskId: string): Promise<CloudTaskResponse> => {
-  const apiKey = process.env.BROWSER_USE_API_KEY;
-  if (!apiKey) {
-    throw new Error('BROWSER_USE_API_KEY environment variable is required');
-  }
-
-  const response = await fetch(`${BROWSER_USE_API_BASE_URL}/task/${taskId}`, {
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-    },
-  });
-
-  if (!response.ok) {
-    logger.error({ msg: 'Failed to get task details', taskId, status: response.status, statusText: response.statusText });
-    throw new Error(`Failed to get task details: ${response.statusText}`);
-  }
-
-  return response.json();
-};
-
-export const waitForLiveUrl = async (taskId: string, maxWaitTime: number = 30000): Promise<CloudTaskResponse> => {
-  const startTime = Date.now();
-  const pollInterval = 2000; // 2 seconds
-  let pollCount = 0;
-
-  logger.debug({ msg: 'Starting to poll for live_url', taskId, maxWaitTime, pollInterval });
-
-  while (Date.now() - startTime < maxWaitTime) {
-    pollCount++;
-    const elapsedTime = Date.now() - startTime;
-
-    logger.trace({
-      msg: 'Polling for live_url',
-      taskId,
-      pollCount,
-      elapsedTime,
-      remainingTime: maxWaitTime - elapsedTime,
-    });
-
-    const taskDetails = await getTaskDetails(taskId);
-
-    logger.trace({
-      msg: 'Task details received',
-      taskId,
-      status: taskDetails.status,
-      hasLiveUrl: !!taskDetails.live_url,
-      pollCount,
-    });
-
-    if (taskDetails.live_url) {
-      logger.debug({
-        msg: 'Live URL available',
-        taskId,
-        liveUrl: taskDetails.live_url,
-        pollCount,
-        totalTime: elapsedTime,
-      });
-      return taskDetails;
-    }
-
-    if (taskDetails.status === 'failed' || taskDetails.status === 'stopped') {
-      logger.error({
-        msg: 'Task failed while waiting for live_url',
-        taskId,
-        status: taskDetails.status,
-        pollCount,
-        elapsedTime,
-      });
-      throw new Error(`Task failed with status: ${taskDetails.status}`);
-    }
-
-    logger.trace({
-      msg: 'Live URL not yet available, continuing to poll',
-      taskId,
-      status: taskDetails.status,
-      pollCount,
-      nextPollIn: pollInterval,
-    });
-
-    await new Promise((resolve) => setTimeout(resolve, pollInterval));
-  }
-
-  logger.error({
-    msg: 'Timeout waiting for live_url',
-    taskId,
-    pollCount,
-    totalTime: Date.now() - startTime,
-    maxWaitTime,
-  });
-  throw new Error('Timeout waiting for live_url to become available');
-};
-
-export const waitForCompletion = async (taskId: string, maxWaitTime: number = 300000): Promise<CloudTaskResponse> => {
-  const startTime = Date.now();
-  const pollInterval = 3000; // 3 seconds for completion polling
-  let pollCount = 0;
-
-  logger.debug({ msg: 'Starting to poll for task completion', taskId, maxWaitTime, pollInterval });
-
-  while (Date.now() - startTime < maxWaitTime) {
-    pollCount++;
-    const elapsedTime = Date.now() - startTime;
-
-    logger.trace({
-      msg: 'Polling for task completion',
-      taskId,
-      pollCount,
-      elapsedTime,
-      remainingTime: maxWaitTime - elapsedTime,
-    });
-
-    const taskDetails = await getTaskDetails(taskId);
-
-    logger.trace({
-      msg: 'Task completion status received',
-      taskId,
-      status: taskDetails.status,
-      pollCount,
-      hasOutput: !!taskDetails.output,
-      stepCount: taskDetails.steps?.length || 0,
-    });
-
-    if (taskDetails.status === 'finished') {
-      logger.debug({
-        msg: 'Task completed successfully',
-        taskId,
-        pollCount,
-        totalTime: elapsedTime,
-        stepCount: taskDetails.steps?.length || 0,
-        hasOutput: !!taskDetails.output,
-      });
-      return taskDetails;
-    }
-
-    if (taskDetails.status === 'failed' || taskDetails.status === 'stopped') {
-      logger.error({
-        msg: 'Task failed during completion polling',
-        taskId,
-        status: taskDetails.status,
-        pollCount,
-        elapsedTime,
-        stepCount: taskDetails.steps?.length || 0,
-      });
-      throw new Error(`Task failed with status: ${taskDetails.status}`);
-    }
-
-    logger.trace({
-      msg: 'Task still in progress, continuing to poll',
-      taskId,
-      status: taskDetails.status,
-      pollCount,
-      stepCount: taskDetails.steps?.length || 0,
-      nextPollIn: pollInterval,
-    });
-
-    await new Promise((resolve) => setTimeout(resolve, pollInterval));
-  }
-
-  logger.error({
-    msg: 'Timeout waiting for task completion',
-    taskId,
-    pollCount,
-    totalTime: Date.now() - startTime,
-    maxWaitTime,
-  });
-  throw new Error('Timeout waiting for task completion');
-};

package/src/checkpointer/checkpointSaverFactory.ts

@@ -1,18 +0,0 @@
-import { BaseCheckpointSaver, MemorySaver } from '@langchain/langgraph';
-import { MindedCheckpointSaver } from '../platform/mindedCheckpointSaver';
-import * as mindedConnection from '../platform/mindedConnection';
-import { logger } from '../utils/logger';
-
-/**
- * Factory function to create the appropriate checkpoint saver based on environment variables.
- * @returns BaseCheckpointSaver instance (either MemorySaver or MindedCheckpointSaver)
- */
-export function createCheckpointSaver(): BaseCheckpointSaver {
-  if (!mindedConnection.isConnected()) {
-    logger.warn('mindedConnection not connected, falling back to in-memory checkpoint saver');
-    return new MemorySaver();
-  }
-
-  logger.debug('[Agent] Using remote checkpoint saver');
-  return new MindedCheckpointSaver();
-}

package/src/cli/index.ts

@@ -1,170 +0,0 @@
-#!/usr/bin/env node
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { logger } from '../utils/logger';
-import { execSync } from 'child_process';
-
-const ENV_FILE = '.env';
-
-function getEnvFilePath(): string {
-  return path.join(process.cwd(), ENV_FILE);
-}
-
-function setToken(token: string): void {
-  const envPath = getEnvFilePath();
-  const tokenLine = `MINDED_CONNECTION_TOKEN=${token}`;
-
-  // Check if .env file exists
-  if (!fs.existsSync(envPath)) {
-    // Create .env file with the token
-    fs.writeFileSync(envPath, tokenLine + '\n');
-    logger.info(`Created ${envPath} and added token`);
-  } else {
-    // Read existing .env file
-    const envContent = fs.readFileSync(envPath, 'utf8');
-
-    // Check if MINDED_CONNECTION_TOKEN already exists
-    if (envContent.includes('MINDED_CONNECTION_TOKEN=')) {
-      // Replace existing token
-      const updatedContent = envContent.replace(/MINDED_CONNECTION_TOKEN=.*/, tokenLine);
-      fs.writeFileSync(envPath, updatedContent);
-      logger.info(`Updated MINDED_CONNECTION_TOKEN in ${envPath}`);
-    } else {
-      // Append token to existing file
-      const newContent = envContent.endsWith('\n') ? envContent + tokenLine + '\n' : envContent + '\n' + tokenLine + '\n';
-      fs.writeFileSync(envPath, newContent);
-      logger.info(`Added MINDED_CONNECTION_TOKEN to ${envPath}`);
-    }
-  }
-}
-
-function generateLambdaHandler(): void {
-  const mindedConfigPath = path.join(process.cwd(), 'minded.json');
-
-  // Check if minded.json exists
-  if (!fs.existsSync(mindedConfigPath)) {
-    logger.error('minded.json not found in the current directory');
-    process.exit(1);
-  }
-
-  // Read and parse minded.json
-  let mindedConfig;
-  try {
-    const configContent = fs.readFileSync(mindedConfigPath, 'utf8');
-    mindedConfig = JSON.parse(configContent);
-  } catch (error) {
-    logger.error('Failed to read or parse minded.json:', error);
-    process.exit(1);
-  }
-
-  // Get the agent path
-  const agentPath = mindedConfig.agent;
-  if (!agentPath) {
-    logger.error('No agent path found in minded.json');
-    process.exit(1);
-  }
-
-  // Remove .ts or .js extension if present and convert to relative path
-  const modulePath = agentPath.replace(/\.(ts|js)$/, '');
-
-  // Get the path to the template file
-  // Try multiple locations to support both development and npm package scenarios
-  const templatePaths = [
-    path.join(__dirname, 'lambdaHandlerTemplate.ts'), // For npm package
-    path.join(__dirname, '..', '..', 'src', 'cli', 'lambdaHandlerTemplate.ts'), // For development
-  ];
-
-  let templateContent: string | null = null;
-
-  // Try each path until we find the template
-  for (const templatePath of templatePaths) {
-    try {
-      if (fs.existsSync(templatePath)) {
-        templateContent = fs.readFileSync(templatePath, 'utf8');
-        logger.debug(`Found template at ${templatePath}`);
-        break;
-      }
-    } catch {
-      // Continue to next path
-    }
-  }
-
-  if (!templateContent) {
-    logger.error('Could not find Lambda handler template file');
-    process.exit(1);
-  }
-
-  try {
-    // Replace the placeholder with the actual module path
-    templateContent = templateContent.replace(/{MODULE_PATH}/g, modulePath);
-
-    // Write the Lambda handler to index.ts at the root
-    const outputPath = path.join(process.cwd(), 'index.ts');
-    fs.writeFileSync(outputPath, templateContent);
-    logger.info(`Generated Lambda handler at ${outputPath}`);
-
-    // Compile the index.ts file using TypeScript
-    logger.info('Compiling the Lambda handler...');
-
-    try {
-      // Read tsconfig.json to get the outDir
-      let outDir = 'dist'; // Default value
-      const tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
-
-      if (fs.existsSync(tsconfigPath)) {
-        try {
-          const tsconfigContent = fs.readFileSync(tsconfigPath, 'utf8');
-          const tsconfig = JSON.parse(tsconfigContent);
-
-          if (tsconfig.compilerOptions && tsconfig.compilerOptions.outDir) {
-            outDir = tsconfig.compilerOptions.outDir;
-            logger.debug(`Using outDir from tsconfig.json: ${outDir}`);
-          }
-        } catch {
-          logger.warn('Failed to parse tsconfig.json, using default outDir: dist');
-        }
-      }
-
-      // Check if output directory exists, create if it doesn't
-      const distDir = path.join(process.cwd(), outDir);
-      if (!fs.existsSync(distDir)) {
-        fs.mkdirSync(distDir, { recursive: true });
-      }
-
-      // Compile index.ts to the configured output directory
-      execSync(`npx tsc --target ES2018 --module CommonJS --esModuleInterop ${outputPath} --outDir ${outDir}`, {
-        stdio: 'pipe',
-        cwd: process.cwd(),
-      });
-
-      logger.info(`Successfully compiled Lambda handler to ${outDir}/index.js`);
-    } catch (compileError) {
-      logger.error({ message: 'Failed to compile Lambda handler', error: compileError });
-    }
-  } catch (error) {
-    logger.error({ message: 'Failed to generate Lambda handler', error: error });
-    process.exit(1);
-  }
-}
-
-function main() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  if (command === 'token') {
-    const token = args[1];
-    if (!token) {
-      logger.error('Please provide a token');
-      process.exit(1);
-    }
-    setToken(token);
-  } else if (command === 'generate-lambda-ts-handler') {
-    generateLambdaHandler();
-  } else {
-    logger.error('Unknown command. Available commands: token, generate-lambda-ts-handler');
-    process.exit(1);
-  }
-}
-
-main();

package/src/cli/lambdaHandlerTemplate.ts

@@ -1,45 +0,0 @@
-// This is the template for the Lambda handler
-// The {MODULE_PATH} placeholder will be replaced with the actual path
-
-export const handler = async (event: any, context: any) => {
-  const modulePath = '{MODULE_PATH}'; // Module path placeholder - DO NOT CHANGE THE {MODULE_PATH} TOKEN
-  const resolvedPath = require.resolve(modulePath);
-  delete require.cache[resolvedPath];
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const agent = require(modulePath).default;
-  const { agentFunctionName, agentFunctionBody } = event.body ? JSON.parse(event.body) : event;
-
-  if (!agent[agentFunctionName]) {
-    throw new Error('Unknown agentFunctionName: ' + agentFunctionName);
-  }
-
-  const response = await agent[agentFunctionName](agentFunctionBody);
-
-  // Safely stringify the response. If it fails (e.g., due to circular refs
-  // or non-serialisable class instances), fall back to null.
-  let responseBody = null;
-  try {
-    JSON.stringify(response);
-    responseBody = response;
-  } catch {
-    // ignored - responseBody stays null
-  }
-
-  if (agentFunctionName === 'startVoiceSession') {
-    const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
-    while (context.getRemainingTimeInMillis() > 1000) {
-      console.log('Lambda remaining time in seconds: ', context.getRemainingTimeInMillis() / 1000);
-      await wait(1000); // sleep 1 s
-    }
-  }
-
-  return {
-    statusCode: 200,
-    headers: {
-      'Content-Type': 'application/json',
-      'Access-Control-Allow-Origin': '*',
-      'Access-Control-Allow-Credentials': true,
-    },
-    body: JSON.stringify(responseBody),
-  };
-};

package/src/edges/createDirectEdge.ts

@@ -1,16 +0,0 @@
-import { StepForwardEdge } from '../types/Flows.types';
-import { stateAnnotation } from '../types/LangGraph.types';
-import { logger } from '../utils/logger';
-
-export const createDirectEdge = (edge: StepForwardEdge) => {
-  return async (state: typeof stateAnnotation.State) => {
-    if (state.goto) {
-      console.log('Jumping to node', state.goto);
-      return state.goto;
-    }
-    // For direct edges, we just return the target of the first edge
-    // since there's no conditional logic needed
-    logger.info({ msg: `[Router] Direct edge`, target: edge.target });
-    return edge.target;
-  };
-};

package/src/edges/createLogicalRouter.ts

@@ -1,114 +0,0 @@
-import { LogicalConditionEdge } from '../types/Flows.types';
-import { stateAnnotation } from '../types/LangGraph.types';
-import { logger } from '../utils/logger';
-import * as vm from 'vm';
-
-// Default timeout for condition evaluation (in milliseconds)
-const CONDITION_TIMEOUT = 5000; // 5 seconds
-
-export const createLogicalRouter = ({ edges }: { edges: LogicalConditionEdge[] }) => {
-  return async (state: typeof stateAnnotation.State) => {
-    logger.debug({ msg: `[Router] Evaluating logical conditions for ${edges.length} edges` });
-
-    if (state.goto) {
-      console.log('Jumping to node', state.goto);
-      return state.goto;
-    }
-
-    // Separate regular conditions from "else" conditions
-    const regularEdges = edges.filter((edge) => edge.condition.trim() !== 'else');
-    const elseEdges = edges.filter((edge) => edge.condition.trim() === 'else');
-
-    // First, evaluate all regular conditions
-    for (const edge of regularEdges) {
-      try {
-        // Customer is responsible for providing valid JavaScript syntax
-        // We execute their condition in a sandboxed VM with timeout protection
-        const conditionCode = `
-          (function({ state }) {
-            return ${edge.condition}
-          })
-        `;
-
-        // Create a sandboxed context with limited access
-        const context = vm.createContext({
-          // Provide safe utilities that customers might need
-          console: {
-            log: (...args: any[]) => logger.debug('Customer condition log:', ...args),
-            error: (...args: any[]) => logger.debug('Customer condition error:', ...args),
-          },
-          // Add other safe globals if needed
-          JSON,
-          Math,
-          Date,
-          // Prevent access to dangerous globals
-          process: undefined,
-          require: undefined,
-          global: undefined,
-          Buffer: undefined,
-        });
-
-        // Compile and run the condition with timeout
-        const script = new vm.Script(conditionCode, {
-          filename: `edge-condition-${edge.source}-to-${edge.target}`,
-        });
-
-        const conditionFn = script.runInContext(context, {
-          timeout: CONDITION_TIMEOUT,
-        });
-
-        // Execute the customer's condition with the current state
-        const result = await Promise.race([
-          Promise.resolve(conditionFn({ state })),
-          new Promise((_, reject) => setTimeout(() => reject(new Error('Condition execution timeout')), CONDITION_TIMEOUT)),
-        ]);
-
-        if (result === true) {
-          if (edge.source == edge.target) {
-            logger.info({ msg: `[Router] Stay at node ${edge.source}`, node: edge.source, condition: edge.condition });
-          } else {
-            logger.info({
-              msg: `[Router] Logical condition matched`,
-              transitionFrom: edge.source,
-              transitionTo: edge.target,
-              condition: edge.condition,
-            });
-          }
-          return edge.target;
-        }
-      } catch (error) {
-        // Provide detailed error information back to the customer
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const conditionPreview = edge.condition.length > 100 ? `${edge.condition.substring(0, 100)}...` : edge.condition;
-
-        logger.error({
-          msg: `[Router] Error evaluating condition for edge ${edge.source} → ${edge.target}`,
-          condition: conditionPreview,
-          error: errorMessage,
-          edgeIndex: edges.indexOf(edge),
-          timeout: CONDITION_TIMEOUT,
-        });
-
-        // Continue to next edge instead of failing completely
-        // This allows other conditions to be evaluated even if one fails
-        continue;
-      }
-    }
-
-    // If no regular conditions matched, check for "else" conditions
-    if (elseEdges.length > 0) {
-      // Return the first "else" condition's target
-      const elseEdge = elseEdges[0];
-      logger.info({
-        msg: `[Router] Else condition matched`,
-        transitionFrom: elseEdge.source,
-        transitionTo: elseEdge.target,
-      });
-      return elseEdge.target;
-    }
-
-    // If no conditions matched or all failed, return to the source node
-    logger.info({ msg: `[Router] Stay at node ${edges[0].source}, no conditions matched`, node: edges[0].source });
-    return null;
-  };
-};