@minded-ai/mindedjs 1.0.102 → 1.0.103-beta-1

package/src/platform/mindedChatOpenAI.ts

@@ -0,0 +1,19 @@
+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/mindedConnection.ts

@@ -1,8 +1,5 @@
 import { io, Socket } from 'socket.io-client';
-import {
-  mindedConnectionSocketMessageType,
-  mindedConnectionSocketMessageTypeMap,
-} from './mindedConnectionTypes';
+import { mindedConnectionSocketMessageType, mindedConnectionSocketMessageTypeMap } from './mindedConnectionTypes';
 import { stringify } from 'flatted';
 import { getConfig } from './config';
 import { logger } from '../utils/logger';
@@ -28,20 +25,13 @@ export const on = <E extends keyof mindedConnectionSocketMessageTypeMap>(
   listeners[event].push(callback);
 };
 
-export const emit = <E extends keyof mindedConnectionSocketMessageTypeMap>(
-  event: E,
-  message: mindedConnectionSocketMessageTypeMap[E]
-) => {
+export const emit = <E extends keyof mindedConnectionSocketMessageTypeMap>(event: E, message: mindedConnectionSocketMessageTypeMap[E]) => {
   if (socket) {
     socket.emit(event, message);
   }
 };
 
-export const awaitEmit = async <T, R>(
-  event: mindedConnectionSocketMessageType,
-  message: T,
-  timeoutMs: number = 5000
-): Promise<R> => {
+export const awaitEmit = async <T, R>(event: mindedConnectionSocketMessageType, message: T, timeoutMs: number = 5000): Promise<R> => {
   if (!socket) {
     throw new Error('Socket is not connected');
   }
@@ -97,43 +87,43 @@ const connect = async (token: string): Promise<void> => {
 
     const checkReady = () => {
       if (connected && ready) {
-        logger.info('\x1b[32mConnection with Minded platform is ready!\x1b[0m');
-        logger.info('\x1b[32mPress Ctrl+C to exit...');
+        logger.info({ message: '\x1b[32mConnection with Minded platform is ready!\x1b[0m' });
+        logger.info({ message: '\x1b[32mPress Ctrl+C to exit...' });
         resolve();
       }
     };
 
     // Connection event handlers
     socket.on('connect', () => {
-      logger.info('Socket connected, waiting for server setup...');
+      logger.info({ message: 'Socket connected, waiting for server setup...' });
       connected = true;
       checkReady();
     });
 
     // Listen for ready event from server
     socket.on('sdk-socket-ready', (data: { agentId: string; orgName: string }) => {
-      logger.info('Server ready signal received', data);
+      logger.info({ message: 'Server ready signal received', data });
       ready = true;
       checkReady();
     });
 
     socket.on('connect_error', () => {
-      logger.error('Failed to connect to minded platform');
+      logger.error({ message: 'Failed to connect to minded platform' });
       reject(new Error('Failed to connect to minded platform'));
     });
 
     socket.on('disconnect', () => {
-      logger.info('Disconnected from local debugging socket');
+      logger.info({ message: 'Disconnected from local debugging socket' });
       connected = false;
       ready = false;
     });
 
     // Listen for error messages from the server
     socket.on('error', async (error: { message: string }) => {
-      logger.error({ msg: 'Server error:', error });
+      logger.error({ message: 'Server error:', error });
 
       if (error.message.includes('Invalid token')) {
-        logger.info('Invalid token');
+        logger.info({ message: 'Invalid token' });
 
         // Disconnect current socket
         if (socket?.connected) {
@@ -159,7 +149,7 @@ const connect = async (token: string): Promise<void> => {
     // Handle process termination
     process.on('SIGINT', () => {
       if (socket?.connected) {
-        logger.info('\nDisconnecting...');
+        logger.info({ message: '\nDisconnecting...' });
         socket.disconnect();
       }
       process.exit(0);
@@ -177,17 +167,17 @@ export const start = async (): Promise<void> => {
 
 export const disconnect = () => {
   if (!socket) {
-    logger.warn('No socket connection to disconnect');
+    logger.warn({ message: 'No socket connection to disconnect' });
     return;
   }
 
   if (socket.connected) {
-    logger.info('Disconnecting from Minded platform...');
+    logger.info({ message: 'Disconnecting from Minded platform...' });
     socket.disconnect();
     return;
   }
 
-  logger.warn('Socket is already disconnected');
+  logger.warn({ message: 'Socket is already disconnected' });
 };
 
 export const mindedConnection = {

package/src/platform/mindedConnectionTypes.ts

@@ -33,6 +33,15 @@ export enum mindedConnectionSocketMessageType {
   TIMER_RESET = 'timer-reset',
   TIMER_CANCEL = 'timer-cancel',
   TIMER_TRIGGER = 'timer-trigger',
+  // Interrupt Session Management
+  INTERRUPT_SESSION_IS_PROCESSED = 'interrupt-session-is-processed',
+  INTERRUPT_SESSION_LOCK = 'interrupt-session-lock',
+  INTERRUPT_SESSION_RELEASE = 'interrupt-session-release',
+  INTERRUPT_SESSION_ENQUEUE = 'interrupt-session-enqueue',
+  INTERRUPT_SESSION_DEQUEUE_ALL = 'interrupt-session-dequeue-all',
+  INTERRUPT_SESSION_DEQUEUE = 'interrupt-session-dequeue',
+  INTERRUPT_SESSION_HAS_MESSAGES = 'interrupt-session-has-messages',
+  INTERRUPT_SESSION_GET_MESSAGES = 'interrupt-session-get-messages',
 }
 
 export type mindedConnectionSocketMessageTypeMap = {
@@ -57,6 +66,15 @@ export type mindedConnectionSocketMessageTypeMap = {
   [mindedConnectionSocketMessageType.TIMER_CANCEL]: TimerCancelRequest;
   [mindedConnectionSocketMessageType.TIMER_TRIGGER]: TimerTriggerRequest;
   [mindedConnectionSocketMessageType.RESTORE_CHECKPOINT]: RestoreCheckpointRequest;
+  // Interrupt Session Management
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_IS_PROCESSED]: InterruptSessionIsProcessedRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_LOCK]: InterruptSessionLockRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_RELEASE]: InterruptSessionReleaseRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_ENQUEUE]: InterruptSessionEnqueueRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE_ALL]: InterruptSessionDequeueAllRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_DEQUEUE]: InterruptSessionDequeueRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_HAS_MESSAGES]: InterruptSessionHasMessagesRequest;
+  [mindedConnectionSocketMessageType.INTERRUPT_SESSION_GET_MESSAGES]: InterruptSessionGetMessagesRequest;
 };
 
 export interface BasemindedConnectionSocketMessage {
@@ -181,6 +199,166 @@ export interface TimerTriggerRequest extends BasemindedConnectionSocketMessage {
   eventArgs: Record<string, any>;
 }
 
+// Interrupt Session Management Interfaces
+export interface InterruptSessionIsProcessedRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionIsProcessedResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  isProcessed?: boolean;
+}
+
+export interface InterruptSessionLockRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionLockResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  lockAcquired?: boolean;
+}
+
+export interface InterruptSessionReleaseRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionReleaseResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionEnqueueRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  message: {
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  };
+}
+
+export interface InterruptSessionEnqueueResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionDequeueAllRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionDequeueAllResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  messages?: Array<{
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  }>;
+}
+
+export interface InterruptSessionDequeueRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionDequeueResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  message?: {
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  } | null;
+}
+
+export interface InterruptSessionHasMessagesRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionHasMessagesResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  hasMessages?: boolean;
+}
+
+export interface InterruptSessionGetMessagesRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionGetMessagesResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  messages?: Array<{
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  }>;
+}
+
+// Interrupt Session Management Interfaces
+export interface InterruptSessionIsProcessedRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionIsProcessedResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  isProcessed?: boolean;
+}
+
+export interface InterruptSessionLockRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionReleaseRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionReleaseResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionEnqueueRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  message: {
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  };
+}
+
+export interface InterruptSessionEnqueueResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}
+
+export interface InterruptSessionDequeueAllRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionDequeueAllResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  messages?: Array<{
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  }>;
+}
+
+export interface InterruptSessionDequeueRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionDequeueResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  message?: {
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  } | null;
+}
+
+export interface InterruptSessionHasMessagesRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionHasMessagesResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  hasMessages?: boolean;
+}
+
+export interface InterruptSessionGetMessagesRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+}
+
+export interface InterruptSessionGetMessagesResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  messages?: Array<{
+    triggerBody: any;
+    triggerName: string;
+    appName?: string;
+  }>;
+}
+
 export interface RestoreCheckpointRequest extends BasemindedConnectionSocketMessage {
   sessionId: string;
   checkpointId: string;
@@ -188,4 +366,13 @@ export interface RestoreCheckpointRequest extends BasemindedConnectionSocketMess
 
 export interface RestoreCheckpointResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
   success?: boolean;
-}
+}
+
+export interface RestoreCheckpointRequest extends BasemindedConnectionSocketMessage {
+  sessionId: string;
+  checkpointId: string;
+}
+
+export interface RestoreCheckpointResponse extends BaseSdkConnectionSocketMessageResponseCallbackAck {
+  success?: boolean;
+}

package/src/playbooks/playbooks.ts

@@ -113,7 +113,7 @@ function loadPlaybooksFromDirectories(directories: string[]): Playbook[] {
 
   for (const directory of directories) {
     if (!fs.existsSync(directory)) {
-      logger.info(`Playbooks directory does not exist: ${directory}`);
+      logger.info({ message: `Playbooks directory does not exist: ${directory}` });
       continue;
     }
 
@@ -126,12 +126,12 @@ function loadPlaybooksFromDirectories(directories: string[]): Playbook[] {
 
         if (playbook && playbook.name && playbook.blocks) {
           playbooks.push(playbook);
-          logger.info(`Loaded playbook: ${playbook.name} from ${file}`);
+          logger.info({ message: `Loaded playbook: ${playbook.name} from ${file}` });
         } else {
-          logger.warn(`Invalid playbook structure in ${file}`);
+          logger.warn({ message: `Invalid playbook structure in ${file}` });
         }
       } catch (error) {
-        logger.error(`Failed to load playbook file ${file}: ${error}`);
+        logger.error({ message: `Failed to load playbook file ${file}: ${error}` });
       }
     }
   }

package/src/types/Agent.types.ts

@@ -29,6 +29,8 @@ export interface AgentInvokeParams {
   sessionId?: string;
   /** Optional name of the application triggering the agent in case of an app trigger */
   appName?: string;
+  /** Internal flag to bypass session processing check for recursive calls */
+  bypassSessionCheck?: boolean;
 }
 export interface HistoryStep {
   type: NodeType;

package/src/types/Flows.types.ts

@@ -11,7 +11,6 @@ export enum NodeType {
   APP_TOOL = 'appTool',
   PROMPT_NODE = 'promptNode',
   JUMP_TO_NODE = 'jumpToNode',
-  BROWSER_TASK = 'browserTask',
 }
 
 export enum EdgeType {
@@ -59,8 +58,6 @@ export interface AppTriggerNode extends BaseTriggerNode, BaseAppNode {
 
 export interface WebhookTriggerNode extends BaseTriggerNode {
   triggerType: TriggerType.WEBHOOK;
-  autoTrigger?: boolean;
-  defaultPayload?: string;
 }
 
 export interface VoiceTriggerNode extends BaseTriggerNode {
@@ -90,18 +87,6 @@ export interface JumpToNode extends BaseNode {
   targetNodeId: string;
 }
 
-export interface BrowserTaskNode extends BaseNode {
-  type: NodeType.BROWSER_TASK;
-  prompt: string;
-  model?: string;
-  inputSchema?: {
-    name: string;
-    type: 'string' | 'number';
-    description?: string;
-    required?: boolean;
-  }[];
-}
-
 export type TriggerNode = AppTriggerNode | WebhookTriggerNode | ManualTriggerNode | VoiceTriggerNode;
 
 export interface JunctionNode extends BaseNode {
@@ -124,7 +109,7 @@ export interface AppToolNode extends BaseNode, BaseAppNode {
   actionKey: string;
 }
 
-export type Node = TriggerNode | JunctionNode | ToolNode | AppToolNode | PromptNode | JumpToNode | BrowserTaskNode;
+export type Node = TriggerNode | JunctionNode | ToolNode | AppToolNode | PromptNode | JumpToNode;
 
 export interface BaseEdge {
   source: string;
@@ -196,5 +181,4 @@ export enum KnownTriggerNames {
 export enum internalNodesSuffix {
   HUMAN_IN_THE_LOOP = '_humanInTheLoop',
   TOOL_RUN = '_toolRun',
-  BROWSER_TASK_RUN = '_browserTaskRun',
 }

package/src/types/LLM.types.ts

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

package/src/types/LangGraph.types.ts

@@ -13,7 +13,6 @@ export const createStateAnnotation = <Memory = any>() =>
             const index = res.findIndex((m) => m.id && m.id === message.id);
             if (index !== -1) {
               res[index].content = message.content;
-              res[index].additional_kwargs = { ...res[index].additional_kwargs, ...message.additional_kwargs };
             }
           } else {
             res.push(message);
@@ -30,10 +29,8 @@ export const createStateAnnotation = <Memory = any>() =>
       default: () => [],
       reducer: (a, b) => a.concat(b),
     }),
-    sessionId: Annotation<string>(),
-    goto: Annotation<string | null | undefined>({
-      default: () => null,
-      reducer: (a, b) => b,
+    sessionId: Annotation<string>({
+      reducer: (a, b) => b || a,
     }),
     sessionType: Annotation<SessionType>({
       default: () => SessionType.TEXT,

package/src/utils/logger.ts

@@ -4,7 +4,7 @@ dotenv.config();
 
 // Create a Pino logger with a custom log format
 export const logger = pino({
-  level: process.env.LOG_LEVEL || 'trace',
+  level: process.env.LOG_LEVEL || 'info',
   base: null,
   transport: {
     target: 'pino-pretty',
@@ -12,6 +12,7 @@ export const logger = pino({
       colorize: true,
       crlf: true,
       translateTime: 'SYS:standard',
+      messageKey: 'message', // Use 'message' instead of default 'msg'
     },
   },
   formatters: {

package/src/voice/voiceSession.ts

@@ -25,7 +25,7 @@ export class VoiceSession {
   private onDisconnectCallback?: () => void;
 
   constructor({ agent, sessionId, firstMessage, voiceId }: { agent: Agent; sessionId: string; firstMessage: string; voiceId?: string }) {
-    logger.debug({ msg: '[Voice] Starting voice session', sessionId, firstMessage, voiceId });
+    logger.debug({ message: 'Starting voice session', sessionId, firstMessage, voiceId });
     this.agent = agent;
     this.sessionId = sessionId;
     this.firstMessage = firstMessage;
@@ -51,6 +51,7 @@ export class VoiceSession {
       apiKey: elevenLabsKey,
     });
 
+    logger.debug({ message: 'Connecting to ElevenLabs', sessionId: this.sessionId });
     this.elevenLabsSocket = new WebSocket(signedUrl);
     this.setupSocketHandlers();
   }
@@ -89,7 +90,7 @@ export class VoiceSession {
     const socket = this.elevenLabsSocket!; // non-null assertion once, we ensured it's assigned in init()
 
     socket.onopen = () => {
-      logger.debug({ msg: '[Voice] Connected to ElevenLabs', sessionId: this.sessionId });
+      logger.debug({ message: 'Connected to ElevenLabs', sessionId: this.sessionId });
       const initiationData: ConversationInitiationClientData = {
         type: 'conversation_initiation_client_data',
         conversation_config_override: {
@@ -115,13 +116,13 @@ export class VoiceSession {
     };
 
     socket.onclose = () => {
-      logger.debug({ msg: '[Voice] Disconnected from ElevenLabs, removing voice session', sessionId: this.sessionId });
+      logger.debug({ message: 'Disconnected from ElevenLabs, removing voice session', sessionId: this.sessionId });
       this.onDisconnectCallback?.();
       this.agent.voiceSessions.delete(this.sessionId);
     };
 
     socket.onerror = (err: unknown) => {
-      logger.error({ msg: '[Voice] socket error', sessionId: this.sessionId, error: err });
+      logger.error({ message: '[ElevenLabsVoice] socket error', sessionId: this.sessionId, error: err });
     };
 
     socket.onmessage = async (event: any) => {
@@ -135,7 +136,7 @@ export class VoiceSession {
           break;
         case 'user_transcript':
           logger.debug({
-            msg: '[Voice] Received user transcript',
+            message: 'User transcript received',
             sessionId: this.sessionId,
             data: data.user_transcription_event.user_transcript,
           });
@@ -147,7 +148,6 @@ export class VoiceSession {
           }
           break;
         case 'agent_response':
-          logger.debug({ msg: '[Voice] Received agent response' });
           if (this.onMessageCallback) {
             this.onMessageCallback(
               data.agent_response_event.agent_response,
@@ -156,7 +156,7 @@ export class VoiceSession {
           }
           break;
         case 'interruption':
-          logger.debug({ msg: '[Voice] Received interruption' });
+          logger.debug('Interruption received');
           this.onInterruptionCallback?.();
           // Send interruption event to dashboard if connected
           if (getConfig().dashboardConnected) {
@@ -167,12 +167,12 @@ export class VoiceSession {
                 timestamp: Date.now(),
               });
             } catch (error) {
-              logger.error({ msg: '[Voice] Error sending interruption to dashboard', sessionId: this.sessionId, error });
+              logger.error({ message: '[ElevenLabsVoice] Error sending interruption to dashboard', sessionId: this.sessionId, error });
             }
           }
           break;
         case 'audio':
-          logger.debug({ msg: '[Voice] Received audio response to user', sessionId: this.sessionId });
+          logger.debug({ message: 'Agent audio received', sessionId: this.sessionId });
           if (this.onAudioCallback) {
             this.onAudioCallback(data.audio_event.audio_base_64);
           }
@@ -185,17 +185,17 @@ export class VoiceSession {
                 type: mindedConnectionSocketMessageType.DASHBOARD_VOICE_AGENT_AUDIO,
               });
             } catch (error) {
-              logger.error({ msg: '[Voice] Error sending audio to dashboard', sessionId: this.sessionId, error });
+              logger.error(`[ElevenLabsVoice] Error sending audio to dashboard: ${error}`);
             }
           }
           break;
         case 'conversation_initiation_metadata':
-          logger.trace({ msg: '[Voice] ElevenLabs conversation initiation metadata', sessionId: this.sessionId, data });
+          logger.debug({ message: 'ElevenLabs conversation initiation metadata', sessionId: this.sessionId, data });
           break;
         case 'agent_response_correction':
           try {
             logger.debug({
-              msg: '[Voice] Received agent response correction',
+              message: 'Agent response correction received',
               sessionId: this.sessionId,
               data: data.agent_response_correction_event,
             });
@@ -204,17 +204,18 @@ export class VoiceSession {
               data.agent_response_correction_event.corrected_agent_response,
             );
           } catch (error) {
-            logger.error({ msg: '[Voice] Error updating agent response', sessionId: this.sessionId, error });
+            logger.error({ message: '[ElevenLabsVoice] Error updating agent response', sessionId: this.sessionId, error });
           }
           break;
         default:
-          logger.debug({ msg: '[Voice] Received unknown message from ElevenLabs', sessionId: this.sessionId, data });
+          logger.debug({ message: 'Received unknown message from ElevenLabs', sessionId: this.sessionId, data });
           break;
       }
     };
   }
 
   private async addFirstMessageToState(): Promise<void> {
+    logger.debug({ message: 'Adding first message to state', sessionId: this.sessionId, firstMessage: this.firstMessage });
     const graphState = await this.agent.compiledGraph.getState(this.agent.getLangraphConfig(this.sessionId));
     if (!graphState.values.messages?.length) {
       await this.agent.compiledGraph.updateState(this.agent.getLangraphConfig(this.sessionId), {
@@ -239,12 +240,12 @@ export class VoiceSession {
         overrideStartFromNodeId: currentNodeId,
       });
     } else {
-      logger.warn({ msg: '[Voice] Agent message not found for correction', sessionId: this.sessionId, originalAgentResponse });
+      logger.warn({ message: 'Agent message not found for correction', sessionId: this.sessionId, originalAgentResponse });
     }
   }
 
   public hangup(): void {
-    logger.info({ msg: '[Voice] Hanging up voice session', sessionId: this.sessionId });
+    logger.info({ message: 'Hanging up voice session', sessionId: this.sessionId });
     this.onDisconnectCallback?.();
     this.elevenLabsSocket?.close();
   }

package/dist/browserTask/executeBrowserTask.d.ts

@@ -1,12 +0,0 @@
-export interface CloudTaskResponse {
-    id: string;
-    status: string;
-    live_url?: string;
-    steps?: any[];
-    output?: string;
-}
-export declare const createCloudTask: (prompt: string, model?: string) => Promise<string>;
-export declare const getTaskDetails: (taskId: string) => Promise<CloudTaskResponse>;
-export declare const waitForLiveUrl: (taskId: string, maxWaitTime?: number) => Promise<CloudTaskResponse>;
-export declare const waitForCompletion: (taskId: string, maxWaitTime?: number) => Promise<CloudTaskResponse>;
-//# sourceMappingURL=executeBrowserTask.d.ts.map

package/dist/browserTask/executeBrowserTask.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"executeBrowserTask.d.ts","sourceRoot":"","sources":["../../src/browserTask/executeBrowserTask.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAGD,eAAO,MAAM,eAAe,GAAU,QAAQ,MAAM,EAAE,QAAQ,MAAM,KAAG,OAAO,CAAC,MAAM,CA6BpF,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,QAAQ,MAAM,KAAG,OAAO,CAAC,iBAAiB,CAkB9E,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,QAAQ,MAAM,EAAE,cAAa,MAAc,KAAG,OAAO,CAAC,iBAAiB,CAsE3G,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,QAAQ,MAAM,EAAE,cAAa,MAAe,KAAG,OAAO,CAAC,iBAAiB,CA0E/G,CAAC"}