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

package/src/internalTools/documentExtraction/types.ts

@@ -1,59 +0,0 @@
-import { ZodType as ZodSchema, ZodTypeAny } from 'zod';
-
-export interface DocumentProcessorConfig {
-  llamaCloudApiKey?: string;
-  useBase64?: boolean;
-  maxImageWidth?: number;
-  imageQuality?: number;
-}
-export interface DocumentExtractionOptions {
-  documentPath?: string;
-  documentContent?: Buffer | string;
-  documentUrl?: string;
-  schema?: ZodSchema<any> | ZodTypeAny;
-  llmConfig?: {
-    model?: string;
-    temperature?: number;
-  };
-  systemPrompt?: string;
-}
-export interface DocumentProcessingResult<T = any> {
-  data: T;
-  metadata: {
-    fileSize?: number;
-    fileType: string;
-    processingTime: number;
-    contentLength: number;
-  };
-}
-export const SUPPORTED_DOCUMENT_TYPES = [
-  // Images
-  '.jpg',
-  '.jpeg',
-  '.png',
-  '.gif',
-  '.bmp',
-  '.webp',
-  '.tiff',
-  // Documents
-  '.pdf',
-  '.doc',
-  '.docx',
-  '.txt',
-  '.rtf',
-  '.odt',
-  // Spreadsheets
-  '.xls',
-  '.xlsx',
-  '.csv',
-  '.ods',
-  // Presentations
-  '.ppt',
-  '.pptx',
-  '.odp',
-  // Other formats
-  '.html',
-  '.htm',
-  '.md',
-  '.xml',
-];

package/src/internalTools/libraryActionRunnerTool.ts

@@ -1,63 +0,0 @@
-import { Tool, ToolExecuteInput } from '../types/Tools.types';
-import { tools } from '../toolsLibrary';
-import { logger } from '../utils/logger';
-
-const libraryActionRunnerToolCreator = (actionKey: string, nodeTitle: string): Tool<any, any> => {
-  // Find the corresponding library tool by key name (e.g., "parseDocument")
-  const libraryTool = (tools as any)[actionKey];
-
-  if (!libraryTool?.default) {
-    throw new Error(`Library tool '${actionKey}' not found in toolsLibrary`);
-  }
-
-  if (!libraryTool.schema) {
-    throw new Error(`Schema not found for library tool '${actionKey}'. Make sure the tool exports a 'schema' object.`);
-  }
-
-  const zodSchema = libraryTool.schema;
-
-  // Create a description using the library tool's own description
-  const description = libraryTool.default.description || `Run ${nodeTitle} action from Minded Tools library.`;
-
-  const tool = {
-    name: nodeTitle,
-    description,
-    input: zodSchema,
-    execute: async ({ input, state, agent }: ToolExecuteInput<typeof zodSchema>) => {
-      try {
-        // Find the corresponding library tool
-        const libraryTool = Object.values(tools).find((toolModule) => toolModule.default && toolModule.default.name === actionKey);
-
-        if (!libraryTool?.default) {
-          throw new Error(`Library tool '${actionKey}' not found in toolsLibrary`);
-        }
-
-        logger.debug({
-          msg: `[Tool] Executing library tool`,
-          toolName: actionKey,
-          nodeTitle,
-        });
-
-        // Execute the library tool directly
-        const result = await libraryTool.default.execute({ input, state, agent });
-
-        return {
-          state: result?.state,
-          result: result?.result,
-        };
-      } catch (error) {
-        logger.error({
-          msg: `[Tool] Error executing library tool`,
-          error,
-          toolName: actionKey,
-          nodeTitle,
-        });
-        throw error;
-      }
-    },
-  };
-
-  return tool;
-};
-
-export default libraryActionRunnerToolCreator;

package/src/internalTools/retell.ts

@@ -1,28 +0,0 @@
-import * as mindedConnection from '../platform/mindedConnection';
-import { mindedConnectionSocketMessageType, TimerResetResponse, RetellGetCallResponse } from '../platform/mindedConnectionTypes';
-
-export async function retellCall({
-  sessionId,
-  callName,
-  callAgentId,
-  vars = {},
-}: {
-  sessionId: string;
-  callName: string;
-  callAgentId: string;
-  vars?: Record<string, any>;
-}): Promise<TimerResetResponse> {
-  return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.RETELL_CALL, {
-    sessionId,
-    callName,
-    callAgentId,
-    vars,
-  });
-}
-
-export async function retellGetCall({ sessionId, callId }: { sessionId: string; callId: string }): Promise<RetellGetCallResponse> {
-  return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.RETELL_GET_CALL, {
-    sessionId,
-    callId,
-  });
-}

package/src/internalTools/sendPlaceholderMessage.ts

@@ -1,27 +0,0 @@
-import * as mindedConnection from '../platform/mindedConnection';
-import { mindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
-
-/**
- * Send a placeholder message to the dashboard voice session.
- * This is typically used for voice sessions to provide immediate feedback to users.
- * 
- * @param params - The parameters for sending the placeholder message
- * @param params.sessionId - The session ID of the voice session
- * @param params.message - The placeholder message to send
- * @throws {Error} When the Minded connection is not established
- */
-export async function sendPlaceholderMessage(params: { sessionId: string; message: string }): Promise<void> {
-  const { sessionId, message } = params;
-
-  if (!mindedConnection.isConnected()) {
-    throw new Error('Minded connection is not established when trying to send placeholder message');
-  }
-
-  const connection = mindedConnection;
-  connection.emit(mindedConnectionSocketMessageType.DASHBOARD_VOICE_PLACEHOLDER_MESSAGES, {
-    sessionId,
-    message,
-    timestamp: Date.now(),
-    type: mindedConnectionSocketMessageType.DASHBOARD_VOICE_PLACEHOLDER_MESSAGES,
-  });
-} 

package/src/internalTools/timer.ts

@@ -1,137 +0,0 @@
-import * as mindedConnection from '../platform/mindedConnection';
-import { mindedConnectionSocketMessageType, TimerResetResponse, TimerCancelResponse } from '../platform/mindedConnectionTypes';
-
-// Store timer handlers by timer name
-export const timerHandlers = new Map<string, Array<{
-  handler: (params: { sessionId: string; payload: Record<string, any> }) => void | Promise<void>;
-}>>();
-
-/**
- * Reset or set a timer for a specific session.
- * When the timer expires, all registered timer handlers will be called.
- * 
- * @param params - The timer configuration
- * @param params.sessionId - The session ID to associate the timer with
- * @param params.seconds - Number of seconds until the timer expires
- * @param params.timerName - Unique name for this timer (used for cancellation and identification)
- * @param params.eventArgs - Additional data to pass to the timer handler when it triggers
- * @returns Promise resolving to timer reset response
- * @throws {Error} When the Minded connection is not established
- * 
- * @example
- * ```typescript
- * import { resetTimer } from '@minded-ai/mindedjs';
- * 
- * // Set a timer to follow up in 10 seconds
- * await resetTimer({
- *   sessionId: 'session-123',
- *   seconds: 10,
- *   timerName: 'followup',
- *   payload: {
- *     message: 'Are you still there?'
- *   }
- * });
- * ```
- */
-export async function resetTimer({
-  sessionId,
-  seconds,
-  timerName,
-  payload = {}
-}: {
-  sessionId: string;
-  seconds: number;
-  timerName: string;
-  payload?: Record<string, any>;
-}): Promise<TimerResetResponse> {
-  return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.TIMER_RESET, {
-    sessionId,
-    seconds,
-    timerName,
-    eventArgs: payload,
-  });
-}
-
-/**
- * Cancel an existing timer for a specific session.
- * 
- * @param sessionId - The session ID the timer is associated with
- * @param timerName - The name of the timer to cancel
- * @returns Promise resolving to timer cancel response
- * @throws {Error} When the Minded connection is not established
- * 
- * @example
- * ```typescript
- * import { cancelTimer } from '@minded-ai/mindedjs';
- * 
- * // Cancel a previously set timer
- * await cancelTimer('session-123', 'followup');
- * ```
- */
-export async function cancelTimer(sessionId: string, timerName: string): Promise<TimerCancelResponse> {
-  if (!mindedConnection.isConnected()) {
-    throw new Error('Minded connection is not established when trying to cancel timer');
-  }
-  return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.TIMER_CANCEL, {
-    sessionId,
-    timerName,
-  });
-}
-
-/**
- * Register a handler for timer trigger events for a specific timer name.
- * The handler will be called when the specified timer expires for any session.
- * 
- * @param params - The configuration for the timer handler
- * @param params.timerName - The name of the timer to handle
- * @param params.handler - Function to call when the timer triggers
- * 
- * @example
- * ```typescript
- * import { onTimer } from '@minded-ai/mindedjs';
- * 
- * // Register a handler for the 'followup' timer
- * onTimer({
- *   timerName: 'followup',
- *   handler: async ({ sessionId, payload }) => {
- *     console.log(`Followup timer triggered for session ${sessionId}`);
- *     
- *     // Handle the followup timer
- *     await agent.invoke({
- *       triggerName: 'timerFollowup',
- *       triggerBody: { message: payload.message },
- *       sessionId
- *     });
- *   }
- * });
- * ```
- */
-export function onTimer({
-  timerName,
-  handler
-}: {
-  timerName: string;
-  handler: (params: { sessionId: string; payload: Record<string, any> }) => void | Promise<void>;
-}): void {
-  // Initialize handlers array for this timer name if it doesn't exist
-  if (!timerHandlers.has(timerName)) {
-    timerHandlers.set(timerName, []);
-  }
-
-  // Add the handler to the array for this timer name
-  const handlers = timerHandlers.get(timerName)!;
-  handlers.push({ handler });
-}
-
-mindedConnection.on(mindedConnectionSocketMessageType.TIMER_TRIGGER, async (timerTriggerMessage) => {
-  // Get handlers for the specific timer name
-  const handlers = timerHandlers.get(timerTriggerMessage.timerName) || [];
-
-  // Call all handlers registered for this timer name
-  for (const { handler } of handlers) {
-    await handler({
-      sessionId: timerTriggerMessage.sessionId,
-      payload: timerTriggerMessage.eventArgs,
-    });
-  }
-});

package/src/llm/createLlmInstance.ts

@@ -1,33 +0,0 @@
-import { LLMConfig, LLMProviders, LLMProvider } from '../types/LLM.types';
-import { createParallelWrapper, BaseParallelChatFields } from '../platform/models/parallelWrapper';
-
-export const createLlmInstance = (llmConfig: LLMConfig) => {
-  const { name, properties } = llmConfig;
-  const LLMClass = LLMProviders[name as LLMProvider];
-  if (!LLMClass) {
-    throw new Error(`Unsupported LLM provider: ${name}`);
-  }
-
-  // Create the base LLM instance
-  const llmInstance = new LLMClass(properties);
-
-  // Check if parallel configuration is present
-  const hasParallelConfig = properties.numParallelRequests && properties.numParallelRequests > 1;
-
-  // For MindedChatOpenAI, parallel functionality is handled on the backend
-  if (name === 'MindedChatOpenAI') {
-    return llmInstance;
-  }
-
-  // For other LLM providers, apply client-side parallel wrapper if configured
-  if (hasParallelConfig) {
-    const parallelOptions: BaseParallelChatFields = {
-      numParallelRequests: properties.numParallelRequests,
-      logTimings: properties.logTimings,
-    };
-
-    return createParallelWrapper(llmInstance, parallelOptions);
-  }
-
-  return llmInstance;
-};

package/src/nodes/addAppToolNode.ts

@@ -1,106 +0,0 @@
-import { AppToolNode, NodeType } from '../types/Flows.types';
-import { tool as langchainTool } from '@langchain/core/tools';
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { SystemMessage } from '@langchain/core/messages';
-import { RunnableLike } from '@langchain/core/runnables';
-import { z } from 'zod';
-import { LLMProviders } from '../types/LLM.types';
-import { AppActionInvocationHistoryStep } from '../types/Agent.types';
-import { Agent } from '../agent';
-import { logger } from '../utils/logger';
-import { compilePlaybooks } from '../playbooks/playbooks';
-import { createHistoryStep } from '../utils/history';
-import { Tool } from '../types/Tools.types';
-
-export const addAppToolNode = async ({
-  graph,
-  node,
-  llm,
-  agent,
-  tools,
-}: {
-  graph: PreCompiledGraph;
-  node: AppToolNode;
-  llm: (typeof LLMProviders)[keyof typeof LLMProviders];
-  agent: Agent;
-  tools: Tool<any, any>[];
-}) => {
-  const cleanedParameters = Object.fromEntries(Object.entries(node.parameters || {}).filter(([, value]) => value !== ''));
-
-  // Find the tool from the tools array by name
-  const appRunnerTool = tools.find((tool) => tool.name === node.displayName);
-
-  if (!appRunnerTool) {
-    throw new Error(`Tool not found for node: ${node.displayName}`);
-  }
-
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.debug({ msg: `[Node] Executing tool node`, node: appRunnerTool.name });
-
-    const executeWrapper = async (input: z.infer<typeof appRunnerTool.input>) => {
-      try {
-        const response = await appRunnerTool.execute({ input, state, agent });
-        return response || {};
-      } catch (error) {
-        logger.error({ msg: `[Node] Error executing tool`, error, node: node.name });
-        throw error;
-      }
-    };
-    const tool = langchainTool(executeWrapper, {
-      name: appRunnerTool.name,
-      description: appRunnerTool.description,
-      schema: appRunnerTool.input,
-    });
-    // Get compiled playbooks with proper parameters
-    const playbookParams = {
-      ...state.memory, // Spread memory fields at the top level
-      currentTime: new Date().toISOString(),
-    };
-    const compiledPlaybooks = compilePlaybooks(agent.playbooks, playbookParams) || '';
-
-    const message = `${compiledPlaybooks ? compiledPlaybooks + '\n\n' : ''}
-    Additional context:
-    previous messages are available for context.
-    Your goal is execute the tool with the correct parameters, some of them already chosen by the user and the rest should be generated.
-    You have 4 things to base your parameters on:
-    - Previous messages
-    - Parameters manually configured by the user (if any)
-    - User instructions for choosing tool parameters that are not set by the user (if any)
-    - Workflow memory
-    Parameters manually configured by the user are:
-    ${JSON.stringify(cleanedParameters)}
-    User instructions for choosing tool parameters are:
-        ${node.prompt ? `${node.prompt}` : 'no instructions set by the user'}
-        Workflow memory is:
-        ${JSON.stringify(state.memory)}
-        `;
-    const AIToolCallMessage = await llm
-      .bindTools([tool], {
-        tool_choice: tool.name,
-      })
-      .invoke([...state.messages, new SystemMessage(message)]);
-    AIToolCallMessage.tool_calls[0].args = {
-      ...AIToolCallMessage.tool_calls[0].args,
-      ...cleanedParameters, //user set parameters have priority over ai generated parameters
-    };
-    const toolCallMessage = await tool.invoke(AIToolCallMessage.tool_calls[0]);
-    AIToolCallMessage.additional_kwargs = {
-      mindedMetadata: {
-        nodeType: NodeType.APP_TOOL,
-      },
-    };
-    return {
-      goto: null,
-      messages: [AIToolCallMessage, toolCallMessage],
-      history: createHistoryStep<AppActionInvocationHistoryStep>(state.history, {
-        type: NodeType.APP_TOOL,
-        nodeId: node.name,
-        nodeDisplayName: node.displayName!,
-        raw: AIToolCallMessage.tool_calls[0],
-        appName: node.appName,
-        messageIds: [AIToolCallMessage.id!],
-      }),
-    };
-  };
-  graph.addNode(node.name, callback);
-};

package/src/nodes/addBrowserTaskNode.ts

@@ -1,231 +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,
-            nodeDisplayName: node.displayName,
-            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,
-            nodeDisplayName: node.displayName,
-            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);
-};