Skip to main content

​
Response

Sent by the framework to confirm that a worker has successfully registered and is ready to communicate. This message is typically sent after the worker establishes a WebSocket connection.
​
type
string
required
Message type. Must be "workerregistered".
​
worker_id
string
required
Unique identifier assigned to this worker by the framework.

​
Examples

​
Basic Worker Registration Confirmation

{
  "type": "workerregistered",
  "worker_id": "worker_a1b2c3d4e5f6"
}

​
UUID-Based Worker ID

{
  "type": "workerregistered",
  "worker_id": "550e8400-e29b-41d4-a716-446655440000"
}

​
Connection Flow

Typical sequence when a worker connects: 
// 1. Worker establishes WebSocket connection
const ws = new WebSocket('ws://localhost:3000');

// 2. Worker waits for WorkerRegistered message
ws.on('message', (data) => {
  const msg = JSON.parse(data);
  
  if (msg.type === 'workerregistered') {
    console.log(`Worker registered with ID: ${msg.worker_id}`);
    
    // 3. Worker can now register services, functions, and triggers
    ws.send(JSON.stringify({
      type: 'registerservice',
      id: 'my_service',
      name: 'My Service'
    }));
  }
});

​
Handling Registration

​
Store Worker ID

let workerId = null;

ws.on('message', (data) => {
  const msg = JSON.parse(data);
  
  if (msg.type === 'workerregistered') {
    workerId = msg.worker_id;
    console.log('Worker ID:', workerId);
    
    // Proceed with initialization
    initializeWorker();
  }
});

​
Registration with Retry

function connectWorker() {
  const ws = new WebSocket('ws://localhost:3000');
  
  const registrationTimeout = setTimeout(() => {
    console.error('Worker registration timeout');
    ws.close();
    // Retry connection
    setTimeout(connectWorker, 5000);
  }, 10000);
  
  ws.on('message', (data) => {
    const msg = JSON.parse(data);
    
    if (msg.type === 'workerregistered') {
      clearTimeout(registrationTimeout);
      console.log('Worker registered:', msg.worker_id);
    }
  });
}

​
Registration Event Handler

class WorkerClient {
  constructor() {
    this.workerId = null;
    this.registered = false;
  }
  
  connect() {
    this.ws = new WebSocket('ws://localhost:3000');
    
    this.ws.on('message', (data) => {
      const msg = JSON.parse(data);
      this.handleMessage(msg);
    });
  }
  
  handleMessage(msg) {
    switch (msg.type) {
      case 'workerregistered':
        this.onWorkerRegistered(msg.worker_id);
        break;
      // Handle other message types...
    }
  }
  
  onWorkerRegistered(workerId) {
    this.workerId = workerId;
    this.registered = true;
    console.log(`Worker registered: ${workerId}`);
    
    // Emit event for application code
    this.emit('registered', workerId);
  }
}

​
Error Cases

​
Registration Timeout

If a WorkerRegistered message is not received within a reasonable timeout (typically 10-30 seconds):
  • The connection may have failed during handshake
  • The framework may be unresponsive or overloaded
  • Network issues may be preventing communication
  • Consider closing the connection and retrying

​
Connection Closed Before Registration

If the WebSocket connection closes before receiving WorkerRegistered:
  • The framework may have rejected the connection
  • Authentication or authorization may have failed
  • The framework may be shutting down
  • Check framework logs for rejection reasons

​
Notes

  • WorkerRegistered is typically the first message received after connecting
  • The worker should not send registration messages (RegisterService, RegisterFunction, etc.) until receiving WorkerRegistered
  • The worker_id can be used for logging, monitoring, and debugging
  • The worker_id format is determined by the framework implementation
  • Store the worker_id for the duration of the connection
  • On reconnection, a new worker_id will typically be assigned
  • The worker must re-register all services, functions, and triggers after receiving a new WorkerRegistered message

​
Best Practices

  • Wait for confirmation: Don’t send other messages until WorkerRegistered is received
  • Implement timeout: Set a timeout for registration and reconnect if not received
  • Log the worker ID: Include worker_id in all logs for traceability
  • Handle reconnection: Re-register everything when a new worker_id is assigned
  • Emit events: Notify your application code when registration completes
  • Store state: Track registration status to prevent sending messages prematurely

Build docs developers (and LLMs) love

Get started for freeTalk to us