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

package/src/nodes/addPromptNode.ts

@@ -1,117 +0,0 @@
-import { RunnableLike } from '@langchain/core/runnables';
-import { NodeType, PromptNode } from '../types/Flows.types';
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { z } from 'zod';
-import { BaseLanguageModel } from '@langchain/core/language_models/base';
-import { SystemMessage, AIMessage, ToolMessage } from '@langchain/core/messages';
-import { Tool } from '../types/Tools.types';
-import { tool as langchainTool } from '@langchain/core/tools';
-import { AgentEventRequestPayloads, AgentEvents } from '../events/AgentEvents';
-import { EmitSignature, HistoryStep } from '../types/Agent.types';
-import { createLlmInstance } from '../llm/createLlmInstance';
-import extractToolStateResponse from '../utils/extractStateMemoryResponse';
-import { Agent } from '../agent';
-import { logger } from '../utils/logger';
-import { compilePlaybooks } from '../playbooks/playbooks';
-import { createHistoryStep } from '../utils/history';
-
-type AddPromptNodeParams = {
-  graph: PreCompiledGraph;
-  node: PromptNode;
-  llm: BaseLanguageModel;
-  tools: Tool<any, any>[];
-  emit: EmitSignature<any, keyof AgentEventRequestPayloads<any>>;
-  agent: Agent;
-};
-
-export const addPromptNode = async ({ graph, node, llm, tools, emit, agent }: AddPromptNodeParams) => {
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing prompt node ${node.displayName}`);
-    const llmToUse = node.llmConfig ? createLlmInstance(node.llmConfig) : llm;
-
-    const globalTools = tools
-      .filter((tool) => tool.isGlobal)
-      .map((tool) =>
-        langchainTool((input: z.infer<typeof tool.input>) => tool.execute({ input, state, agent }), {
-          name: tool.name,
-          description: tool.description,
-          schema: tool.input,
-        }),
-      );
-
-    // Get compiled playbooks with proper parameters
-    const playbookParams = {
-      ...state.memory, // Spread memory fields at the top level
-    };
-    const compiledPlaybooks = compilePlaybooks(agent.playbooks, playbookParams) || '';
-
-    const message = `
-    ${node.prompt ? `# Task instructions:\n${node.prompt}\n\n` : ''}
-    ${state.memory ? `# Task context:\n${JSON.stringify(state.memory)}\n\n` : ''}
-    ${compiledPlaybooks ? `# General guidelines:\n${compiledPlaybooks}\n\n` : ''}
-    `;
-
-    const result: AIMessage = await llmToUse.bindTools(globalTools).invoke([...state.messages, new SystemMessage(message)]);
-
-    // Check if the result contains tool calls
-    if (result.tool_calls && result.tool_calls.length > 0) {
-      // Execute the tools
-      const toolResults = [];
-      let stateUpdates = {};
-
-      for (const toolCall of result.tool_calls) {
-        const matchedTool = globalTools.find((t) => t.name === toolCall.name);
-        logger.info({ msg: `Model called tool ${matchedTool?.name}` });
-        if (matchedTool) {
-          try {
-            // Invoke the LangChain tool directly
-            const toolResult = await matchedTool.invoke(toolCall);
-            const toolStateUpdate = extractToolStateResponse(toolResult);
-            // Properly merge memory and other state updates
-            stateUpdates = {
-              ...stateUpdates,
-              ...toolStateUpdate,
-              memory: { ...(stateUpdates as any).memory, ...(toolStateUpdate as any).memory },
-            };
-            toolResults.push(toolResult);
-          } catch (error) {
-            logger.error({ msg: `Error executing tool ${toolCall.name}:`, error });
-            const errorMessage = new ToolMessage({
-              content: JSON.stringify({ error: error instanceof Error ? error.message : String(error) }),
-              tool_call_id: toolCall.id!,
-            });
-            toolResults.push(errorMessage);
-          }
-        } else {
-          logger.error({ msg: `Model tried to call tool ${toolCall.name} but it was not found` });
-        }
-      }
-
-      // Return the tool call message and tool results with state updates spread at top level
-      return {
-        ...stateUpdates,
-        messages: [result, ...toolResults],
-      };
-    }
-
-    if (result.getType() === 'ai') {
-      await emit(AgentEvents.AI_MESSAGE, {
-        message: result.content as string,
-        state,
-      });
-      console.log('AI Message', result.content);
-    }
-
-    return {
-      history: createHistoryStep<HistoryStep>(state.history, {
-        type: NodeType.PROMPT_NODE,
-        nodeId: node.name,
-        nodeDisplayName: node.displayName,
-        raw: result.content,
-        messageIds: [result.id!],
-      }),
-      messages: [result],
-    };
-  };
-  graph.addNode(node.name, callback);
-};

package/src/nodes/addToolNode.ts

@@ -1,71 +0,0 @@
-import { NodeType, ToolNode } from '../types/Flows.types';
-import { Tool } from '../types/Tools.types';
-import { tool as langchainTool } from '@langchain/core/tools';
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { AIMessage, SystemMessage } from '@langchain/core/messages';
-import { RunnableLike } from '@langchain/core/runnables';
-import { LLMProviders } from '../types/LLM.types';
-import { logger } from '../utils/logger';
-import { Agent } from '../agent';
-import { compilePlaybooks } from '../playbooks/playbooks';
-import { createHistoryStep } from '../utils/history';
-import { HistoryStep } from '../types/Agent.types';
-
-export const addToolNode = async ({
-  graph,
-  node,
-  tools,
-  llm,
-  agent,
-}: {
-  graph: PreCompiledGraph;
-  node: ToolNode;
-  tools: Tool<any, any>[];
-  llm: (typeof LLMProviders)[keyof typeof LLMProviders];
-  agent: Agent;
-}) => {
-  const toolNode = node as ToolNode;
-  const matchedTool = tools.find((tool) => tool.name === toolNode.toolName);
-  if (!matchedTool) {
-    throw new Error(`Tool not found: ${toolNode.toolName} in node ${node.name}`);
-  }
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing tool node ${toolNode.displayName}`);
-
-    const tool = langchainTool(() => {}, {
-      name: matchedTool.name,
-      description: matchedTool.description,
-      schema: matchedTool.input,
-    });
-
-    // Get compiled playbooks with proper parameters
-    const playbookParams = {
-      ...state.memory, // Spread memory fields at the top level
-      state, // Keep the full state for backward compatibility
-      currentTime: new Date().toISOString(),
-      // Add any other common parameters that playbooks might need
-    };
-    const compiledPlaybooks = compilePlaybooks(agent.playbooks, playbookParams) || '';
-
-    const prompt = `${compiledPlaybooks ? compiledPlaybooks + '\n\n' : ''}
-        Additional context:
-          workflow memory: ${JSON.stringify(state.memory)}
-        `;
-    const AIToolCallMessage: AIMessage = await llm
-      .bindTools([tool], {
-        tool_choice: tool.name,
-      })
-      .invoke([...state.messages, new SystemMessage(prompt)]);
-    return {
-      messages: [AIToolCallMessage],
-      history: createHistoryStep<HistoryStep>(state.history, {
-        type: NodeType.TOOL,
-        nodeId: node.name,
-        nodeDisplayName: node.displayName,
-        raw: AIToolCallMessage.tool_calls?.[0] || '',
-        messageIds: [AIToolCallMessage.id!],
-      }),
-    };
-  };
-  graph.addNode(node.name, callback);
-};

package/src/nodes/addToolRunNode.ts

@@ -1,74 +0,0 @@
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { RunnableLike } from '@langchain/core/runnables';
-import { Tool } from '../types/Tools.types';
-import { LLMProviders } from '../types/LLM.types';
-import { internalNodesSuffix, NodeType, ToolNode } from '../types/Flows.types';
-import { tool as langchainTool } from '@langchain/core/tools';
-import { ToolMessage } from '@langchain/core/messages';
-import { z } from 'zod';
-import extractToolStateResponse from '../utils/extractStateMemoryResponse';
-import { Agent } from '../agent';
-import { logger } from '../utils/logger';
-import { createHistoryStep } from '../utils/history';
-import { HistoryStep } from '../types/Agent.types';
-
-type AddToolRunNodeParams = {
-  graph: PreCompiledGraph;
-  tools: Tool<any, any>[];
-  llm: (typeof LLMProviders)[keyof typeof LLMProviders];
-  toolNode: ToolNode;
-  attachedToNodeName: string;
-  agent: Agent;
-};
-
-export const buildToolRunNodeName = (nodeName: string) => `${nodeName}${internalNodesSuffix.TOOL_RUN}`;
-
-export const addToolRunNode = async ({ graph, tools, toolNode, attachedToNodeName, agent }: AddToolRunNodeParams) => {
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    const matchedTool = tools.find((tool) => tool.name === toolNode.toolName);
-    if (!matchedTool) {
-      throw new Error(`Tool not found: ${toolNode.toolName}`);
-    }
-
-    const executeWrapper = async (input: z.infer<typeof matchedTool.input>) => {
-      try {
-        const response = await matchedTool.execute({ input, state, agent });
-        return response || {};
-      } catch (error) {
-        logger.error({ msg: 'Error executing tool', error });
-        throw error;
-      }
-    };
-    const tool = langchainTool(executeWrapper, {
-      name: matchedTool.name,
-      description: matchedTool.description,
-      schema: matchedTool.input,
-    });
-
-    const toolCallObj = state.messages[state.messages.length - 1] as any;
-    if (!toolCallObj.tool_calls) {
-      throw new Error('Tool call not found');
-    }
-    const toolCallMessage = await tool.invoke(toolCallObj.tool_calls[0]);
-    const toolStateUpdate = extractToolStateResponse(toolCallMessage as ToolMessage);
-
-    // Push the toolCallMessage into the messages array from toolStateUpdate
-    const updatedMessages = [toolCallMessage, ...((toolStateUpdate as any).messages || [])];
-
-    // Return the full state update from the tool with the updated messages
-    return {
-      ...toolStateUpdate,
-      messages: updatedMessages,
-      history: createHistoryStep<HistoryStep>(state.history, {
-        type: NodeType.TOOL,
-        nodeId: toolNode.name,
-        nodeDisplayName: toolNode.displayName,
-        raw: toolCallMessage,
-        messageIds: [],
-      }),
-    };
-  };
-
-  graph.addNode(buildToolRunNodeName(attachedToNodeName), callback);
-  graph.addEdge(attachedToNodeName as any, buildToolRunNodeName(attachedToNodeName) as any);
-};

package/src/nodes/addTriggerNode.ts

@@ -1,26 +0,0 @@
-import { RunnableLike } from '@langchain/core/runnables';
-import { NodeType, TriggerNode, TriggerType } from '../types/Flows.types';
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { logger } from '../utils/logger';
-import { HistoryStep } from '../types/Agent.types';
-import { createHistoryStep } from '../utils/history';
-
-export const addTriggerNode = async ({ graph, node }: { graph: PreCompiledGraph; node: TriggerNode }) => {
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing trigger node ${node.displayName}`);
-    if (node.triggerType === TriggerType.MANUAL) {
-      return {
-        history: createHistoryStep<HistoryStep>(state.history, {
-          type: NodeType.TRIGGER,
-          nodeId: node.name,
-          nodeDisplayName: node.displayName,
-          raw: '',
-          messageIds: [],
-        }),
-      };
-    }
-    return {};
-  };
-
-  graph.addNode(node.name, callback);
-};

package/src/nodes/nodeFactory.ts

@@ -1,53 +0,0 @@
-import { Node, NodeType } from '../types/Flows.types';
-import { PreCompiledGraph } from '../types/LangGraph.types';
-import { Tool } from '../types/Tools.types';
-import { addToolNode } from './addToolNode';
-import { addPromptNode } from './addPromptNode';
-import { AgentEventRequestPayloads } from '../events/AgentEvents';
-import { EmitSignature } from '../types/Agent.types';
-import { addAppToolNode } from './addAppToolNode';
-import { addTriggerNode } from './addTriggerNode';
-import { LLMProviders } from '../types/LLM.types';
-import { Agent } from '../agent';
-import { addJumpToNode } from './addJumpToNode';
-import { addJunctionNode } from './addJunctionNode';
-
-export const nodeFactory = ({
-  graph,
-  node,
-  tools,
-  llm,
-  emit,
-  agent,
-}: {
-  graph: PreCompiledGraph;
-  node: Node;
-  tools: Tool<any, any>[];
-  llm: (typeof LLMProviders)[keyof typeof LLMProviders];
-  emit: EmitSignature<any, keyof AgentEventRequestPayloads<any>>;
-  agent: Agent;
-}) => {
-  const nodeType = node.type;
-  switch (nodeType) {
-    case NodeType.TRIGGER:
-      addTriggerNode({ graph, node });
-      break;
-    case NodeType.TOOL:
-      addToolNode({ graph, node, tools, llm, agent });
-      break;
-    case NodeType.JUNCTION:
-      addJunctionNode({ graph, node });
-      break;
-    case NodeType.APP_TOOL:
-      addAppToolNode({ graph, node, llm, agent });
-      break;
-    case NodeType.PROMPT_NODE:
-      addPromptNode({ graph, node, tools, llm, emit, agent });
-      break;
-    case NodeType.JUMP_TO_NODE:
-      addJumpToNode({ graph, node });
-      break;
-    default:
-      throw new Error(`Unsupported node type: ${nodeType}`);
-  }
-};

package/src/platform/config.ts

@@ -1,77 +0,0 @@
-import { resolve } from 'path';
-import { config } from 'dotenv';
-import { Environment } from '../types/Platform.types';
-const path = resolve(__dirname, '../../.env');
-config({ path });
-
-type MindedConfig = {
-  baseUrl: string;
-  env: Environment;
-  token: string | null;
-  runLocally: boolean;
-  isDeployed: boolean;
-  dashboardConnected: boolean;
-  elevenLabsKey: string | null;
-  elevenLabsAgentId: string | null;
-};
-
-export const getConfig = (): MindedConfig => {
-  const environment = (process.env.NODE_ENV as Environment) || 'sandbox';
-  switch (environment) {
-    case 'test':
-      return {
-        baseUrl: 'http://localhost:8888',
-        env: 'test',
-        token: process.env.MINDED_CONNECTION_TOKEN || '',
-        runLocally: process.env.RUN_LOCALLY !== 'false',
-        isDeployed: process.env.IS_DEPLOYED_AGENT === 'true',
-        dashboardConnected: false,
-        elevenLabsKey: process.env.ELEVEN_LABS_API_KEY || null,
-        elevenLabsAgentId: process.env.ELEVEN_LABS_AGENT_ID || null,
-      };
-    case 'development':
-      return {
-        baseUrl: 'http://localhost:8888',
-        env: 'development',
-        token: process.env.MINDED_CONNECTION_TOKEN || '',
-        runLocally: process.env.RUN_LOCALLY === 'true',
-        isDeployed: process.env.IS_DEPLOYED_AGENT === 'true',
-        dashboardConnected: true,
-        elevenLabsKey: process.env.ELEVEN_LABS_API_KEY || null,
-        elevenLabsAgentId: process.env.ELEVEN_LABS_AGENT_ID || 'Iyr6DCOj80AdvVEVHSGt',
-      };
-    case 'sandbox-staging':
-      return {
-        baseUrl: 'https://dashboard-api.dev.minded.com',
-        env: 'sandbox-staging',
-        token: process.env.MINDED_CONNECTION_TOKEN || '',
-        runLocally: false,
-        isDeployed: process.env.IS_DEPLOYED_AGENT === 'true',
-        elevenLabsKey: process.env.ELEVEN_LABS_API_KEY || null,
-        dashboardConnected: true,
-        elevenLabsAgentId: process.env.ELEVEN_LABS_AGENT_ID || 'agent_01jye194psezr909nwec27m2t9',
-      };
-    case 'sandbox':
-      return {
-        baseUrl: 'https://dashboard-api.minded.com',
-        env: 'sandbox',
-        token: process.env.MINDED_CONNECTION_TOKEN || '',
-        runLocally: false,
-        isDeployed: process.env.IS_DEPLOYED_AGENT === 'true',
-        elevenLabsKey: process.env.ELEVEN_LABS_API_KEY || null,
-        dashboardConnected: true,
-        elevenLabsAgentId: process.env.ELEVEN_LABS_AGENT_ID || 'agent_01jye194psezr909nwec27m2t9',
-      };
-    case 'production':
-      return {
-        baseUrl: 'https://api.minded.com',
-        env: 'production',
-        token: process.env.MINDED_CONNECTION_TOKEN || '',
-        runLocally: false,
-        isDeployed: process.env.IS_DEPLOYED_AGENT === 'true',
-        elevenLabsKey: process.env.ELEVEN_LABS_API_KEY || null,
-        dashboardConnected: false,
-        elevenLabsAgentId: process.env.ELEVEN_LABS_AGENT_ID || 'agent_01jye1ajkaf17axpcxg220qwcm',
-      };
-  }
-};

package/src/platform/mindedChatOpenAI.ts

@@ -1,19 +0,0 @@
-import { ChatOpenAI, ChatOpenAIFields } from "@langchain/openai";
-import { getConfig } from "./config";
-
-export class MindedChatOpenAI extends ChatOpenAI {
-  constructor(fields?: ChatOpenAIFields) {
-    const { token, baseUrl } = getConfig();
-    const mindedBaseUrl = `${baseUrl}/sdk/llmGateway/chatOpenAI`;
-    if (!token) {
-      throw new Error('Minded token not found');
-    }
-    super({
-      ...fields,
-      apiKey: token,
-      configuration: {
-        baseURL: mindedBaseUrl,
-      },
-    });
-  }
-}

package/src/platform/mindedCheckpointSaver.ts

@@ -1,146 +0,0 @@
-import {
-  BaseCheckpointSaver,
-  CheckpointTuple,
-  Checkpoint,
-  CheckpointMetadata,
-  ChannelVersions,
-  PendingWrite,
-  CheckpointListOptions,
-  CheckpointPendingWrite,
-} from '@langchain/langgraph-checkpoint';
-import type { RunnableConfig } from '@langchain/core/runnables';
-import * as mindedConnection from './mindedConnection';
-import {
-  mindedConnectionSocketMessageType,
-  OnCheckpointGetTuple,
-  OnCheckpointGetTupleResponse,
-  OnCheckpointList,
-  OnCheckpointListResponse,
-  OnCheckpointPut,
-  OnCheckpointPutResponse,
-  OnCheckpointPutWrites,
-} from './mindedConnectionTypes';
-import { logger } from '../utils/logger';
-
-export class MindedCheckpointSaver extends BaseCheckpointSaver<number> {
-  constructor() {
-    super();
-  }
-
-  async getTuple(config: RunnableConfig<Record<string, any>>): Promise<CheckpointTuple | undefined> {
-    const response = await mindedConnection.awaitEmit<OnCheckpointGetTuple, OnCheckpointGetTupleResponse>(
-      mindedConnectionSocketMessageType.CHECKPOINT_GET_TUPLE,
-      {
-        type: mindedConnectionSocketMessageType.CHECKPOINT_GET_TUPLE,
-        config,
-      },
-    );
-
-    if (!response.tuple) {
-      return undefined;
-    }
-
-    const tuple = response.tuple;
-
-    // Re-serialize and deserialize checkpoint to restore class information
-    const [checkpointType, serializedCheckpoint] = this.serde.dumpsTyped(tuple.checkpoint);
-    const checkpoint = (await this.serde.loadsTyped(checkpointType, serializedCheckpoint)) as Checkpoint;
-
-    // Re-serialize and deserialize metadata to restore class information
-    const metadata = tuple.metadata
-      ? (() => {
-        const [metadataType, serializedMetadata] = this.serde.dumpsTyped(tuple.metadata);
-        return this.serde.loadsTyped(metadataType, serializedMetadata) as CheckpointMetadata;
-      })()
-      : undefined;
-
-    // Re-serialize and deserialize pending writes to restore class information
-    const pendingWrites: CheckpointPendingWrite[] = tuple.pendingWrites
-      ? await Promise.all(
-        tuple.pendingWrites.map(async (write) => {
-          const [taskId, channel, value] = write;
-          const [valueType, serializedValue] = this.serde.dumpsTyped(value);
-          const deserializedValue = await this.serde.loadsTyped(valueType, serializedValue);
-          return [taskId, channel, deserializedValue] as CheckpointPendingWrite;
-        }),
-      )
-      : [];
-
-    return {
-      config: tuple.config,
-      checkpoint,
-      metadata: await metadata,
-      parentConfig: tuple.parentConfig,
-      pendingWrites,
-    };
-  }
-
-  async *list(config: RunnableConfig<Record<string, any>>, options?: CheckpointListOptions): AsyncGenerator<CheckpointTuple, any, any> {
-    const response = await mindedConnection.awaitEmit<OnCheckpointList, OnCheckpointListResponse>(
-      mindedConnectionSocketMessageType.CHECKPOINT_LIST,
-      {
-        type: mindedConnectionSocketMessageType.CHECKPOINT_LIST,
-        config,
-        options,
-      },
-    );
-
-    for (const tuple of response.checkpoints || []) {
-      // Re-serialize and deserialize checkpoint to restore class information
-      const [checkpointType, serializedCheckpoint] = this.serde.dumpsTyped(tuple.checkpoint);
-      const checkpoint = (await this.serde.loadsTyped(checkpointType, serializedCheckpoint)) as Checkpoint;
-
-      // Re-serialize and deserialize metadata to restore class information
-      const metadata = tuple.metadata
-        ? (() => {
-          const [metadataType, serializedMetadata] = this.serde.dumpsTyped(tuple.metadata);
-          return this.serde.loadsTyped(metadataType, serializedMetadata) as CheckpointMetadata;
-        })()
-        : undefined;
-
-      yield {
-        config: tuple.config,
-        checkpoint,
-        metadata: await metadata,
-        parentConfig: tuple.parentConfig,
-      };
-    }
-  }
-
-  async put(
-    config: RunnableConfig<Record<string, any>>,
-    checkpoint: Checkpoint<string, string>,
-    metadata: CheckpointMetadata,
-    newVersions: ChannelVersions,
-  ): Promise<RunnableConfig<Record<string, any>>> {
-    try {
-      const response = await mindedConnection.awaitEmit<OnCheckpointPut, OnCheckpointPutResponse>(
-        mindedConnectionSocketMessageType.CHECKPOINT_PUT,
-        {
-          type: mindedConnectionSocketMessageType.CHECKPOINT_PUT,
-          config,
-          checkpoint,
-          metadata,
-          newVersions,
-        },
-      );
-      return response.config;
-    } catch (error) {
-      logger.error({ msg: 'Error putting checkpoint:', error });
-      return config;
-    }
-  }
-
-  async putWrites(config: RunnableConfig<Record<string, any>>, writes: PendingWrite[], taskId: string): Promise<void> {
-    try {
-      await mindedConnection.awaitEmit<OnCheckpointPutWrites, any>(mindedConnectionSocketMessageType.CHECKPOINT_PUT_WRITES, {
-        type: mindedConnectionSocketMessageType.CHECKPOINT_PUT_WRITES,
-        config,
-        writes,
-        taskId,
-      });
-    } catch (error) {
-      logger.error({ msg: 'Error putting writes:', error });
-    }
-  }
-}