@drok/agent-hub-sdk 1.0.0

package/README.md

@@ -0,0 +1,207 @@
+# @agent-hub/sdk
+
+Agent Hub 官方 SDK，用于快速接入 Agent Hub 协作平台。
+
+## 安装
+
+```bash
+npm install @agent-hub/sdk
+```
+
+## 快速开始
+
+### 1. 初始化客户端
+
+```typescript
+import { AgentClient } from '@agent-hub/sdk';
+
+const client = new AgentClient({
+  server: 'http://localhost:3000',
+  token: 'your-jwt-token',
+  name: 'my-agent',
+  capabilities: ['code-review', 'testing'],
+  reconnect: true,              // 自动重连
+  heartbeatInterval: 30000,     // 心跳间隔（毫秒）
+});
+
+// 连接
+await client.connect();
+console.log('Connected to Agent Hub!');
+```
+
+### 2. 监听事件
+
+```typescript
+// 监听任务分配
+client.on('task:assigned', async (task) => {
+  console.log(`收到任务：${task.title}`);
+  
+  // 执行任务
+  const result = await processTask(task);
+  
+  // 上报结果
+  await client.completeTask(task.id, result);
+});
+
+// 监听消息
+client.on('message', (msg) => {
+  console.log(`收到来自 ${msg.from} 的消息:`, msg.content);
+});
+
+// 监听 Agent 上下线
+client.on('agent:online', (agent) => {
+  console.log(`Agent 上线：${agent.name}`);
+});
+
+client.on('agent:offline', (agentId) => {
+  console.log(`Agent 离线：${agentId}`);
+});
+
+// 监听错误
+client.on('error', (err) => {
+  console.error('Error:', err);
+});
+```
+
+### 3. 发送消息
+
+```typescript
+// 点对点消息
+await client.send('target-agent-id', {
+  type: 'text',
+  content: 'Hello!',
+});
+
+// 广播消息
+await client.broadcast('general', {
+  type: 'text',
+  content: '大家好，我是新上线的 Agent',
+});
+
+// 订阅频道
+await client.subscribe('code-review');
+await client.unsubscribe('code-review');
+```
+
+### 4. 任务管理
+
+```typescript
+// 查询任务列表
+const tasks = await client.listTasks({
+  status: 'pending',
+  limit: 10,
+});
+
+// 完成任务
+await client.completeTask(taskId, {
+  score: 95,
+  issues: [],
+});
+
+// 报告失败
+await client.failTask(taskId, 'Timeout connecting to repo');
+```
+
+### 5. 共享状态
+
+```typescript
+// 读取状态
+const config = await client.getState('review-config');
+
+// 写入状态
+await client.setState('current-sprint', {
+  name: 'Sprint 42',
+  goal: 'Ship auth module',
+});
+```
+
+### 6. 查询 Agent
+
+```typescript
+// 获取所有 Agent 列表
+const agents = await client.listAgents();
+console.log(`当前有 ${agents.length} 个 Agent 在线`);
+```
+
+### 7. 断开连接
+
+```typescript
+// 手动断开（不会自动重连）
+await client.disconnect();
+```
+
+## API 参考
+
+### AgentClient 构造函数
+
+```typescript
+new AgentClient(config: AgentConfig)
+```
+
+**AgentConfig**:
+- `server` (string): Agent Hub 服务器地址（如 `http://localhost:3000`）
+- `token` (string): JWT token（注册 Agent 时获取）
+- `name` (string, optional): Agent 名称
+- `capabilities` (string[], optional): 能力标签列表
+- `reconnect` (boolean, optional): 是否自动重连，默认 `true`
+- `heartbeatInterval` (number, optional): 心跳间隔（毫秒），默认 `30000`
+
+### 方法
+
+#### 连接管理
+- `connect(): Promise<void>` - 建立连接
+- `disconnect(): Promise<void>` - 断开连接
+
+#### 消息
+- `send(to: string, message: { channel?, type?, content: any }): Promise<void>` - 发送点对点消息
+- `broadcast(channel: string, message: { type?, content: any }): Promise<void>` - 广播消息
+- `subscribe(channel: string): Promise<void>` - 订阅频道
+- `unsubscribe(channel: string): Promise<void>` - 取消订阅
+
+#### 任务
+- `completeTask(taskId: string, result: any): Promise<void>` - 完成任务
+- `failTask(taskId: string, error: string): Promise<void>` - 报告失败
+- `listTasks(filters?): Promise<Task[]>` - 查询任务列表
+
+#### 共享状态
+- `getState(key: string): Promise<any>` - 读取共享状态
+- `setState(key: string, value: any): Promise<void>` - 写入共享状态
+
+#### 查询
+- `listAgents(): Promise<Agent[]>` - 获取所有 Agent 列表
+
+### 事件
+
+- `connected` - 连接成功
+- `disconnected(reason: string)` - 断开连接
+- `task:assigned(task: Task)` - 被分配任务
+- `task:cancelled(taskId: string)` - 任务被取消
+- `message(msg: Message)` - 收到消息
+- `agent:online(agent: Agent)` - Agent 上线
+- `agent:offline(agentId: string)` - Agent 离线
+- `state:changed(change: StateChange)` - 共享状态变更
+- `error(err: Error)` - 发生错误
+
+## 自动重连
+
+SDK 内置自动重连机制，断线后会自动重连，重连间隔采用指数退避策略：
+
+```
+1s → 2s → 4s → 8s → 16s → 30s（最大）
+```
+
+重连成功后会自动恢复心跳和事件监听。
+
+## 错误处理
+
+建议始终监听 `error` 事件：
+
+```typescript
+client.on('error', (err) => {
+  console.error('SDK error:', err);
+});
+```
+
+## 许可证
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,46 @@
+import { EventEmitter } from 'events';
+import { AgentConfig, Agent, Task, Events } from './types';
+export declare class AgentClient extends EventEmitter {
+    private config;
+    private ws;
+    private connected;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private reconnectAttempts;
+    private manualDisconnect;
+    constructor(config: AgentConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    send(to: string, message: {
+        channel?: string;
+        type?: string;
+        content: any;
+    }): Promise<void>;
+    broadcast(channel: string, message: {
+        type?: string;
+        content: any;
+    }): Promise<void>;
+    subscribe(channel: string): Promise<void>;
+    unsubscribe(channel: string): Promise<void>;
+    completeTask(taskId: string, result: any): Promise<void>;
+    failTask(taskId: string, error: string): Promise<void>;
+    private updateTask;
+    getState(key: string): Promise<any>;
+    setState(key: string, value: any): Promise<void>;
+    listAgents(): Promise<Agent[]>;
+    listTasks(filters?: {
+        status?: string;
+        assignedTo?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<Task[]>;
+    private handleMessage;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private scheduleReconnect;
+    private stopReconnect;
+    private generateId;
+    private httpGet;
+    private httpPut;
+    on<Event extends keyof Events>(event: Event, handler: Events[Event]): this;
+}

package/dist/client.js

@@ -0,0 +1,294 @@
+import { EventEmitter } from 'events';
+import WebSocket from 'ws';
+export class AgentClient extends EventEmitter {
+    config;
+    ws = null;
+    connected = false;
+    reconnectTimer = null;
+    heartbeatTimer = null;
+    reconnectAttempts = 0;
+    manualDisconnect = false;
+    constructor(config) {
+        super();
+        this.config = {
+            server: config.server,
+            token: config.token,
+            name: config.name || '',
+            capabilities: config.capabilities || [],
+            reconnect: config.reconnect !== false,
+            heartbeatInterval: config.heartbeatInterval || 30000,
+        };
+    }
+    async connect() {
+        if (this.connected) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                const url = `${this.config.server.replace('http', 'ws')}/ws?token=${this.config.token}`;
+                this.ws = new WebSocket(url);
+                this.ws.on('open', () => {
+                    this.connected = true;
+                    this.reconnectAttempts = 0;
+                    this.manualDisconnect = false;
+                    this.startHeartbeat();
+                    this.emit('connected');
+                    resolve();
+                });
+                this.ws.on('message', (data) => {
+                    try {
+                        const msg = JSON.parse(data.toString());
+                        this.handleMessage(msg);
+                    }
+                    catch (err) {
+                        this.emit('error', new Error(`Failed to parse message: ${err}`));
+                    }
+                });
+                this.ws.on('close', (code, reason) => {
+                    this.connected = false;
+                    this.stopHeartbeat();
+                    if (!this.manualDisconnect && this.config.reconnect) {
+                        this.scheduleReconnect();
+                    }
+                    else {
+                        this.emit('disconnected', reason.toString());
+                    }
+                });
+                this.ws.on('error', (err) => {
+                    this.emit('error', err);
+                    if (!this.connected) {
+                        reject(err);
+                    }
+                });
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    async disconnect() {
+        this.manualDisconnect = true;
+        this.stopReconnect();
+        this.stopHeartbeat();
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.connected = false;
+    }
+    async send(to, message) {
+        if (!this.ws || !this.connected) {
+            throw new Error('Not connected');
+        }
+        this.ws.send(JSON.stringify({
+            type: 'send',
+            id: this.generateId(),
+            timestamp: Date.now(),
+            payload: {
+                to,
+                channel: message.channel || 'direct',
+                type: message.type || 'text',
+                content: message.content,
+            },
+        }));
+    }
+    async broadcast(channel, message) {
+        if (!this.ws || !this.connected) {
+            throw new Error('Not connected');
+        }
+        this.ws.send(JSON.stringify({
+            type: 'broadcast',
+            id: this.generateId(),
+            timestamp: Date.now(),
+            payload: {
+                channel,
+                type: message.type || 'text',
+                content: message.content,
+            },
+        }));
+    }
+    async subscribe(channel) {
+        if (!this.ws || !this.connected) {
+            throw new Error('Not connected');
+        }
+        this.ws.send(JSON.stringify({
+            type: 'subscribe',
+            id: this.generateId(),
+            timestamp: Date.now(),
+            payload: { channel },
+        }));
+    }
+    async unsubscribe(channel) {
+        if (!this.ws || !this.connected) {
+            throw new Error('Not connected');
+        }
+        this.ws.send(JSON.stringify({
+            type: 'unsubscribe',
+            id: this.generateId(),
+            timestamp: Date.now(),
+            payload: { channel },
+        }));
+    }
+    async completeTask(taskId, result) {
+        await this.updateTask(taskId, 'completed', result);
+    }
+    async failTask(taskId, error) {
+        await this.updateTask(taskId, 'failed', undefined, error);
+    }
+    async updateTask(taskId, status, result, error) {
+        if (!this.ws || !this.connected) {
+            throw new Error('Not connected');
+        }
+        this.ws.send(JSON.stringify({
+            type: 'task_update',
+            id: this.generateId(),
+            timestamp: Date.now(),
+            payload: {
+                taskId,
+                status,
+                result,
+                error,
+            },
+        }));
+    }
+    async getState(key) {
+        const response = await this.httpGet(`/api/v1/state/${key}`);
+        return response.data;
+    }
+    async setState(key, value) {
+        await this.httpPut(`/api/v1/state/${key}`, { value });
+    }
+    async listAgents() {
+        const response = await this.httpGet('/api/v1/agents');
+        return response.data;
+    }
+    async listTasks(filters) {
+        const params = new URLSearchParams();
+        if (filters?.status)
+            params.append('status', filters.status);
+        if (filters?.assignedTo)
+            params.append('assignedTo', filters.assignedTo);
+        if (filters?.limit)
+            params.append('limit', filters.limit.toString());
+        if (filters?.offset)
+            params.append('offset', filters.offset.toString());
+        const query = params.toString();
+        const response = await this.httpGet(`/api/v1/tasks${query ? `?${query}` : ''}`);
+        return response.data;
+    }
+    handleMessage(msg) {
+        const { type, payload } = msg;
+        switch (type) {
+            case 'heartbeat_ack':
+                // Heartbeat acknowledged
+                break;
+            case 'task_assigned':
+                this.emit('task:assigned', payload.task);
+                break;
+            case 'task_cancelled':
+                this.emit('task:cancelled', payload.taskId);
+                break;
+            case 'message':
+                this.emit('message', {
+                    id: payload.id,
+                    from: payload.from,
+                    channel: payload.channel,
+                    type: payload.type,
+                    content: payload.content,
+                    timestamp: payload.timestamp,
+                });
+                break;
+            case 'agent_online':
+                this.emit('agent:online', {
+                    id: payload.agentId,
+                    name: payload.name,
+                    status: 'online',
+                    capabilities: [],
+                });
+                break;
+            case 'agent_offline':
+                this.emit('agent:offline', payload.agentId);
+                break;
+            case 'state_changed':
+                this.emit('state:changed', {
+                    key: payload.key,
+                    value: payload.value,
+                    updatedBy: payload.updatedBy,
+                });
+                break;
+            case 'error':
+                this.emit('error', new Error(payload.message));
+                break;
+        }
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (this.ws && this.connected) {
+                this.ws.send(JSON.stringify({
+                    type: 'heartbeat',
+                    id: this.generateId(),
+                    timestamp: Date.now(),
+                    payload: {},
+                }));
+            }
+        }, this.config.heartbeatInterval);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    scheduleReconnect() {
+        this.stopReconnect();
+        const delays = [1000, 2000, 4000, 8000, 16000, 30000];
+        const delay = delays[Math.min(this.reconnectAttempts, delays.length - 1)];
+        this.reconnectAttempts++;
+        this.reconnectTimer = setTimeout(() => {
+            this.connect().catch(() => {
+                // Reconnect will be rescheduled
+            });
+        }, delay);
+    }
+    stopReconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    generateId() {
+        return `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    async httpGet(path) {
+        const url = `${this.config.server}${path}`;
+        const response = await fetch(url, {
+            headers: {
+                'Authorization': `Bearer ${this.config.token}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async httpPut(path, body) {
+        const url = `${this.config.server}${path}`;
+        const response = await fetch(url, {
+            method: 'PUT',
+            headers: {
+                'Authorization': `Bearer ${this.config.token}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+    }
+    on(event, handler) {
+        super.on(event, handler);
+        return this;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { AgentClient } from './client';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { AgentClient } from './client';
+export * from './types';

package/dist/types.d.ts

@@ -0,0 +1,56 @@
+export interface AgentConfig {
+    server: string;
+    token: string;
+    name?: string;
+    capabilities?: string[];
+    reconnect?: boolean;
+    heartbeatInterval?: number;
+}
+export interface Agent {
+    id: string;
+    name: string;
+    status: 'online' | 'offline' | 'busy';
+    capabilities: string[];
+    lastSeen?: number;
+}
+export interface Task {
+    id: string;
+    title: string;
+    description?: string;
+    status: 'pending' | 'assigned' | 'running' | 'completed' | 'failed' | 'cancelled';
+    priority: number;
+    createdBy: string;
+    assignedTo?: string;
+    payload?: any;
+    result?: any;
+    error?: string;
+    timeoutMs?: number;
+    createdAt: number;
+    startedAt?: number;
+    completedAt?: number;
+}
+export interface Message {
+    id: string;
+    from: string;
+    channel: string;
+    type: string;
+    content: any;
+    timestamp: number;
+}
+export interface StateChange {
+    key: string;
+    value: any;
+    updatedBy: string;
+}
+export type EventHandler<T = any> = (data: T) => void;
+export interface Events {
+    connected: () => void;
+    disconnected: (reason: string) => void;
+    'task:assigned': (task: Task) => void;
+    'task:cancelled': (taskId: string) => void;
+    message: (msg: Message) => void;
+    'agent:online': (agent: Agent) => void;
+    'agent:offline': (agentId: string) => void;
+    'state:changed': (change: StateChange) => void;
+    error: (err: Error) => void;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@drok/agent-hub-sdk",
+  "version": "1.0.0",
+  "description": "Agent SDK for Agent Hub",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "keywords": ["agent", "hub", "sdk"],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "ws": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/src/client.ts

@@ -0,0 +1,340 @@
+import { EventEmitter } from 'events';
+import WebSocket from 'ws';
+import { AgentConfig, Agent, Task, Message, StateChange, Events } from './types';
+
+export class AgentClient extends EventEmitter {
+  private config: Required<AgentConfig>;
+  private ws: WebSocket | null = null;
+  private connected = false;
+  private reconnectTimer: NodeJS.Timeout | null = null;
+  private heartbeatTimer: NodeJS.Timeout | null = null;
+  private reconnectAttempts = 0;
+  private manualDisconnect = false;
+
+  constructor(config: AgentConfig) {
+    super();
+    this.config = {
+      server: config.server,
+      token: config.token,
+      name: config.name || '',
+      capabilities: config.capabilities || [],
+      reconnect: config.reconnect !== false,
+      heartbeatInterval: config.heartbeatInterval || 30000,
+    };
+  }
+
+  async connect(): Promise<void> {
+    if (this.connected) {
+      return;
+    }
+
+    return new Promise((resolve, reject) => {
+      try {
+        const url = `${this.config.server.replace('http', 'ws')}/ws?token=${this.config.token}`;
+        this.ws = new WebSocket(url);
+
+        this.ws.on('open', () => {
+          this.connected = true;
+          this.reconnectAttempts = 0;
+          this.manualDisconnect = false;
+          this.startHeartbeat();
+          this.emit('connected');
+          resolve();
+        });
+
+        this.ws.on('message', (data) => {
+          try {
+            const msg = JSON.parse(data.toString());
+            this.handleMessage(msg);
+          } catch (err) {
+            this.emit('error', new Error(`Failed to parse message: ${err}`));
+          }
+        });
+
+        this.ws.on('close', (code, reason) => {
+          this.connected = false;
+          this.stopHeartbeat();
+          
+          if (!this.manualDisconnect && this.config.reconnect) {
+            this.scheduleReconnect();
+          } else {
+            this.emit('disconnected', reason.toString());
+          }
+        });
+
+        this.ws.on('error', (err) => {
+          this.emit('error', err);
+          if (!this.connected) {
+            reject(err);
+          }
+        });
+
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  async disconnect(): Promise<void> {
+    this.manualDisconnect = true;
+    this.stopReconnect();
+    this.stopHeartbeat();
+    
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.connected = false;
+  }
+
+  async send(to: string, message: { channel?: string; type?: string; content: any }): Promise<void> {
+    if (!this.ws || !this.connected) {
+      throw new Error('Not connected');
+    }
+
+    this.ws.send(JSON.stringify({
+      type: 'send',
+      id: this.generateId(),
+      timestamp: Date.now(),
+      payload: {
+        to,
+        channel: message.channel || 'direct',
+        type: message.type || 'text',
+        content: message.content,
+      },
+    }));
+  }
+
+  async broadcast(channel: string, message: { type?: string; content: any }): Promise<void> {
+    if (!this.ws || !this.connected) {
+      throw new Error('Not connected');
+    }
+
+    this.ws.send(JSON.stringify({
+      type: 'broadcast',
+      id: this.generateId(),
+      timestamp: Date.now(),
+      payload: {
+        channel,
+        type: message.type || 'text',
+        content: message.content,
+      },
+    }));
+  }
+
+  async subscribe(channel: string): Promise<void> {
+    if (!this.ws || !this.connected) {
+      throw new Error('Not connected');
+    }
+
+    this.ws.send(JSON.stringify({
+      type: 'subscribe',
+      id: this.generateId(),
+      timestamp: Date.now(),
+      payload: { channel },
+    }));
+  }
+
+  async unsubscribe(channel: string): Promise<void> {
+    if (!this.ws || !this.connected) {
+      throw new Error('Not connected');
+    }
+
+    this.ws.send(JSON.stringify({
+      type: 'unsubscribe',
+      id: this.generateId(),
+      timestamp: Date.now(),
+      payload: { channel },
+    }));
+  }
+
+  async completeTask(taskId: string, result: any): Promise<void> {
+    await this.updateTask(taskId, 'completed', result);
+  }
+
+  async failTask(taskId: string, error: string): Promise<void> {
+    await this.updateTask(taskId, 'failed', undefined, error);
+  }
+
+  private async updateTask(taskId: string, status: string, result?: any, error?: string): Promise<void> {
+    if (!this.ws || !this.connected) {
+      throw new Error('Not connected');
+    }
+
+    this.ws.send(JSON.stringify({
+      type: 'task_update',
+      id: this.generateId(),
+      timestamp: Date.now(),
+      payload: {
+        taskId,
+        status,
+        result,
+        error,
+      },
+    }));
+  }
+
+  async getState(key: string): Promise<any> {
+    const response = await this.httpGet(`/api/v1/state/${key}`);
+    return response.data;
+  }
+
+  async setState(key: string, value: any): Promise<void> {
+    await this.httpPut(`/api/v1/state/${key}`, { value });
+  }
+
+  async listAgents(): Promise<Agent[]> {
+    const response = await this.httpGet('/api/v1/agents');
+    return response.data;
+  }
+
+  async listTasks(filters?: { status?: string; assignedTo?: string; limit?: number; offset?: number }): Promise<Task[]> {
+    const params = new URLSearchParams();
+    if (filters?.status) params.append('status', filters.status);
+    if (filters?.assignedTo) params.append('assignedTo', filters.assignedTo);
+    if (filters?.limit) params.append('limit', filters.limit.toString());
+    if (filters?.offset) params.append('offset', filters.offset.toString());
+
+    const query = params.toString();
+    const response = await this.httpGet(`/api/v1/tasks${query ? `?${query}` : ''}`);
+    return response.data;
+  }
+
+  private handleMessage(msg: any) {
+    const { type, payload } = msg;
+
+    switch (type) {
+      case 'heartbeat_ack':
+        // Heartbeat acknowledged
+        break;
+
+      case 'task_assigned':
+        this.emit('task:assigned', payload.task);
+        break;
+
+      case 'task_cancelled':
+        this.emit('task:cancelled', payload.taskId);
+        break;
+
+      case 'message':
+        this.emit('message', {
+          id: payload.id,
+          from: payload.from,
+          channel: payload.channel,
+          type: payload.type,
+          content: payload.content,
+          timestamp: payload.timestamp,
+        });
+        break;
+
+      case 'agent_online':
+        this.emit('agent:online', {
+          id: payload.agentId,
+          name: payload.name,
+          status: 'online',
+          capabilities: [],
+        });
+        break;
+
+      case 'agent_offline':
+        this.emit('agent:offline', payload.agentId);
+        break;
+
+      case 'state_changed':
+        this.emit('state:changed', {
+          key: payload.key,
+          value: payload.value,
+          updatedBy: payload.updatedBy,
+        });
+        break;
+
+      case 'error':
+        this.emit('error', new Error(payload.message));
+        break;
+    }
+  }
+
+  private startHeartbeat() {
+    this.stopHeartbeat();
+    
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws && this.connected) {
+        this.ws.send(JSON.stringify({
+          type: 'heartbeat',
+          id: this.generateId(),
+          timestamp: Date.now(),
+          payload: {},
+        }));
+      }
+    }, this.config.heartbeatInterval);
+  }
+
+  private stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  private scheduleReconnect() {
+    this.stopReconnect();
+    
+    const delays = [1000, 2000, 4000, 8000, 16000, 30000];
+    const delay = delays[Math.min(this.reconnectAttempts, delays.length - 1)];
+    this.reconnectAttempts++;
+
+    this.reconnectTimer = setTimeout(() => {
+      this.connect().catch(() => {
+        // Reconnect will be rescheduled
+      });
+    }, delay);
+  }
+
+  private stopReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+
+  private generateId(): string {
+    return `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  private async httpGet(path: string): Promise<any> {
+    const url = `${this.config.server}${path}`;
+    const response = await fetch(url, {
+      headers: {
+        'Authorization': `Bearer ${this.config.token}`,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+
+    return response.json();
+  }
+
+  private async httpPut(path: string, body: any): Promise<void> {
+    const url = `${this.config.server}${path}`;
+    const response = await fetch(url, {
+      method: 'PUT',
+      headers: {
+        'Authorization': `Bearer ${this.config.token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+  }
+
+  on<Event extends keyof Events>(event: Event, handler: Events[Event]): this {
+    super.on(event, handler as any);
+    return this;
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { AgentClient } from './client';
+export * from './types';

package/src/types.ts

@@ -0,0 +1,62 @@
+export interface AgentConfig {
+  server: string;
+  token: string;
+  name?: string;
+  capabilities?: string[];
+  reconnect?: boolean;
+  heartbeatInterval?: number;
+}
+
+export interface Agent {
+  id: string;
+  name: string;
+  status: 'online' | 'offline' | 'busy';
+  capabilities: string[];
+  lastSeen?: number;
+}
+
+export interface Task {
+  id: string;
+  title: string;
+  description?: string;
+  status: 'pending' | 'assigned' | 'running' | 'completed' | 'failed' | 'cancelled';
+  priority: number;
+  createdBy: string;
+  assignedTo?: string;
+  payload?: any;
+  result?: any;
+  error?: string;
+  timeoutMs?: number;
+  createdAt: number;
+  startedAt?: number;
+  completedAt?: number;
+}
+
+export interface Message {
+  id: string;
+  from: string;
+  channel: string;
+  type: string;
+  content: any;
+  timestamp: number;
+}
+
+export interface StateChange {
+  key: string;
+  value: any;
+  updatedBy: string;
+}
+
+export type EventHandler<T = any> = (data: T) => void;
+
+export interface Events {
+  connected: () => void;
+  disconnected: (reason: string) => void;
+  'task:assigned': (task: Task) => void;
+  'task:cancelled': (taskId: string) => void;
+  message: (msg: Message) => void;
+  'agent:online': (agent: Agent) => void;
+  'agent:offline': (agentId: string) => void;
+  'state:changed': (change: StateChange) => void;
+  error: (err: Error) => void;
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022"],
+    "moduleResolution": "node",
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}