@minded-ai/mindedjs 1.0.92 → 1.0.93-beta.2

package/src/agent.ts

@@ -10,13 +10,10 @@ import { CompiledGraph, PreCompiledGraph, stateAnnotation } from './types/LangGr
 import { edgeFactory } from './edges/edgeFactory';
 import { AgentEventRequestPayloads, AgentEventResponsePayloads, AgentEvents } from './events/AgentEvents';
 import { z } from 'zod';
-import { MindedConnection } from './platform/mindedConnection';
+import * as mindedConnection from './platform/mindedConnection';
 import {
   InvokeMessage,
-  MindedConnectionSocketMessageType,
-  TimerCancelResponse,
-  TimerResetResponse,
-  TimerTriggerRequest,
+  mindedConnectionSocketMessageType,
 } from './platform/mindedConnectionTypes';
 import * as fs from 'fs';
 import * as path from 'path';
@@ -41,6 +38,7 @@ import { PIIGateway, PIIGatewayInstance } from './platform/piiGateway';
 import { logger } from './utils/logger';
 import { loadPlaybooks, Playbook } from './playbooks/playbooks';
 import { createHistoryStep } from './utils/history';
+import { timerHandlers } from './internalTools/timer';
 
 type CreateAgentParams<Memory> = {
   memorySchema: z.ZodSchema;
@@ -72,8 +70,12 @@ export class Agent {
   private memorySchema: z.ZodSchema;
   private flows!: Flow[];
   public tools!: Tool<any, any>[];
+  /**
+   * Internal tools
+   */
   public llm!: BaseLanguageModel;
-  public mindedConnection: MindedConnection | null = null;
+  // Remove the mindedConnection property since it's now a singleton module
+
   // Langgraph memory saver. In memory for local development, Custom for Platform
   private checkpointer!: BaseCheckpointSaver;
   // Langgraph compiled graph
@@ -86,10 +88,10 @@ export class Agent {
   private _piiGateway: PIIGatewayInstance | null = null;
   public playbooks: Playbook[] = [];
 
-  // PII gateway instance getter
+  // Getter for PII Gateway that ensures it's available
   public get piiGateway(): PIIGatewayInstance {
     if (!this._piiGateway) {
-      throw new Error('Minded connection is not established when trying to get PII gateway');
+      throw new Error('PII Gateway is not initialized. Make sure the agent is connected to the Minded platform.');
     }
     return this._piiGateway;
   }
@@ -149,12 +151,12 @@ export class Agent {
       const { config, tools, memorySaver } = params;
       const { runLocally } = getConfig();
       if (!runLocally) {
-        this.mindedConnection = new MindedConnection();
-        await this.mindedConnection.start();
+        await mindedConnection.start();
 
         // Initialize PII gateway
-        this._piiGateway = new PIIGateway(this.mindedConnection);
-        this.mindedConnection.on(MindedConnectionSocketMessageType.INVOKE, async (message, callback) => {
+        this._piiGateway = new PIIGateway();
+
+        mindedConnection.on(mindedConnectionSocketMessageType.INVOKE, async (message, callback) => {
           const invokeMessage = message as InvokeMessage;
           const result = await this.invoke({
             triggerBody: invokeMessage.triggerBody,
@@ -164,20 +166,18 @@ export class Agent {
           });
           callback(result);
         });
-        this.mindedConnection.on(MindedConnectionSocketMessageType.TIMER_TRIGGER, async (message) => {
-          const timerTriggerMessage = message as TimerTriggerRequest;
-          await this.emit(AgentEvents.TIMER_TRIGGER, {
-            sessionId: timerTriggerMessage.sessionId,
-            timerName: timerTriggerMessage.timerName,
-            eventArgs: timerTriggerMessage.eventArgs,
-          });
+
+        mindedConnection.on(mindedConnectionSocketMessageType.RESTORE_CHECKPOINT, async (restoreCheckpointMessage, callback) => {
+          const langraphConfig = this.getLangraphConfig(restoreCheckpointMessage.sessionId, restoreCheckpointMessage.checkpointId);
+          this.compiledGraph.invoke({}, langraphConfig);
+          callback({ success: true });
         });
       }
 
       const [, flows, playbooks] = await Promise.all([
         this.loadSecrets(),
         this.loadFlows(config.flows),
-        loadPlaybooks(this.mindedConnection, config.playbooks),
+        loadPlaybooks(config.playbooks),
       ]);
 
       this.playbooks = playbooks;
@@ -185,7 +185,7 @@ export class Agent {
       this.validate();
       const appActionsRunnerTools = this.initAppActionsRunnerTools();
       this.tools = [...tools, ...appActionsRunnerTools];
-      this.checkpointer = memorySaver || createCheckpointSaver(this.mindedConnection);
+      this.checkpointer = memorySaver || createCheckpointSaver();
 
       // call here methods that needs environment variables to be loaded
       this.llm = createLlmInstance(config.llm);
@@ -207,8 +207,8 @@ export class Agent {
   private async loadFlows(flowsDirectories: string[]) {
     const { env, isDeployed } = getConfig();
     if (['sandbox-staging', 'sandbox'].includes(env) && isDeployed) {
-      const response = await this.mindedConnection?.awaitEmit<object, { flows: Record<string, Flow> }>(
-        MindedConnectionSocketMessageType.GET_FLOWS,
+      const response = await mindedConnection.awaitEmit<object, { flows: Record<string, Flow> }>(
+        mindedConnectionSocketMessageType.GET_FLOWS,
         {},
       );
       if (!response?.flows) {
@@ -376,14 +376,14 @@ export class Agent {
 
     return appName
       ? createHistoryStep<AppTriggerHistoryStep>(currentHistory, {
-          ...baseStep,
-          type: NodeType.TRIGGER,
-          appName,
-        })
+        ...baseStep,
+        type: NodeType.TRIGGER,
+        appName,
+      })
       : createHistoryStep<TriggerHistoryStep>(currentHistory, {
-          ...baseStep,
-          type: NodeType.TRIGGER,
-        });
+        ...baseStep,
+        type: NodeType.TRIGGER,
+      });
   }
 
   /**
@@ -690,32 +690,7 @@ export class Agent {
     (this.eventHandlers[event] as Array<typeof handler>).push(handler);
   }
 
-  public async resetTimer(
-    sessionId: string,
-    seconds: number,
-    timerName: string,
-    eventArgs: Record<string, any>,
-  ): Promise<TimerResetResponse> {
-    if (!this.mindedConnection) {
-      throw new Error('Minded connection is not established when trying to reset timer');
-    }
-    return await this.mindedConnection.awaitEmit(MindedConnectionSocketMessageType.TIMER_RESET, {
-      sessionId,
-      seconds,
-      timerName,
-      eventArgs,
-    });
-  }
 
-  public async cancelTimer(sessionId: string, timerName: string): Promise<TimerCancelResponse> {
-    if (!this.mindedConnection) {
-      throw new Error('Minded connection is not established when trying to cancel timer');
-    }
-    return await this.mindedConnection.awaitEmit(MindedConnectionSocketMessageType.TIMER_CANCEL, {
-      sessionId,
-      timerName,
-    });
-  }
 
   // Internal method to emit events to the registered listeners
   private async emit<E extends keyof AgentEventRequestPayloads<z.infer<typeof this.memorySchema>>>(
@@ -731,12 +706,12 @@ export class Agent {
 
   private initAppActionsRunnerTools() {
     const { runLocally } = getConfig();
-    if (!runLocally && !this.mindedConnection && process.env.NODE_ENV !== 'test') {
+    if (!runLocally && !mindedConnection.isConnected() && process.env.NODE_ENV !== 'test') {
       throw new Error('Minded connection is mandatory to use run app action tools');
     }
     return this.flows
       .flatMap((flow) => flow.nodes.filter((node) => node.type === NodeType.APP_TOOL))
-      .map((node) => appActionRunnerToolCreator(node.metadata.schema, node.displayName!, this.mindedConnection as MindedConnection));
+      .map((node) => appActionRunnerToolCreator(node.metadata.schema, node.displayName!));
   }
 
   // Private method to get secrets from the backend service and load them into environment variables
@@ -747,7 +722,7 @@ export class Agent {
       logger.info('Running locally - skipping secret loading');
       return {};
     }
-    if (!this.mindedConnection?.isConnected) {
+    if (!mindedConnection.isConnected()) {
       throw new Error('Minded connection is not established when trying to get secrets');
     }
 
@@ -758,12 +733,12 @@ export class Agent {
 
     try {
       // Check if mindedConnection is available
-      if (!this.mindedConnection) {
+      if (!mindedConnection.isConnected()) {
         throw new Error('Platform is not available');
       }
 
-      const response = await this.mindedConnection.awaitEmit<object, { secrets: Record<string, string> }>(
-        MindedConnectionSocketMessageType.GET_SECRETS,
+      const response = await mindedConnection.awaitEmit<object, { secrets: Record<string, string> }>(
+        mindedConnectionSocketMessageType.GET_SECRETS,
         {},
       );
 
@@ -785,28 +760,28 @@ export class Agent {
     }
   }
 
-  public getLangraphConfig(sessionId: string): { configurable: { thread_id: string; recursionLimit: number } } {
-    return { configurable: { thread_id: sessionId, recursionLimit: 3 } };
+  public getLangraphConfig(sessionId: string, checkpointId?: string) {
+    return { configurable: { thread_id: sessionId, recursionLimit: 3, checkpoint_id: checkpointId } };
   }
 
   private setupVoice(): void {
     logger.info('Setting up voice');
-    if (!this.mindedConnection) {
+    if (!mindedConnection.isConnected()) {
       throw new Error('Minded connection is required');
     }
 
-    const connection = this.mindedConnection;
+    const connection = mindedConnection;
     const { dashboardConnected } = getConfig();
 
     if (dashboardConnected) {
       // Listen for voice session start
-      connection.on(MindedConnectionSocketMessageType.DASHBOARD_VOICE_SESSION_START, async (message) => {
+      connection.on(mindedConnectionSocketMessageType.DASHBOARD_VOICE_SESSION_START, async (message) => {
         const sessionStart = message as BaseVoiceMessage;
         await this.startVoiceSession({ sessionId: sessionStart.sessionId });
       });
 
       // Listen for incoming audio from the platform
-      connection.on(MindedConnectionSocketMessageType.DASHBOARD_VOICE_USER_AUDIO, (message) => {
+      connection.on(mindedConnectionSocketMessageType.DASHBOARD_VOICE_USER_AUDIO, (message) => {
         const audioMessage = message as OnVoiceAudioOut;
         const voiceSession = this.voiceSessions.get(audioMessage.sessionId);
         if (voiceSession) {
@@ -821,7 +796,7 @@ export class Agent {
       });
 
       // Hangup / end session handler
-      connection.on(MindedConnectionSocketMessageType.DASHBOARD_VOICE_SESSION_END, (message) => {
+      connection.on(mindedConnectionSocketMessageType.DASHBOARD_VOICE_SESSION_END, (message) => {
         const hangup = message as BaseVoiceMessage;
         logger.debug({ message: 'Dashboard eneded voice session', sessionId: hangup.sessionId });
         const voiceSession = this.voiceSessions.get(hangup.sessionId);
@@ -838,19 +813,9 @@ export class Agent {
     }
   }
 
-  public async sendPlaceholderMessage({ sessionId, message }: { sessionId: string; message: string }): Promise<void> {
-    if (!this.mindedConnection) {
-      throw new Error('Minded connection is not established when trying to send placeholder message');
-    }
-    const connection = this.mindedConnection;
-    connection.emit(MindedConnectionSocketMessageType.DASHBOARD_VOICE_PLACEHOLDER_MESSAGES, {
-      sessionId,
-      message,
-      timestamp: Date.now(),
-      type: MindedConnectionSocketMessageType.DASHBOARD_VOICE_PLACEHOLDER_MESSAGES,
-    });
-  }
-
+  /*
+   To be used by the Lambda wrapper to start voice sessions
+  */
   public async startVoiceSession(params: { sessionId: string }): Promise<VoiceSession> {
     await this.waitForInitialization();
     const voiceTrigger = this.flows
@@ -877,12 +842,16 @@ export class Agent {
     return voiceSession;
   }
 
+  /*
+   To be used by the Lambda wrapper to trigger timers
+  */
   public async timerTrigger(params: { sessionId: string; timerName: string; eventArgs: Record<string, any> }): Promise<void> {
-    console.log('timerTrigger fired from lambda', params);
-    await this.emit(AgentEvents.TIMER_TRIGGER, {
-      sessionId: params.sessionId,
-      timerName: params.timerName,
-      eventArgs: params.eventArgs,
-    });
+    const handlers = timerHandlers.get(params.timerName) || [];
+    for (const { handler } of handlers) {
+      await handler({
+        sessionId: params.sessionId,
+        payload: params.eventArgs,
+      });
+    }
   }
 }

package/src/checkpointer/checkpointSaverFactory.ts

@@ -1,19 +1,18 @@
 import { BaseCheckpointSaver, MemorySaver } from '@langchain/langgraph';
 import { MindedCheckpointSaver } from '../platform/mindedCheckpointSaver';
-import { MindedConnection } from '../platform/mindedConnection';
+import * as mindedConnection from '../platform/mindedConnection';
 import { logger } from '../utils/logger';
 
 /**
  * Factory function to create the appropriate checkpoint saver based on environment variables.
- * @param platformToken - Optional platform token for remote checkpoint saving
  * @returns BaseCheckpointSaver instance (either MemorySaver or MindedCheckpointSaver)
  */
-export function createCheckpointSaver(mindedConnection: MindedConnection | null): BaseCheckpointSaver {
-  if (!mindedConnection) {
-    logger.warn('mindedConnection not set, falling back to in-memory checkpoint saver');
+export function createCheckpointSaver(): BaseCheckpointSaver {
+  if (!mindedConnection.isConnected()) {
+    logger.warn('mindedConnection not connected, falling back to in-memory checkpoint saver');
     return new MemorySaver();
   }
 
   logger.debug('Using remote checkpoint saver');
-  return new MindedCheckpointSaver(mindedConnection);
+  return new MindedCheckpointSaver();
 }

package/src/events/AgentEvents.ts

@@ -7,8 +7,7 @@ export enum AgentEvents {
   AI_MESSAGE = 'AI_MESSAGE',
   TRIGGER_EVENT = 'TRIGGER_EVENT',
   VOICE_SESSION_START = 'VOICE_SESSION_START',
-  ERROR = 'ERROR',
-  TIMER_TRIGGER = 'TIMER_TRIGGER',
+  ERROR = 'ERROR'
 }
 
 export type AgentEventRequestPayloads<Memory> = {
@@ -31,11 +30,6 @@ export type AgentEventRequestPayloads<Memory> = {
     error: Error;
     state?: State<Memory>;
   };
-  [AgentEvents.TIMER_TRIGGER]: {
-    sessionId: string;
-    timerName: string;
-    eventArgs: Record<string, any>;
-  };
 };
 
 export type AgentEventResponsePayloads<Memory> = {
@@ -50,5 +44,4 @@ export type AgentEventResponsePayloads<Memory> = {
   };
   [AgentEvents.VOICE_SESSION_START]: void;
   [AgentEvents.ERROR]: void;
-  [AgentEvents.TIMER_TRIGGER]: void;
 };

package/src/index.ts

@@ -1,9 +1,11 @@
 import { Agent } from './agent';
 import events from './events';
 import { logger } from './utils/logger';
+import { sendPlaceholderMessage } from './internalTools/sendPlaceholderMessage';
+import { resetTimer, cancelTimer, onTimer } from './internalTools/timer';
 
 export type { ElevenLabsContext } from './types/Voice.types';
-export { Agent, events, logger };
+export { Agent, events, logger, sendPlaceholderMessage, resetTimer, cancelTimer, onTimer };
 
 // HTTP module for PII masking - only public API
 export type { PIIGatewayInstance, HttpRequestConfig, HttpResponse } from './platform/piiGateway';

package/src/interfaces/zendesk.ts

@@ -1,5 +1,6 @@
 import { Agent } from '../agent';
-import { MindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
+import * as mindedConnection from '../platform/mindedConnection';
+import { mindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
 
 export const zendesk = {
   agent: null as Agent | null,
@@ -8,9 +9,9 @@ export const zendesk = {
   },
 
   sendMessage: async (sessionId: string, message: string) => {
-    if (!zendesk.agent?.mindedConnection) return;
-    return await zendesk.agent.mindedConnection.awaitEmit(MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
+    if (!mindedConnection.isConnected()) return;
+    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
+      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
       interfaceName: 'zendesk',
       sessionId,
       functionName: 'sendMessage',
@@ -19,9 +20,9 @@ export const zendesk = {
   },
 
   sendComment: async (sessionId: string, comment: string) => {
-    if (!zendesk.agent?.mindedConnection) return;
-    return await zendesk.agent.mindedConnection.awaitEmit(MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
+    if (!mindedConnection.isConnected()) return;
+    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
+      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
       interfaceName: 'zendesk',
       sessionId,
       functionName: 'sendComment',
@@ -30,9 +31,9 @@ export const zendesk = {
   },
 
   sendPublicComment: async (sessionId: string, comment: string) => {
-    if (!zendesk.agent?.mindedConnection) return;
-    return await zendesk.agent.mindedConnection.awaitEmit(MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
+    if (!mindedConnection.isConnected()) return;
+    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
+      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
       interfaceName: 'zendesk',
       sessionId,
       functionName: 'sendPublicComment',
@@ -41,9 +42,9 @@ export const zendesk = {
   },
 
   getConversation: async (sessionId: string) => {
-    if (!zendesk.agent?.mindedConnection) return;
-    return await zendesk.agent.mindedConnection.awaitEmit(MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
+    if (!mindedConnection.isConnected()) return;
+    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
+      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
       interfaceName: 'zendesk',
       sessionId,
       functionName: 'getConversation',
@@ -52,9 +53,9 @@ export const zendesk = {
   },
 
   getConversationMessages: async (sessionId: string) => {
-    if (!zendesk.agent?.mindedConnection) return;
-    return await zendesk.agent.mindedConnection.awaitEmit(MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
+    if (!mindedConnection.isConnected()) return;
+    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
+      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
       interfaceName: 'zendesk',
       sessionId,
       functionName: 'getConversationMessages',
@@ -63,9 +64,9 @@ export const zendesk = {
   },
 
   addTag: async (sessionId: string, tag: string) => {
-    if (!zendesk.agent?.mindedConnection) return;
-    return await zendesk.agent.mindedConnection.awaitEmit(MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
+    if (!mindedConnection.isConnected()) return;
+    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
+      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
       interfaceName: 'zendesk',
       sessionId,
       functionName: 'addTag',
@@ -74,9 +75,9 @@ export const zendesk = {
   },
 
   getTicket: async (sessionId: string) => {
-    if (!zendesk.agent?.mindedConnection) return;
-    return await zendesk.agent.mindedConnection.awaitEmit(MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
+    if (!mindedConnection.isConnected()) return;
+    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
+      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
       interfaceName: 'zendesk',
       sessionId,
       functionName: 'getTicket',
@@ -101,9 +102,9 @@ export const zendesk = {
     tags: string[];
     customFields: any[];
   }) => {
-    if (!zendesk.agent?.mindedConnection) return;
-    return await zendesk.agent.mindedConnection.awaitEmit(MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
+    if (!mindedConnection.isConnected()) return;
+    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
+      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
       interfaceName: 'zendesk',
       sessionId,
       functionName: 'createTicket',
@@ -111,9 +112,9 @@ export const zendesk = {
     });
   },
   markTicketAsSolved: async ({ sessionId }: { sessionId: string }) => {
-    if (!zendesk.agent?.mindedConnection) return;
-    return await zendesk.agent.mindedConnection.awaitEmit(MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
+    if (!mindedConnection.isConnected()) return;
+    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
+      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
       interfaceName: 'zendesk',
       sessionId,
       functionName: 'markTicketAsSolved',
@@ -122,9 +123,9 @@ export const zendesk = {
   },
 
   markTicketAsOpen: async ({ sessionId }: { sessionId: string }) => {
-    if (!zendesk.agent?.mindedConnection) return;
-    return await zendesk.agent.mindedConnection.awaitEmit(MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
+    if (!mindedConnection.isConnected()) return;
+    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
+      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
       interfaceName: 'zendesk',
       sessionId,
       functionName: 'markTicketAsOpen',
@@ -133,9 +134,9 @@ export const zendesk = {
   },
 
   setCustomFields: async ({ sessionId, fields }: { sessionId: string; fields: any[] }) => {
-    if (!zendesk.agent?.mindedConnection) return;
-    return await zendesk.agent.mindedConnection.awaitEmit(MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
+    if (!mindedConnection.isConnected()) return;
+    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
+      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
       interfaceName: 'zendesk',
       sessionId,
       functionName: 'setCustomFields',
@@ -144,9 +145,9 @@ export const zendesk = {
   },
 
   search: async ({ sessionId, query }: { sessionId: string; query: string }) => {
-    if (!zendesk.agent?.mindedConnection) return;
-    return await zendesk.agent.mindedConnection.awaitEmit(MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
-      type: MindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
+    if (!mindedConnection.isConnected()) return;
+    return await mindedConnection.awaitEmit(mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL, {
+      type: mindedConnectionSocketMessageType.INTERFACE_FUNCTION_CALL,
       interfaceName: 'zendesk',
       sessionId,
       functionName: 'search',

package/src/internalTools/appActionRunnerTool.ts

@@ -1,5 +1,5 @@
-import { MindedConnection } from '../platform/mindedConnection';
-import { MindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
+import * as mindedConnection from '../platform/mindedConnection';
+import { mindedConnectionSocketMessageType } from '../platform/mindedConnectionTypes';
 import { ActionInputParam } from '../types/Flows.types';
 import { Tool, ToolExecuteInput } from '../types/Tools.types';
 import { z } from 'zod';
@@ -24,7 +24,7 @@ const convertToZodSchema = (schema: Record<string, { type: string; example?: any
 
 const createdTools: Record<string, Tool<any, any>> = {};
 
-const appActionRunnerToolCreator = (schema: ActionInputParam[], nodeTitle: string, mindedConnection: MindedConnection): Tool<any, any> => {
+const appActionRunnerToolCreator = (schema: ActionInputParam[], nodeTitle: string): Tool<any, any> => {
   const zodSchema = convertToZodSchema(
     schema.reduce((acc, param) => {
       if (param.required) {
@@ -51,7 +51,7 @@ const appActionRunnerToolCreator = (schema: ActionInputParam[], nodeTitle: strin
     input: zodSchema,
     execute: async ({ input, state }: ToolExecuteInput<typeof zodSchema>) => {
       const response = await mindedConnection.awaitEmit(
-        MindedConnectionSocketMessageType.OnAppAction,
+        mindedConnectionSocketMessageType.OnAppAction,
         {
           nodeTitle,
           actionInput: input,

package/src/internalTools/sendPlaceholderMessage.ts

@@ -0,0 +1,27 @@
+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,
+  });
+}