HUMA-0.1 Agent API

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

const API = 'https://api.humalike.tech';
const API_KEY = 'ak_your_api_key';

// 1. Define Agent Class (client-side)
const COACH_ALEX_CLASS = {
  className: 'Coach Alex',
  personality: `You are Coach Alex, an enthusiastic fitness coach.
You're positive, encouraging, and knowledgeable about fitness.`,
  instructions: `Help users with their fitness journey:
- Provide workout advice and motivation
- Answer fitness-related questions
- Use the send_message tool to respond`,
  tools: [
    {
      name: 'send_message',
      description: 'Send a message to the user in the chat',
      parameters: [
        { name: 'message', type: 'string', description: 'Message content', required: true }
      ]
    }
  ]
};

// Track chat history and pending tool calls
const chatHistory = [];
const pendingToolCalls = new Map();

// Helper to send tool results
function sendToolResult(socket, toolCallId, success, result, error, status = 'completed') {
  socket.emit('message', {
    type: 'huma-0.1-event',
    content: { type: 'tool-result', toolCallId, status, success, result, error }
  });
}

// Handle cancel-tool-call events
function handleCancelToolCall(socket, toolCallId, reason) {
  const controller = pendingToolCalls.get(toolCallId);
  if (controller) {
    console.log(`Canceling tool call: ${toolCallId}`);
    controller.abort();
    pendingToolCalls.delete(toolCallId);
    sendToolResult(socket, toolCallId, false, null, reason, 'canceled');
  }
  // If not found, tool already completed - ignore
}

async function main() {
  // 2. Create Agent Instance
  const agent = await fetch(`${API}/api/agents`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json', 'X-API-Key': API_KEY },
    body: JSON.stringify({
      name: 'Coach Alex Instance',
      agentType: 'HUMA-0.1',
      metadata: COACH_ALEX_CLASS
    })
  }).then(r => r.json());

  console.log('Created agent:', agent.id);

  // 3. Connect WebSocket
  const socket = io(API, {
    query: { agentId: agent.id, apiKey: API_KEY },
    transports: ['websocket']
  });

  // 4. Handle Server Events
  socket.on('event', (data) => {
    switch (data.type) {
      case 'status':
        console.log(`Agent status: ${data.status}`);
        break;

      case 'tool-call':
        handleToolCall(socket, data);
        break;

      case 'cancel-tool-call':
        handleCancelToolCall(socket, data.toolCallId, data.reason);
        break;

      case 'error':
        console.error(`Error: ${data.message}`);
        break;
    }
  });

  // 5. Send Initial Event on Connect
  socket.on('connect', () => {
    console.log('Connected to agent');
    sendUserMessage(socket, 'Hey! Ready for today\'s workout!', 'Alice');
  });
}

// Handle tool calls from agent (with cancellation support)
async function handleToolCall(socket, data) {
  if (data.toolName === 'send_message') {
    const message = data.arguments.message;

    // Create abort controller for cancellation support
    const controller = new AbortController();
    pendingToolCalls.set(data.toolCallId, controller);

    // Simulate typing delay (can be canceled by server)
    const typingMs = Math.max(500, message.split(' ').length * 60);
    const completed = await new Promise(resolve => {
      const timeout = setTimeout(() => resolve(true), typingMs);
      controller.signal.addEventListener('abort', () => {
        clearTimeout(timeout);
        resolve(false);
      });
    });

    pendingToolCalls.delete(data.toolCallId);

    if (completed) {
      // Display message in UI
      console.log(`Coach Alex: ${message}`);

      // Add to chat history
      chatHistory.push({
        id: crypto.randomUUID(),
        author: 'Coach Alex',
        content: message,
        timestamp: new Date().toISOString()
      });

      // Send success result
      sendToolResult(socket, data.toolCallId, true, 'Message displayed');
    }
    // If not completed, it was canceled - result already sent
  }
}

// Send user message to agent
function sendUserMessage(socket, content, userName) {
  chatHistory.push({
    id: crypto.randomUUID(),
    author: userName,
    content,
    timestamp: new Date().toISOString()
  });

  socket.emit('message', {
    type: 'huma-0.1-event',
    content: {
      name: 'new-message',
      context: {
        chatHistory: chatHistory.slice(-50),
        user: { name: userName }
      },
      description: `User "${userName}" sent: "${content}"`
    }
  });
}

main();