@minded-ai/mindedjs 1.0.96 → 1.0.97-beta-1236

package/src/playbooks/playbooks.ts

@@ -1,209 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-import * as ejs from 'ejs';
-import * as mindedConnection from '../platform/mindedConnection';
-import { mindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
-import { getConfig } from '../platform/config';
-import { logger } from '../utils/logger';
-import { OutputBlockData } from '@editorjs/editorjs';
-
-export type Playbook = {
-  id: string;
-  name: string;
-  blocks: OutputBlockData[];
-};
-
-/**
- * Convert EditorJS blocks to markdown
- */
-function editorJsToMarkdown(blocks: OutputBlockData[]): string {
-  if (!blocks || blocks.length === 0) {
-    return '';
-  }
-
-  return blocks
-    .map((block) => {
-      try {
-        switch (block.type) {
-          case 'header': {
-            const level = block.data?.level || 1;
-            const headerPrefix = '#'.repeat(level);
-            return `${headerPrefix} ${block.data?.text || ''}`;
-          }
-
-          case 'paragraph': {
-            return block.data?.text || '';
-          }
-
-          case 'list': {
-            const items = block.data?.items || [];
-            const style = block.data?.style || 'unordered';
-            return items
-              .map((item: string, index: number) => {
-                if (style === 'ordered') {
-                  return `${index + 1}. ${item}`;
-                } else {
-                  return `- ${item}`;
-                }
-              })
-              .join('\n');
-          }
-
-          case 'quote': {
-            const text = block.data?.text || '';
-            const caption = block.data?.caption ? `\n*${block.data.caption}*` : '';
-            return `> ${text}${caption}`;
-          }
-
-          case 'code': {
-            const code = block.data?.code || '';
-            return `\`\`\`\n${code}\n\`\`\``;
-          }
-
-          case 'delimiter': {
-            return '---';
-          }
-
-          default: {
-            logger.warn(`Unknown playbook block type: ${block.type}`);
-            return '';
-          }
-        }
-      } catch (error) {
-        logger.error({ message: 'Error converting EditorJS blocks to markdown', error, block });
-        throw error;
-      }
-    })
-    .join('\n\n');
-}
-
-/**
- * Load playbooks from directories or platform
- */
-export async function loadPlaybooks(playbooksDirectories?: string[]): Promise<Playbook[]> {
-  const { env, isDeployed } = getConfig();
-  let playbooks: Playbook[] = [];
-
-  if (['sandbox-staging', 'sandbox'].includes(env) && isDeployed && mindedConnection.isConnected()) {
-    // Load from platform
-    const response = await mindedConnection.awaitEmit<object, { playbooks?: Playbook[]; error?: string }>(
-      mindedConnectionSocketMessageType.GET_PLAYBOOKS,
-      {},
-    );
-
-    if (response?.error) {
-      throw new Error(`Failed to load playbooks from platform: ${response.error}`);
-    }
-
-    playbooks = response?.playbooks || [];
-  } else if (playbooksDirectories) {
-    // Load from directories
-    playbooks = loadPlaybooksFromDirectories(playbooksDirectories);
-  }
-
-  return playbooks;
-}
-
-/**
- * Load playbooks from local directories
- */
-function loadPlaybooksFromDirectories(directories: string[]): Playbook[] {
-  const playbooks: Playbook[] = [];
-
-  for (const directory of directories) {
-    if (!fs.existsSync(directory)) {
-      logger.info(`Playbooks directory does not exist: ${directory}`);
-      continue;
-    }
-
-    const files = getAllYamlFiles(directory);
-
-    for (const file of files) {
-      try {
-        const fileContent = fs.readFileSync(file, 'utf8');
-        const playbook = yaml.load(fileContent) as Playbook;
-
-        if (playbook && playbook.name && playbook.blocks) {
-          playbooks.push(playbook);
-          logger.info(`Loaded playbook: ${playbook.name} from ${file}`);
-        } else {
-          logger.warn(`Invalid playbook structure in ${file}`);
-        }
-      } catch (error) {
-        logger.error(`Failed to load playbook file ${file}: ${error}`);
-      }
-    }
-  }
-
-  return playbooks;
-}
-
-/**
- * Recursively get all YAML files in a directory
- */
-function getAllYamlFiles(dir: string): string[] {
-  const files: string[] = [];
-  const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...getAllYamlFiles(fullPath));
-    } else if (entry.name.endsWith('.yaml') || entry.name.endsWith('.yml')) {
-      files.push(fullPath);
-    }
-  }
-
-  return files;
-}
-
-/**
- * Compile playbooks into a single string with EJS and placeholders
- */
-export function compilePlaybooks(playbooks: Playbook[], params: Record<string, any> = {}): string {
-  if (playbooks.length === 0) {
-    return '';
-  }
-
-  // Combine all playbooks into sections
-  const sections = playbooks.map((playbook) => {
-    const markdownContent = editorJsToMarkdown(playbook.blocks);
-    return `# ${playbook.name}\n${markdownContent}`;
-  });
-
-  const combinedPlaybooks = sections.join('\n\n');
-
-  try {
-    // First, render with EJS
-    let compiledPlaybooks = ejs.render(combinedPlaybooks, params);
-
-    // Then, replace placeholders in {} format
-    compiledPlaybooks = replacePlaceholders(compiledPlaybooks, params);
-
-    return compiledPlaybooks;
-  } catch (error) {
-    logger.error({ message: 'Error compiling playbooks', error });
-    return combinedPlaybooks; // 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);
-  });
-}

package/src/triggers/triggerTypeToDefaultMessage.ts

@@ -1,9 +0,0 @@
-import { BaseMessage, HumanMessage } from '@langchain/core/messages';
-
-const triggerTypeToDefaultMessage: Record<string, Record<string, (triggerBody: any) => Array<BaseMessage>>> = {
-  ['Slack']: {
-    'New Direct Message (Instant)': (triggerBody: any) => [new HumanMessage({ content: triggerBody.text })],
-  },
-};
-
-export default triggerTypeToDefaultMessage;

package/src/types/Agent.types.ts

@@ -1,67 +0,0 @@
-import { AgentEventRequestPayloads, AgentEventResponsePayloads } from '../events/AgentEvents';
-import { LLMConfig } from './LLM.types';
-import { NodeType } from './Flows.types';
-
-export type EmitSignature<Memory, E extends keyof AgentEventRequestPayloads<Memory>> = (
-  event: E,
-  payload: AgentEventRequestPayloads<Memory>[E],
-) => Promise<AgentEventResponsePayloads<Memory>[E][]>;
-
-export type MindedSDKConfig = {
-  flows: string[];
-  llm: LLMConfig;
-  tools: string[];
-  /**
-   * Optional directories containing playbook definition files. If omitted, no playbooks will be loaded.
-   */
-  playbooks?: string[];
-};
-
-/**
- * Parameters for the Agent invoke method
- */
-export interface AgentInvokeParams {
-  /** The payload/data associated with the trigger */
-  triggerBody: any;
-  /** The name/type of the trigger being invoked */
-  triggerName: string;
-  /** Optional session identifier for conversation continuity */
-  sessionId?: string;
-  /** Optional name of the application triggering the agent in case of an app trigger */
-  appName?: string;
-}
-export interface HistoryStep {
-  type: NodeType;
-  step: number;
-  raw: any;
-  nodeId: string;
-  nodeDisplayName: string;
-  messageIds?: string[];
-}
-
-export interface AppTriggerHistoryStep extends HistoryStep {
-  type: NodeType.TRIGGER;
-  appName: string;
-}
-
-export interface TriggerHistoryStep extends HistoryStep {
-  type: NodeType.TRIGGER;
-}
-
-export interface AppActionInvocationHistoryStep extends HistoryStep {
-  type: NodeType.APP_TOOL;
-  appName: string;
-}
-
-export interface CustomActionInvocationHistoryStep extends HistoryStep {
-  type: NodeType.TOOL;
-}
-
-export interface JunctionHistoryStep extends HistoryStep {
-  type: NodeType.JUNCTION;
-}
-
-export enum SessionType {
-  VOICE = 'voice',
-  TEXT = 'text',
-}

package/src/types/Flows.types.ts

@@ -1,184 +0,0 @@
-import { LLMConfig } from './LLM.types';
-export interface Position {
-  x: number;
-  y: number;
-}
-
-export enum NodeType {
-  TRIGGER = 'trigger',
-  JUNCTION = 'junction',
-  TOOL = 'tool',
-  APP_TOOL = 'appTool',
-  PROMPT_NODE = 'promptNode',
-  JUMP_TO_NODE = 'jumpToNode',
-}
-
-export enum EdgeType {
-  LOGICAL_CONDITION = 'logicalCondition',
-  PROMPT_CONDITION = 'promptCondition',
-  STEP_FORWARD = 'stepForward',
-}
-
-export interface BaseNode {
-  name: string;
-  type: NodeType;
-  position?: Position;
-  humanInTheLoop?: boolean;
-  canStayOnNode?: boolean;
-  displayName: string;
-}
-
-export enum TriggerType {
-  APP = 'app',
-  WEBHOOK = 'webhook',
-  MANUAL = 'manual',
-  VOICE = 'voice',
-}
-
-export interface BaseTriggerNode extends BaseNode {
-  type: NodeType.TRIGGER;
-  triggerType: TriggerType;
-}
-
-export interface BaseAppNode {
-  appName: string;
-  appImgSrc: string;
-  account?: string;
-  mockDataInstructions?: string;
-  textSentToModel?: string;
-  parameters?: Record<string, any>;
-}
-
-export interface AppTriggerNode extends BaseTriggerNode, BaseAppNode {
-  triggerType: TriggerType.APP;
-  appTriggerId: string;
-  appTriggerName: string;
-  promptInstructions?: string;
-}
-
-export interface WebhookTriggerNode extends BaseTriggerNode {
-  triggerType: TriggerType.WEBHOOK;
-}
-
-export interface VoiceTriggerNode extends BaseTriggerNode {
-  triggerType: TriggerType.VOICE;
-  /**
-   * Text that will be spoken as the very first message in a voice interaction.
-   */
-  firstMessage: string;
-  /**
-   * Optional ElevenLabs voice ID to be used for TTS.
-   */
-  voiceId?: string;
-}
-
-export interface ManualTriggerNode extends BaseTriggerNode {
-  triggerType: TriggerType.MANUAL;
-}
-
-export interface PromptNode extends BaseNode {
-  type: NodeType.PROMPT_NODE;
-  prompt: string;
-  llmConfig?: LLMConfig;
-}
-
-export interface JumpToNode extends BaseNode {
-  type: NodeType.JUMP_TO_NODE;
-  targetNodeId: string;
-}
-
-export type TriggerNode = AppTriggerNode | WebhookTriggerNode | ManualTriggerNode | VoiceTriggerNode;
-
-export interface JunctionNode extends BaseNode {
-  type: NodeType.JUNCTION;
-}
-
-export interface ToolNode extends BaseNode {
-  type: NodeType.TOOL;
-  toolName: string;
-  prompt: string;
-  appImgSrc?: string;
-}
-
-export interface AppToolNode extends BaseNode, BaseAppNode {
-  type: NodeType.APP_TOOL;
-  prompt: string;
-  appName: string;
-  actionName: string;
-  metadata: AppNodeMetadata;
-  actionKey: string;
-}
-
-export type Node = TriggerNode | JunctionNode | ToolNode | AppToolNode | PromptNode | JumpToNode;
-
-export interface BaseEdge {
-  source: string;
-  target: string;
-  type: EdgeType;
-}
-
-export interface LogicalConditionEdge extends BaseEdge {
-  type: EdgeType.LOGICAL_CONDITION;
-  condition: string;
-}
-
-export interface PromptConditionEdge extends BaseEdge {
-  type: EdgeType.PROMPT_CONDITION;
-  prompt: string;
-}
-
-export interface StepForwardEdge extends BaseEdge {
-  type: EdgeType.STEP_FORWARD;
-}
-
-export type Edge = LogicalConditionEdge | PromptConditionEdge | StepForwardEdge;
-
-export enum AppNodeMetadataType {
-  APP_TOOL = 'appTool',
-}
-export interface NodeMetadata {
-  type: AppNodeMetadataType;
-}
-export interface AppNodeMetadata extends NodeMetadata {
-  type: AppNodeMetadataType.APP_TOOL;
-  schema: ActionInputParam[];
-}
-
-export type ActionInputParam = {
-  name: string;
-  type: ActionInputParamType;
-  description: string;
-  example: string | null;
-  required: boolean;
-  enum?: string[];
-  items?: {
-    type: ActionInputParamType;
-    properties?: ActionInputParam[];
-  };
-};
-
-export enum ActionInputParamType {
-  String = 'string',
-  Number = 'number',
-  Boolean = 'boolean',
-  Array = 'array',
-  Object = 'object',
-  Any = 'any',
-}
-
-export interface Flow {
-  name: string;
-  nodes: Node[];
-  edges: Edge[];
-}
-
-export enum KnownTriggerNames {
-  WEBHOOK = 'webhook',
-  DASHBOARD_MESSAGE = 'dashboard_message',
-  VOICE_MESSAGE = 'voice_message',
-}
-
-export enum internalNodesSuffix {
-  HUMAN_IN_THE_LOOP = '_humanInTheLoop',
-  TOOL_RUN = '_toolRun',
-}

package/src/types/LLM.types.ts

@@ -1,15 +0,0 @@
-import { AzureChatOpenAI, ChatOpenAI } from '@langchain/openai';
-import { MindedChatOpenAI } from '../platform/mindedChatOpenAI';
-
-export type LLMConfig = {
-  name: string,
-  properties: Record<string, any>
-}
-
-export type LLMProvider = 'ChatOpenAI' | 'AzureChatOpenAI' | 'MindedChatOpenAI';
-
-export const LLMProviders: Record<LLMProvider, any> = {
-  ChatOpenAI: ChatOpenAI,
-  AzureChatOpenAI: AzureChatOpenAI,
-  MindedChatOpenAI,
-}

package/src/types/LangGraph.types.ts

@@ -1,48 +0,0 @@
-import { BaseMessage } from '@langchain/core/messages';
-import { Annotation, CompiledStateGraph, StateGraph } from '@langchain/langgraph';
-import { HistoryStep, SessionType } from './Agent.types';
-
-export const createStateAnnotation = <Memory = any>() =>
-  Annotation.Root({
-    messages: Annotation<Array<BaseMessage>>({
-      default: () => [],
-      reducer: (prevMessages, newMessages) => {
-        const res = [...prevMessages];
-        for (const message of newMessages) {
-          if (message.additional_kwargs?.update) {
-            const index = res.findIndex((m) => m.id && m.id === message.id);
-            if (index !== -1) {
-              res[index].content = message.content;
-            }
-          } else {
-            res.push(message);
-          }
-        }
-        return res;
-      },
-    }),
-    memory: Annotation<Memory>({
-      default: () => ({} as Memory),
-      reducer: (a, b) => ({ ...a, ...b }),
-    }),
-    history: Annotation<Array<HistoryStep>>({
-      default: () => [],
-      reducer: (a, b) => a.concat(b),
-    }),
-    sessionId: Annotation<string>(),
-    sessionType: Annotation<SessionType>({
-      default: () => SessionType.TEXT,
-      reducer: (a, b) => b || a,
-    }),
-    overrideStartFromNodeId: Annotation<string | null>({
-      default: () => null,
-      reducer: (a, b) => b,
-    }),
-  });
-
-// Default state annotation with any memory type
-export const stateAnnotation = createStateAnnotation();
-
-export type CompiledGraph = CompiledStateGraph<any, any, string>;
-export type PreCompiledGraph = StateGraph<any, any, string>;
-export type State<Memory = any> = ReturnType<typeof createStateAnnotation<Memory>>['State'];

package/src/types/Platform.types.ts

@@ -1 +0,0 @@
-export type Environment = 'development' | 'sandbox' | 'production' | 'test' | 'sandbox-staging';

package/src/types/Tools.types.ts

@@ -1,31 +0,0 @@
-import { z } from 'zod';
-import { Agent } from '../';
-import { State } from './LangGraph.types';
-
-// Type for state updates that allows partial memory
-type StateUpdate<Memory = any> = Omit<Partial<State<Memory>>, 'memory'> & {
-  memory?: Partial<Memory>;
-};
-
-// Valid return type for new API
-export type ToolReturnType<Memory = any> = ({ state?: StateUpdate<Memory>; result?: any }) | void;
-
-export interface Tool<Input extends z.ZodSchema, Memory = any> {
-  name: string;
-  description: string;
-  input: Input;
-  isGlobal?: boolean;
-  execute: (input: ToolExecuteInput<Input, Memory>) => Promise<ToolReturnType<Memory>>;
-}
-
-export interface ToolExecuteInput<Input extends z.ZodSchema, Memory = any> {
-  input: z.infer<Input>;
-  state: State<Memory>;
-  agent: Agent;
-}
-
-export interface AppActionRunnerInput {
-  appName: string;
-  actionName: string;
-  actionInput: object;
-}

package/src/types/Voice.types.ts

@@ -1,4 +0,0 @@
-export type ElevenLabsContext = {
-  sessionId: string;
-  mindedToken: string;
-}

package/src/utils/extractStateMemoryResponse.ts

@@ -1,16 +0,0 @@
-import { ToolMessage } from '@langchain/core/messages';
-import { logger } from './logger';
-
-const extractToolStateResponse = <State>(toolMessage: ToolMessage): Partial<State> => {
-  try {
-    const parsed = JSON.parse(toolMessage.content as string);
-    if (typeof parsed === 'object' && parsed !== null && 'state' in parsed) {
-      return parsed.state;
-    }
-  } catch (error) {
-    logger.error({ msg: 'Error parsing tool state response', error });
-  }
-  return {};
-};
-
-export default extractToolStateResponse;

package/src/utils/history.ts

@@ -1,9 +0,0 @@
-import { HistoryStep } from '../types/Agent.types';
-
-export const createHistoryStep = <T extends HistoryStep>(currentHistory: HistoryStep[], stepPayload: Omit<T, 'step'>): HistoryStep => {
-  const lastHistoryStep = currentHistory?.[currentHistory?.length - 1];
-  return {
-    ...stepPayload,
-    step: lastHistoryStep?.step + 1 || 0,
-  } as HistoryStep;
-};

package/src/utils/logger.ts

@@ -1,22 +0,0 @@
-import pino from 'pino';
-import dotenv from 'dotenv';
-dotenv.config();
-
-// Create a Pino logger with a custom log format
-export const logger = pino({
-  level: process.env.LOG_LEVEL || 'info',
-  base: null,
-  transport: {
-    target: 'pino-pretty',
-    options: {
-      colorize: true,
-      crlf: true,
-      translateTime: 'SYS:standard',
-    },
-  },
-  formatters: {
-    level(label) {
-      return { level: label };
-    },
-  },
-});

package/src/utils/wait.ts

@@ -1 +0,0 @@
-export const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));