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

package/src/nodes/addBrowserTaskNode.ts

@@ -1,229 +0,0 @@
-import { RunnableLike } from '@langchain/core/runnables';
-import { BrowserTaskNode, NodeType } from '../types/Flows.types';
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { HistoryStep } from '../types/Agent.types';
-import { logger } from '../utils/logger';
-import { createHistoryStep } from '../utils/history';
-import { AIMessage, SystemMessage } from '@langchain/core/messages';
-import { v4 as uuidv4 } from 'uuid';
-import { Agent } from '../agent';
-import { createCloudTask, waitForLiveUrl } from '../browserTask/executeBrowserTask';
-import { tool as langchainTool } from '@langchain/core/tools';
-import { z } from 'zod';
-import { LLMProviders } from '../types/LLM.types';
-import { compilePlaybooks } from '../playbooks/playbooks';
-import * as ejs from 'ejs';
-
-/**
- * Compile prompt with parameters using EJS and placeholder replacement
- */
-function compilePrompt(prompt: string, params: Record<string, any> = {}): string {
-  try {
-    // First, render with EJS
-    let compiledPrompt = ejs.render(prompt, params);
-
-    // Then, replace placeholders in {} format
-    compiledPrompt = replacePlaceholders(compiledPrompt, params);
-
-    return compiledPrompt;
-  } catch (error) {
-    logger.error({ message: 'Error compiling prompt', error });
-    return prompt; // 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);
-  });
-}
-
-type AddBrowserTaskNodeParams = {
-  graph: PreCompiledGraph;
-  node: BrowserTaskNode;
-  agent: Agent;
-  llm: (typeof LLMProviders)[keyof typeof LLMProviders];
-};
-
-export const addBrowserTaskNode = async ({ graph, node, agent, llm }: AddBrowserTaskNodeParams) => {
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info({ msg: `Executing browser task node ${node.displayName}`, prompt: node.prompt });
-
-    // Create Zod schema from inputSchema
-    const schemaFields: Record<string, z.ZodTypeAny> = {};
-    if (node.inputSchema) {
-      for (const field of node.inputSchema) {
-        let fieldSchema: z.ZodTypeAny;
-
-        if (field.type === 'string') {
-          fieldSchema = z.string();
-        } else if (field.type === 'number') {
-          fieldSchema = z.number();
-        } else {
-          fieldSchema = z.string(); // Default to string
-        }
-
-        if (field.description) {
-          fieldSchema = fieldSchema.describe(field.description);
-        }
-
-        if (field.required === false) {
-          fieldSchema = fieldSchema.optional();
-        }
-
-        schemaFields[field.name] = fieldSchema;
-      }
-    }
-
-    const zodSchema = z.object(schemaFields);
-
-    // Create langchain tool
-    const tool = langchainTool(() => { }, {
-      name: 'browser-task',
-      description: node.prompt,
-      schema: zodSchema,
-    });
-
-    // Get compiled playbooks
-    const playbookParams = {
-      ...state.memory,
-      state,
-      currentTime: new Date().toISOString(),
-    };
-    const compiledPlaybooks = compilePlaybooks(agent.playbooks, playbookParams) || '';
-
-    const systemPrompt = `${compiledPlaybooks ? compiledPlaybooks + '\n\n' : ''}
-Additional context:
-- workflow memory: ${JSON.stringify(state.memory)}`;
-
-    try {
-      // Use LLM to generate tool call
-      const AIToolCallMessage: AIMessage = await llm
-        .bindTools([tool], {
-          tool_choice: tool.name,
-        })
-        .invoke([...state.messages, new SystemMessage(systemPrompt)]);
-
-      if (!AIToolCallMessage.tool_calls || AIToolCallMessage.tool_calls.length === 0) {
-        throw new Error('No tool calls generated by LLM');
-      }
-
-      const toolCall = AIToolCallMessage.tool_calls[0];
-      const inputParams = toolCall.args || {};
-
-      // Prepare parameters for prompt compilation
-      const promptParams = {
-        input: inputParams,
-        state,
-        currentTime: new Date().toISOString(),
-      };
-
-      // Compile the prompt with parameters
-      const compiledPrompt = compilePrompt(node.prompt, promptParams);
-
-      // Build the full prompt with compiled content
-      const fullPrompt = `
-Follow the instructions. Any retrieved data should be printed as string and not saved to a file.
-
-# Task instructions:
-${compiledPrompt}
-
-${Object.keys(inputParams).length > 0 ? `# Input parameters:\n${JSON.stringify(inputParams, null, 2)}\n\n` : ''}
-${state.memory ? `# Task context:\n${JSON.stringify(state.memory)}\n\n` : ''}
-`;
-
-      // Create the browser task in the cloud
-      const taskId = await createCloudTask(fullPrompt, node.model);
-      logger.debug({ msg: 'Browser task created', taskId });
-
-      // Wait for live_url to become available
-      const taskDetails = await waitForLiveUrl(taskId);
-      logger.debug({ msg: 'Live URL available', taskId, liveUrl: taskDetails.live_url });
-
-      // Update the tool call with taskId and other metadata
-      const updatedToolCall = {
-        ...toolCall,
-        args: {
-          ...inputParams,
-          taskId,
-          prompt: fullPrompt,
-        },
-      };
-
-      const toolCallingMessage = new AIMessage({
-        id: AIToolCallMessage.id,
-        content: AIToolCallMessage.content,
-        tool_calls: [updatedToolCall],
-        additional_kwargs: {
-          mindedMetadata: {
-            nodeType: NodeType.BROWSER_TASK,
-            taskId,
-            liveUrl: taskDetails.live_url,
-          },
-        },
-      });
-
-      return {
-        history: createHistoryStep<HistoryStep>(state.history, {
-          type: NodeType.BROWSER_TASK,
-          nodeId: node.name,
-          nodeDisplayName: node.displayName,
-          raw: { taskId, liveUrl: taskDetails.live_url, inputParams },
-          messageIds: [toolCallingMessage.id!],
-        }),
-        messages: [toolCallingMessage],
-      };
-    } catch (error: any) {
-      logger.error(`Error creating browser task node ${node.displayName}: ${error}`);
-
-      const errorMessageId = uuidv4();
-      const errorToolCallId = uuidv4();
-
-      const toolCallingMessage = new AIMessage({
-        id: errorMessageId,
-        content: '',
-        tool_calls: [
-          {
-            id: errorToolCallId,
-            name: 'browser-task',
-            args: {
-              error: error.message,
-            },
-          },
-        ],
-        additional_kwargs: {
-          mindedMetadata: {
-            nodeType: NodeType.BROWSER_TASK,
-            error: error.message,
-          },
-        },
-      });
-
-      return {
-        history: createHistoryStep<HistoryStep>(state.history, {
-          type: NodeType.BROWSER_TASK,
-          nodeId: node.name,
-          nodeDisplayName: node.displayName,
-          raw: error,
-          messageIds: [errorMessageId],
-        }),
-        messages: [toolCallingMessage],
-      };
-    }
-  };
-  graph.addNode(node.name, callback);
-};

package/src/nodes/addBrowserTaskRunNode.ts

@@ -1,142 +0,0 @@
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { RunnableLike } from '@langchain/core/runnables';
-import { internalNodesSuffix, NodeType, BrowserTaskNode } from '../types/Flows.types';
-import { ToolMessage, AIMessage } from '@langchain/core/messages';
-import { Agent } from '../agent';
-import { logger } from '../utils/logger';
-import { createHistoryStep } from '../utils/history';
-import { HistoryStep } from '../types/Agent.types';
-import { v4 as uuidv4 } from 'uuid';
-import { waitForCompletion } from '../browserTask/executeBrowserTask';
-
-type AddBrowserTaskRunNodeParams = {
-  graph: PreCompiledGraph;
-  browserTaskNode: BrowserTaskNode;
-  attachedToNodeName: string;
-  agent: Agent;
-};
-
-export const buildBrowserTaskRunNodeName = (nodeName: string) => `${nodeName}${internalNodesSuffix.BROWSER_TASK_RUN}`;
-
-export const addBrowserTaskRunNode = async ({ graph, browserTaskNode, attachedToNodeName }: AddBrowserTaskRunNodeParams) => {
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing browser task run node for ${browserTaskNode.displayName}`);
-
-    const toolCallObj = state.messages[state.messages.length - 1] as any;
-    if (!toolCallObj.tool_calls) {
-      throw new Error('Tool call not found');
-    }
-
-    const toolCall = toolCallObj.tool_calls[0];
-    const { taskId, ...inputParams } = toolCall.args;
-
-    if (!taskId) {
-      throw new Error('Task ID not found in tool call arguments');
-    }
-
-    try {
-      // Wait for task completion
-      const completedTask = await waitForCompletion(taskId);
-      logger.debug({ msg: 'Browser task completed', taskId, output: completedTask.output });
-
-      // Create tool message with the result
-      const toolMessage = new ToolMessage({
-        id: uuidv4(),
-        content: JSON.stringify({
-          result: completedTask.output || 'Task completed successfully',
-          steps: completedTask.steps || [],
-          inputParams: inputParams,
-        }),
-        name: 'browser-task',
-        tool_call_id: toolCall.id,
-        status: 'success',
-        additional_kwargs: {
-          mindedMetadata: {
-            nodeType: NodeType.BROWSER_TASK,
-            taskId,
-            steps: completedTask.steps,
-            inputParams: inputParams,
-          },
-        },
-      });
-
-      // Update the AI message with steps using the message reducer pattern
-      const updatedAIMessage = new AIMessage({
-        id: toolCallObj.id,
-        content: toolCallObj.content,
-        tool_calls: toolCallObj.tool_calls,
-        additional_kwargs: {
-          ...toolCallObj.additional_kwargs,
-          mindedMetadata: {
-            ...toolCallObj.additional_kwargs?.mindedMetadata,
-            steps: completedTask.steps,
-            status: 'completed',
-          },
-          update: true, // This triggers the message reducer to update the existing message
-        },
-      });
-
-      return {
-        messages: [toolMessage, updatedAIMessage],
-        history: createHistoryStep<HistoryStep>(state.history, {
-          type: NodeType.BROWSER_TASK,
-          nodeId: browserTaskNode.name,
-          nodeDisplayName: browserTaskNode.displayName,
-          raw: completedTask,
-          messageIds: [],
-        }),
-      };
-    } catch (error: any) {
-      logger.error({ msg: 'Error executing browser task run node', error });
-
-      const errorToolMessage = new ToolMessage({
-        id: uuidv4(),
-        content: JSON.stringify({
-          error: error instanceof Error ? error.message : error.toString(),
-          inputParams: inputParams,
-        }),
-        status: 'error',
-        name: 'browser-task',
-        tool_call_id: toolCall.id,
-        additional_kwargs: {
-          mindedMetadata: {
-            nodeType: NodeType.BROWSER_TASK,
-            taskId,
-            error: error.message,
-            inputParams: inputParams,
-          },
-        },
-      });
-
-      // Update the AI message with error status
-      const updatedAIMessage = new AIMessage({
-        id: toolCallObj.id,
-        content: toolCallObj.content,
-        tool_calls: toolCallObj.tool_calls,
-        additional_kwargs: {
-          ...toolCallObj.additional_kwargs,
-          mindedMetadata: {
-            ...toolCallObj.additional_kwargs?.mindedMetadata,
-            status: 'failed',
-            error: error.message,
-          },
-          update: true,
-        },
-      });
-
-      return {
-        messages: [errorToolMessage, updatedAIMessage],
-        history: createHistoryStep<HistoryStep>(state.history, {
-          type: NodeType.BROWSER_TASK,
-          nodeId: browserTaskNode.name,
-          nodeDisplayName: browserTaskNode.displayName,
-          raw: error,
-          messageIds: [],
-        }),
-      };
-    }
-  };
-
-  graph.addNode(buildBrowserTaskRunNodeName(attachedToNodeName), callback);
-  graph.addEdge(attachedToNodeName as any, buildBrowserTaskRunNodeName(attachedToNodeName) as any);
-};

package/src/platform/models/mindedChatOpenAI.ts

@@ -1,49 +0,0 @@
-import { ChatOpenAI, ChatOpenAIFields } from '@langchain/openai';
-import { getConfig } from '../config';
-
-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;
-}
-
-export interface MindedChatOpenAIFields extends ChatOpenAIFields, BaseParallelChatFields {}
-
-export class MindedChatOpenAI extends ChatOpenAI {
-  private numParallelRequests: number;
-  private logTimings: boolean;
-
-  constructor(fields?: MindedChatOpenAIFields) {
-    const { token, baseUrl } = getConfig();
-    const mindedBaseUrl = `${baseUrl}/sdk/llmGateway/chatOpenAI`;
-    if (!token) {
-      throw new Error('Minded token not found');
-    }
-
-    // Store parallel configuration
-    const numParallelRequests = fields?.numParallelRequests || 1;
-    const logTimings = fields?.logTimings || false;
-
-    super({
-      ...fields,
-      apiKey: token,
-      configuration: {
-        baseURL: mindedBaseUrl,
-        defaultHeaders: {
-          'X-Parallel-Requests': numParallelRequests.toString(),
-          'X-Log-Timings': logTimings.toString(),
-        },
-      },
-    });
-
-    this.numParallelRequests = numParallelRequests;
-    this.logTimings = logTimings;
-  }
-}

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