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

package/src/nodes/addBrowserTaskRunNode.ts

@@ -1,144 +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;
-    try {
-      if (!taskId) {
-        throw new Error('Task ID not found in tool call arguments');
-      }
-
-      // 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,
-            nodeDisplayName: browserTaskNode.displayName,
-            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,
-            nodeDisplayName: browserTaskNode.displayName,
-            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,
-            nodeDisplayName: browserTaskNode.displayName,
-            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,
-            nodeDisplayName: browserTaskNode.displayName,
-            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/nodes/addHumanInTheLoopNode.ts

@@ -1,25 +0,0 @@
-import { interrupt } from '@langchain/langgraph';
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { RunnableLike } from '@langchain/core/runnables';
-import { logger } from '../utils/logger';
-import { internalNodesSuffix } from '../types/Flows.types';
-
-type AddHumanInTheLoopNodeParams = {
-  graph: PreCompiledGraph;
-  attachedToNodeName: string;
-};
-
-export const buildHumanInTheLoopNodeName = (nodeName: string) => `${nodeName}${internalNodesSuffix.HUMAN_IN_THE_LOOP}`;
-
-export const addHumanInTheLoopNode = async ({ graph, attachedToNodeName }: AddHumanInTheLoopNodeParams) => {
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.debug({ msg: `[Node] Waiting for human input`, node: attachedToNodeName });
-
-    if (state.messages[state.messages.length - 1].getType() === 'ai') {
-      const value = interrupt('input from human in the loop');
-      return value;
-    }
-  };
-  graph.addNode(buildHumanInTheLoopNodeName(attachedToNodeName), callback);
-  graph.addEdge(attachedToNodeName as any, buildHumanInTheLoopNodeName(attachedToNodeName) as any);
-};

package/src/nodes/addJumpToNode.ts

@@ -1,25 +0,0 @@
-import { RunnableLike } from '@langchain/core/runnables';
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { JumpToNode, NodeType } from '../types/Flows.types';
-import { logger } from '../utils/logger';
-import { HistoryStep } from '../types/Agent.types';
-import { createHistoryStep } from '../utils/history';
-
-export const addJumpToNode = async ({ graph, node }: { graph: PreCompiledGraph; node: JumpToNode }) => {
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    logger.info(`Executing jump node ${node.displayName} – jumping to ${node.targetNodeId}`);
-    // No state modifications are necessary; control flow is handled via edges.
-    return {
-      goto: null,
-      history: createHistoryStep<HistoryStep>(state.history, {
-        type: NodeType.JUMP_TO_NODE,
-        nodeId: node.name,
-        nodeDisplayName: node.displayName,
-        raw: '',
-      }),
-    };
-  };
-
-  graph.addNode(node.name, callback);
-  graph.addEdge(node.name as any, node.targetNodeId as any);
-};

package/src/nodes/addJunctionNode.ts

@@ -1,20 +0,0 @@
-import { JunctionNode, NodeType } from '../types/Flows.types';
-import { PreCompiledGraph, stateAnnotation } from '../types/LangGraph.types';
-import { RunnableLike } from '@langchain/core/runnables';
-import { createHistoryStep } from '../utils/history';
-import { HistoryStep } from '../types/Agent.types';
-
-export const addJunctionNode = ({ graph, node }: { graph: PreCompiledGraph; node: JunctionNode }) => {
-  const callback: RunnableLike = async (state: typeof stateAnnotation.State) => {
-    return {
-      goto: null,
-      history: createHistoryStep<HistoryStep>(state.history, {
-        type: NodeType.JUNCTION,
-        nodeId: node.name,
-        nodeDisplayName: node.displayName,
-        raw: '',
-      }),
-    };
-  };
-  graph.addNode(node.name, callback);
-};

package/src/nodes/addPromptNode.ts

@@ -1,119 +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.debug({ msg: `[Node] Executing prompt node`, 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] Calling tool`, tool: matchedTool?.name });
-        if (matchedTool) {
-          try {
-            // Invoke the LangChain tool directly
-            const toolResult = await matchedTool.invoke(toolCall);
-            logger.debug({ msg: `[Tool] Tool result`, tool: matchedTool?.name, result: toolResult });
-            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: `[Tool] Error executing tool`, 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: `[Tool] Model called tool but it was not found`, tool: toolCall.name });
-        }
-      }
-
-      // 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,
-      });
-      logger.info({ msg: `[Model] Response`, content: result.content });
-    }
-
-    return {
-      goto: null,
-      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,72 +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.debug({ msg: `[Node] Executing tool node`, 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
-      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 {
-      goto: null,
-      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,76 +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: '[Tool] Error executing tool', error, node: toolNode.displayName });
-        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 {
-      goto: null,
-      ...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,27 +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.debug({ msg: `[Trigger] Executing trigger node`, node: node.displayName });
-    if (node.triggerType === TriggerType.MANUAL) {
-      return {
-        goto: null,
-        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,57 +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';
-import { addBrowserTaskNode } from './addBrowserTaskNode';
-
-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, tools });
-      break;
-    case NodeType.PROMPT_NODE:
-      addPromptNode({ graph, node, tools, llm, emit, agent });
-      break;
-    case NodeType.JUMP_TO_NODE:
-      addJumpToNode({ graph, node });
-      break;
-    case NodeType.BROWSER_TASK:
-      addBrowserTaskNode({ graph, node, agent, llm });
-      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',
-      };
-  }
-};