Blits.ai API Documentation

const WebSocket = require('ws');

const API_TOKEN = 'your-jwt-token-here';
// Use general endpoint (recommended) or choose a regional endpoint
const WS_URL = 'wss://platform.blits.ai/'; // or eu, us, uae, au

// Connect to WebSocket
const ws = new WebSocket(WS_URL);

ws.on('open', () => {
  console.log('Connected to Blits.ai');
  
  // Initialize conversation
  ws.send(JSON.stringify({
    command: 'initialize',
    authToken: API_TOKEN,
    userId: 'user-123',
    setCurrentLanguageTo: 'en',
    tts: { streaming: false }
  }));
});

ws.on('message', (data) => {
  const response = JSON.parse(data.toString());
  console.log('Received:', response);
  
  if (response.command === 'initialize') {
    console.log('Conversation ID:', response.conversationId);
    
    // Send a message
    ws.send(JSON.stringify({
      command: 'message',
      authToken: API_TOKEN,
      conversationId: response.conversationId,
      message: 'Hello! How are you today?',
      speechResponse: false,
      requestId: 'msg-001'
    }));
  }
  
  if (response.command === 'message') {
    console.log('Bot response:', response.response);
  }
});

ws.on('error', (error) => {
  console.error('WebSocket error:', error);
});

ws.on('close', () => {
  console.log('Disconnected from Blits.ai');
});

import asyncio
import websockets
import json

API_TOKEN = 'your-jwt-token-here'
# Use general endpoint (recommended) or choose a regional endpoint
WS_URL = 'wss://platform.blits.ai/'  # or eu, us, uae, au

async def chat_with_blits():
    async with websockets.connect(WS_URL) as ws:
        print('Connected to Blits.ai')
        
        # Wait for connection acknowledgment
        connect_msg = await ws.recv()
        print('Connection:', json.loads(connect_msg))
        
        # Initialize conversation
        await ws.send(json.dumps({
            'command': 'initialize',
            'authToken': API_TOKEN,
            'userId': 'user-123',
            'setCurrentLanguageTo': 'en'
        }))
        
        init_response = json.loads(await ws.recv())
        print('Initialized:', init_response)
        conversation_id = init_response['conversationId']
        
        # Send a message
        await ws.send(json.dumps({
            'command': 'message',
            'authToken': API_TOKEN,
            'conversationId': conversation_id,
            'message': 'Hello! How are you today?',
            'speechResponse': False,
            'requestId': 'msg-001'
        }))
        
        message_response = json.loads(await ws.recv())
        print('Bot response:', message_response['response'])

# Run the async function
asyncio.run(chat_with_blits())

class BlitsClient {
  constructor(apiToken, endpoint = 'platform.blits.ai') {
    this.apiToken = apiToken;
    this.ws = null;
    this.conversationId = null;
    this.endpoint = endpoint;
  }

  connect() {
    return new Promise((resolve, reject) => {
      // Use general endpoint or regional: eu.platform.blits.ai, us.platform.blits.ai, etc.
      const wsUrl = `wss://${this.endpoint}/`;
      this.ws = new WebSocket(wsUrl);
      
      this.ws.onopen = () => {
        console.log('Connected to Blits.ai');
        resolve();
      };
      
      this.ws.onmessage = (event) => {
        const response = JSON.parse(event.data);
        this.handleMessage(response);
      };
      
      this.ws.onerror = (error) => {
        console.error('WebSocket error:', error);
        reject(error);
      };
    });
  }

  async initialize(userId = 'web-user') {
    return new Promise((resolve) => {
      const initHandler = (response) => {
        if (response.command === 'initialize') {
          this.conversationId = response.conversationId;
          resolve(response);
        }
      };
      
      this.messageHandlers.push(initHandler);
      
      this.ws.send(JSON.stringify({
        command: 'initialize',
        authToken: this.apiToken,
        userId: userId,
        setCurrentLanguageTo: 'en'
      }));
    });
  }

  sendMessage(text, options = {}) {
    return new Promise((resolve) => {
      const messageHandler = (response) => {
        if (response.command === 'message' && 
            response.requestId === options.requestId) {
          resolve(response);
        }
      };
      
      this.messageHandlers.push(messageHandler);
      
      this.ws.send(JSON.stringify({
        command: 'message',
        authToken: this.apiToken,
        conversationId: this.conversationId,
        message: text,
        speechResponse: options.speechResponse || false,
        requestId: options.requestId || Date.now().toString()
      }));
    });
  }

  handleMessage(response) {
    console.log('Received:', response);
    this.messageHandlers.forEach(handler => handler(response));
  }
}

// Usage
// Use general endpoint (recommended) or specify regional endpoint
const client = new BlitsClient('your-jwt-token', 'platform.blits.ai');
// Or use regional: 'eu.platform.blits.ai', 'us.platform.blits.ai', etc.

await client.connect();
await client.initialize('user-123');
const response = await client.sendMessage('Hello!');
console.log('Bot said:', response.response);

// Record audio and send to Blits.ai
async function recordAndSend() {
  // Get microphone access
  const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
  const mediaRecorder = new MediaRecorder(stream);
  const audioChunks = [];
  
  mediaRecorder.ondataavailable = (event) => {
    audioChunks.push(event.data);
  };
  
  mediaRecorder.onstop = async () => {
    // Create blob from chunks
    const audioBlob = new Blob(audioChunks, { type: 'audio/wav' });
    
    // Convert to base64
    const reader = new FileReader();
    reader.readAsDataURL(audioBlob);
    reader.onloadend = () => {
      const base64Audio = reader.result.split(',')[1];
      
      // Send to Blits.ai
      ws.send(JSON.stringify({
        command: 'message',
        authToken: API_TOKEN,
        conversationId: conversationId,
        speechData: base64Audio,
        speechResponse: true,
        requestId: 'voice-msg-001'
      }));
    };
  };
  
  // Start recording
  mediaRecorder.start();
  console.log('Recording...');
  
  // Stop after 5 seconds (or when user stops)
  setTimeout(() => {
    mediaRecorder.stop();
    console.log('Recording stopped');
    stream.getTracks().forEach(track => track.stop());
  }, 5000);
}

// Handle voice response
ws.onmessage = (event) => {
  const response = JSON.parse(event.data);
  
  if (response.command === 'message' && response.speechData) {
    // Play audio response
    const audio = new Audio('data:audio/mp3;base64,' + response.speechData);
    audio.play();
    
    // Also show text
    console.log('Bot said:', response.response);
  }
};