WebSocket Events

import { io } from 'socket.io-client';

const socket = io('wss://api.lvng.ai', {
  auth: {
    token: 'YOUR_JWT_TOKEN'
  },
  transports: ['websocket', 'polling']
});

// Connection established
socket.on('connected', (data) => {
  console.log('Connected:', data);
  // { socketId, userId, organizationId, timestamp }
});

// Handle errors
socket.on('error', (err) => {
  console.error('Socket error:', err);
  // { code, message }
});

socket.on('disconnect', (reason) => {
  console.log('Disconnected:', reason);
});

// Send a message to a channel
socket.emit('message:send', {
  channelId: '550e8400-e29b-41d4-a716-446655440000',
  content: 'Hello from WebSocket!',
  optimisticId: 'tmp_abc123',          // Optional, for optimistic UI
  threadId: null,                       // Optional, for threaded replies
  mentions: ['usr_8f3a2b1c-4d5e-...'], // Optional
  workspaceId: 'ws_b2c3d4e5-...'       // Optional
});

// Confirmation sent back to sender only
socket.on('message:sent', (ack) => {
  console.log('Confirmed:', ack);
  // { id, optimisticId, channelId, timestamp }
});

// New message broadcast to the room
socket.on('message:new', (message) => {
  console.log('New message:', message);
  // { id, channelId, conversationId, userId, userName,
  //   content, contentType, threadId, attachments,
  //   createdAt, updatedAt, metadata }
});

// Message edited
socket.on('message:update', (update) => {
  console.log('Updated:', update);
  // { messageId, content, metadata, channelId,
  //   conversationId, updatedBy, timestamp }
});

// Message deleted
socket.on('message:delete', (data) => {
  console.log('Deleted:', data);
  // { messageId, channelId, conversationId,
  //   deletedBy, deletedByName, timestamp }
});

// Reaction added or removed
socket.on('message:reaction', (reaction) => {
  console.log('Reaction:', reaction);
  // { messageId, channelId, emoji, userId,
  //   userName, action: 'add'|'remove', timestamp }
});

// Read receipt
socket.on('message:read', (receipt) => {
  console.log('Read:', receipt);
  // { messageId, channelId, conversationId,
  //   userId, userName, timestamp }
});

// Batch read receipts
socket.on('message:read:batch', (batch) => {
  console.log('Batch read:', batch);
  // { messageIds: [], channelId, conversationId,
  //   userId, timestamp }
});

// Start typing indicator
socket.emit('typing:start', {
  channelId: '550e8400-e29b-41d4-a716-446655440000',
  userId: 'usr_8f3a2b1c-...',
  userName: 'Sam'
});

// Stop typing indicator
socket.emit('typing:stop', {
  channelId: '550e8400-e29b-41d4-a716-446655440000',
  userId: 'usr_8f3a2b1c-...',
  userName: 'Sam'
});

// Listen for others typing
socket.on('typing:start', (data) => {
  console.log(data.userName, 'is typing in', data.channelId);
  // { channelId, conversationId, userId, userName, timestamp }
});

socket.on('typing:stop', (data) => {
  console.log(data.userName, 'stopped typing');
  // { channelId, conversationId, userId, userName, timestamp }
});

// Join a channel room to receive its events.
// history: true also asks for its recent messages (channel:history below).
// Leave it out and no history is sent.
socket.emit('channel:join', { channelId: '550e8400-...', history: true }, (response) => {
  console.log('Joined channel:', response);
});

// Server broadcasts join to other members
// Other clients receive:
// { channelId, userId, userName, user: { id, name }, timestamp }

// Sent to the joining client only when its join set history: true
socket.on('channel:history', (data) => {
  console.log('History:', data);
  // { channelId, messages: [...], hasMore, total }
  // Last 50 messages by default
});

// Leave a channel room
socket.emit('channel:leave', { channelId: '550e8400-...' }, (response) => {
  console.log('Left channel:', response);
});

// Listen for channel metadata updates
socket.on('channel:update', (data) => {
  console.log('Channel updated:', data);
  // { channelId, updates, channel, updatedBy, updatedByName, timestamp }
});

// Keep this connection counted (every 30 s; it lapses after 60 s)
socket.emit('presence:heartbeat');

// Say whether this tab is in use: 'idle' after 10 minutes without input
// or 30 s hidden, 'active' again on input. Send it on every connect too.
socket.emit('presence:activity', { state: 'active' });

// Everyone in a workspace you are a member of, now
socket.emit('presence:subscribe', { workspaceId }, (answer) => {
  // { success: true, workspaceId, members: [{ userId, status, inCall, rev, displayName, avatarUrl }] }
  // or { success: false, error: 'NOT_A_MEMBER' | 'INVALID_WORKSPACE' | 'RATE_LIMITED' | 'UNAVAILABLE' }
});

// Changes, from the members of your workspaces
socket.on('presence:update', (data) => {
  // { userId, userName, status: 'online' | 'away' | 'offline', inCall, rev, timestamp }
  // Keep the highest rev per person; a snapshot replaces what you had before asking.
});
socket.on('presence:joined', ({ workspaceId, member }) => {});
socket.on('presence:left', ({ workspaceId, userId }) => {});

// Join a multi-tenant conversation
socket.emit('conversation:join', {
  conversationId: 'conv_a1b2c3d4-...',
  customerId: 'cust_e5f6a7b8-...'
});

// Confirmation sent to sender
socket.on('room:joined', (data) => {
  console.log('Joined room:', data);
  // { room, conversationId, customerId, timestamp }
});

// Other members in the room see:
// member:joined -> { conversationId, userId, userName, timestamp }

// Leave a conversation
socket.emit('conversation:leave', {
  conversationId: 'conv_a1b2c3d4-...',
  customerId: 'cust_e5f6a7b8-...'
});

// Rejoin after disconnect (get missed messages)
socket.emit('conversation:rejoin', {
  conversationId: 'conv_a1b2c3d4-...',
  customerId: 'cust_e5f6a7b8-...',
  lastMessageId: 'msg_f7e6d5c4-...',       // Optional
  lastMessageTimestamp: '2026-03-19T12:00Z' // Optional
});

socket.on('conversation:rejoined', (data) => {
  console.log('Missed messages:', data.missed_messages);
  // { conversationId, customerId, missed_messages: [], timestamp }
});

// Join a call room
socket.emit('call:join', { roomName: 'call_engineering_standup' });

socket.on('call:joined', (data) => {
  console.log('Joined call:', data);
  // { roomName, timestamp }
});

// Others in the call receive:
// call:participant_joined -> { roomName, userId, userName, timestamp }

// Send live transcription segments
socket.emit('call:transcription', {
  roomName: 'call_engineering_standup',
  segment: {
    speaker: 'Sam',
    text: 'Let us review the sprint backlog.',
    isFinal: true,
    confidence: 0.97
  }
});

// Receive transcription segments from others
socket.on('transcription:segment', (segment) => {
  console.log(segment.speaker + ':', segment.text);
  // { speaker, text, isFinal, timestamp, confidence }
});

// Leave the call
socket.emit('call:leave', { roomName: 'call_engineering_standup' });

// Others receive:
// call:participant_left -> { roomName, userId, userName, reason, timestamp }

// Subscribe to a swarm session's updates
socket.emit('swarm:subscribe', {
  sessionId: 'swarm_9a8b7c6d-...'
});

socket.on('swarm:subscribed', (data) => {
  console.log('Subscribed to swarm:', data.sessionId);
  // { sessionId }
});

// Unsubscribe when done
socket.emit('swarm:unsubscribe', {
  sessionId: 'swarm_9a8b7c6d-...'
});

// Join an activity feed room for your workspace
socket.emit('activity:join', {
  room: 'activity:cust_e5f6a7b8-...'
});

socket.on('activity:joined', (data) => {
  console.log('Joined activity feed:', data.room);
  // { room }
});

// Leave the activity feed
socket.emit('activity:leave', {
  room: 'activity:cust_e5f6a7b8-...'
});

// OODA loop phase events are emitted during streaming execution
// Subscribe by joining the user room (automatic on connection)

socket.on('ooda:phase', (data) => {
  console.log('OODA phase:', data.phase, data.data.status);
  // { phase: 'observe'|'orient'|'decide'|'act',
  //   iteration: 0, data: { status: 'started'|'completed', result? },
  //   timestamp }
});

socket.on('ooda:complete', (data) => {
  console.log('OODA complete:', data);
  // { goalMet: boolean, iterations: number,
  //   killed: boolean, timestamp }
});

// Tool permission events for agentic harness approval flows
socket.on('tool:permission:request', (data) => {
  console.log('Tool needs approval:', data.toolName);
  // { requestId, toolName, input, reason, summary?,
  //   channelId?, conversationId?,
  //   createdAt, expiresAt, timeoutMs, remainingMs }
  // channelId and conversationId: the conversation Tron was asked in, when there is one.
  // remainingMs is measured by the server: count down from it.
  // The same request can be announced more than once: keep one per requestId.

  // Respond with approval or denial. The acknowledgement says what the answer did.
  socket.emit('tool:permission:response', {
    requestId: data.requestId,
    approved: true
  }, (ack) => {
    // { requestId, ok: true, status: 'approved' | 'denied' }
    // { requestId, ok: false, code: 'expired' | 'already_answered', status }
    // { requestId, ok: false, code: 'relayed' | 'not_found' | 'invalid' }
  });
});

// How a request ended, sent to every connection of the user
socket.on('tool:permission:resolved', (data) => {
  // { requestId, toolName, status: 'approved' | 'denied' | 'expired', resolvedAt }
});