@minded-ai/mindedjs 1.0.102 → 1.0.103-beta-1

package/dist/platform/models/parallelWrapper.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createParallelWrapper = createParallelWrapper;
-const logger_1 = require("../../utils/logger");
-/**
- * Creates a wrapped version of a chat model with parallel request capabilities
- */
-function createParallelWrapper(model, fields) {
-    const numParallelRequests = (fields === null || fields === void 0 ? void 0 : fields.numParallelRequests) || 1;
-    const logTimings = (fields === null || fields === void 0 ? void 0 : 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 = (promises) => {
-        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, options, runManager) {
-        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_1.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_1.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, options, runManager) {
-        // 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_1.logger.debug({
-                msg: '[Model] Streaming mode - using single request',
-                reason: 'Parallel streaming not implemented',
-            });
-        }
-        yield* originalStream(messages, options, runManager);
-    };
-    // Add properties for testing
-    model.numParallelRequests = numParallelRequests;
-    model.logTimings = logTimings;
-    return model;
-}
-//# sourceMappingURL=parallelWrapper.js.map

package/dist/platform/models/parallelWrapper.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parallelWrapper.js","sourceRoot":"","sources":["../../../src/platform/models/parallelWrapper.ts"],"names":[],"mappings":"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"}

package/docs/platform/parallel-llm.md

@@ -1,242 +0,0 @@
-# Parallel LLM Requests
-
-Parallel LLM requests can significantly reduce latency by sending multiple identical requests and using the fastest response. This feature can reduce response times by 30-50% in scenarios with variable network conditions.
-
-## Quick Start
-
-The easiest way to enable parallel requests is through your `minded.json` configuration:
-
-```json
-{
-  "flows": ["./src/flows"],
-  "tools": ["./src/tools"],
-  "agent": "./src/agent.ts",
-  "llm": {
-    "name": "MindedChatOpenAI",
-    "properties": {
-      "model": "gpt-4o",
-      "numParallelRequests": 3,
-      "logTimings": true
-    }
-  }
-}
-```
-
-Your agent will automatically use parallel requests for all LLM calls:
-
-```typescript
-import { Agent } from '@minded-ai/mindedjs';
-import memorySchema from './agentMemorySchema';
-import config from '../minded.json';
-import tools from './tools';
-
-const agent = new Agent({
-  memorySchema,
-  config, // Parallel configuration is automatically applied
-  tools,
-});
-```
-
-## Configuration Options
-
-### MindedChatOpenAI (Recommended)
-
-For agents running on the Minded platform, use `MindedChatOpenAI` with parallel configuration:
-
-```json
-{
-  "llm": {
-    "name": "MindedChatOpenAI",
-    "properties": {
-      "model": "gpt-4o",
-      "numParallelRequests": 3,
-      "logTimings": true,
-      "temperature": 0.7
-    }
-  }
-}
-```
-
-### AzureChatOpenAI
-
-For Azure OpenAI deployments:
-
-```json
-{
-  "llm": {
-    "name": "AzureChatOpenAI",
-    "properties": {
-      "model": "gpt-4o",
-      "numParallelRequests": 3,
-      "logTimings": true,
-      "azureOpenAIApiVersion": "2024-02-01"
-    }
-  }
-}
-```
-
-Required environment variables:
-
-```env
-AZURE_OPENAI_API_KEY=your_azure_key
-AZURE_OPENAI_API_INSTANCE_NAME=your_instance_name
-AZURE_OPENAI_API_DEPLOYMENT_NAME=your_deployment_name
-```
-
-### ChatOpenAI
-
-For standard OpenAI API:
-
-```json
-{
-  "llm": {
-    "name": "ChatOpenAI",
-    "properties": {
-      "model": "gpt-4o",
-      "numParallelRequests": 3,
-      "logTimings": true,
-      "openAIApiKey": "${OPENAI_API_KEY}"
-    }
-  }
-}
-```
-
-## Configuration Parameters
-
-| Parameter             | Type    | Default | Description                                   |
-| --------------------- | ------- | ------- | --------------------------------------------- |
-| `numParallelRequests` | number  | 1       | Number of parallel requests (2-5 recommended) |
-| `logTimings`          | boolean | false   | Enable detailed timing logs                   |
-
-## Performance Notes
-
-- **Optimal Range**: 2-3 parallel requests usually provide the best latency/cost balance
-- **Cost Impact**: You pay for all parallel requests made
-- **Best Use Cases**: Variable network conditions, consistency requirements
-- **Latency Reduction**: Typically 30-50% faster response times
-
-## Monitoring Performance
-
-When `logTimings: true` is enabled, you'll see detailed performance logs:
-
-```
-[Model] Fastest request completed { requestTime: 1.234, numParallelRequests: 3 }
-[Model] Time saved using parallel requests {
-  fastestRequestTime: 1.234,
-  secondFastestRequestTime: 1.567,
-  allFinishTime: 2.345,
-  timeSaved: 1.111,
-  timeSavedFromSecond: 0.333
-}
-```
-
-## Advanced Usage
-
-### Dynamic Configuration
-
-You can adjust parallel requests based on environment:
-
-```json
-{
-  "llm": {
-    "name": "MindedChatOpenAI",
-    "properties": {
-      "model": "gpt-4o",
-      "numParallelRequests": "${NODE_ENV === 'production' ? 3 : 1}",
-      "logTimings": "${NODE_ENV === 'development'}"
-    }
-  }
-}
-```
-
-### Manual Instantiation with createParallelWrapper
-
-For advanced use cases where you need direct control over the LLM instance, you can manually apply parallel wrapping:
-
-```typescript
-import { createParallelWrapper } from '@minded-ai/mindedjs';
-import { ChatOpenAI, AzureChatOpenAI } from '@langchain/openai';
-
-// Manual wrapping for ChatOpenAI
-const parallelOpenAI = createParallelWrapper(
-  new ChatOpenAI({
-    openAIApiKey: process.env.OPENAI_API_KEY,
-    model: 'gpt-4o',
-    temperature: 0.7,
-  }),
-  {
-    numParallelRequests: 3,
-    logTimings: true,
-  },
-);
-
-// Manual wrapping for AzureChatOpenAI
-const parallelAzure = createParallelWrapper(
-  new AzureChatOpenAI({
-    azureOpenAIApiKey: process.env.AZURE_OPENAI_API_KEY,
-    azureOpenAIApiInstanceName: process.env.AZURE_OPENAI_INSTANCE!,
-    azureOpenAIApiDeploymentName: process.env.AZURE_OPENAI_DEPLOYMENT!,
-    azureOpenAIApiVersion: '2024-02-01',
-  }),
-  {
-    numParallelRequests: 2,
-    logTimings: false,
-  },
-);
-
-// Use directly with Agent (bypassing configuration)
-const agent = new Agent({
-  memorySchema,
-  config: {
-    flows: ['./flows'],
-    tools: [],
-    llm: parallelOpenAI as any, // Direct LLM instance
-  },
-  tools: [],
-});
-```
-
-**Note**: The configuration-based approach is recommended for most use cases as it's simpler and more maintainable. Use manual instantiation only when you need specific control over LLM creation or are integrating with existing LangChain workflows.
-
-## How It Works
-
-### MindedChatOpenAI (Backend Processing)
-
-- Parallel requests are handled on the Minded platform backend
-- Multiple requests sent to Azure OpenAI from the backend
-- Fastest response returned to your agent
-- Optimal for production deployments
-
-### Other LLM Providers (Client-Side Processing)
-
-- Parallel requests handled in your application
-- Multiple requests sent directly to the LLM provider
-- Good for development and custom deployments
-
-## Best Practices
-
-1. **Start Small**: Begin with 2-3 parallel requests
-2. **Monitor Costs**: Each parallel request counts toward your usage
-3. **Enable Logging**: Use `logTimings: true` during development to measure improvements
-4. **Environment-Specific**: Use fewer parallel requests in development
-5. **Configuration Over Code**: Prefer `minded.json` configuration over manual instantiation
-
-## Troubleshooting
-
-### No Performance Improvement
-
-- Check network latency variability
-- Ensure `numParallelRequests > 1`
-- Verify timing logs are showing multiple requests
-
-### Increased Costs
-
-- Reduce `numParallelRequests`
-- Consider cost vs. latency trade-offs
-- Monitor usage patterns
-
-### Rate Limiting
-
-- Lower `numParallelRequests`
-- Implement backoff strategies
-- Contact provider about rate limits

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');
-};