@exagent/agent 0.3.6 → 0.3.7

package/src/prediction/types.ts

@@ -1,151 +0,0 @@
-/**
- * Polymarket Prediction Market Types
- *
- * Core type definitions for prediction market trading via Polymarket CLOB on Polygon.
- * Fills are reported to the command center via WebSocket relay — no on-chain recording.
- */
-
-// ============================================================
-// CONFIG
-// ============================================================
-
-export interface PredictionConfig {
-  enabled: boolean;
-  clobApiUrl: string;
-  gammaApiUrl: string;
-  maxNotionalUSD: number;
-  maxTotalExposureUSD: number;
-  allowedCategories?: string[];
-}
-
-export const DEFAULT_PREDICTION_CONFIG: PredictionConfig = {
-  enabled: false,
-  clobApiUrl: 'https://clob.polymarket.com',
-  gammaApiUrl: 'https://gamma-api.polymarket.com',
-  maxNotionalUSD: 1_000,
-  maxTotalExposureUSD: 5_000,
-};
-
-// ============================================================
-// SIGNALS
-// ============================================================
-
-export type PredictionAction =
-  | 'buy_yes'
-  | 'buy_no'
-  | 'sell_yes'
-  | 'sell_no'
-  | 'hold';
-
-export interface PredictionTradeSignal {
-  action: PredictionAction;
-  marketConditionId: string;
-  marketQuestion: string;
-  outcomeIndex: number;
-  amount: number;
-  limitPrice: number;
-  orderType: 'limit' | 'market';
-  confidence: number;
-  reasoning?: string;
-}
-
-// ============================================================
-// POSITIONS
-// ============================================================
-
-export interface PredictionPosition {
-  marketConditionId: string;
-  marketQuestion: string;
-  outcomeIndex: number;
-  outcomeLabel: string;
-  tokenId: string;
-  balance: number;
-  averageEntryPrice: number;
-  currentPrice: number;
-  unrealizedPnl: number;
-  costBasis: number;
-  endDate?: number;
-  category?: string;
-}
-
-// ============================================================
-// MARKETS
-// ============================================================
-
-export interface PredictionMarket {
-  conditionId: string;
-  question: string;
-  description: string;
-  category: string;
-  outcomes: string[];
-  outcomeTokenIds: string[];
-  outcomePrices: number[];
-  volume24h: number;
-  liquidity: number;
-  endDate: number;
-  active: boolean;
-  resolved: boolean;
-  winningOutcome?: number;
-  resolutionSource?: string;
-  uniqueTraders?: number;
-}
-
-// ============================================================
-// FILLS & ORDER RESULTS
-// ============================================================
-
-export interface PredictionFill {
-  orderId: string;
-  tradeId: string;
-  marketConditionId: string;
-  outcomeIndex: number;
-  side: 'BUY' | 'SELL';
-  price: string;
-  size: string;
-  fee: string;
-  timestamp: number;
-  marketQuestion?: string;
-  isMaker: boolean;
-  tokenId?: string;
-}
-
-export interface PredictionOrderResult {
-  success: boolean;
-  orderId?: string;
-  status: 'filled' | 'partially_filled' | 'resting' | 'cancelled' | 'error';
-  avgPrice?: number;
-  filledSize?: number;
-  error?: string;
-}
-
-// ============================================================
-// ACCOUNT
-// ============================================================
-
-export interface PredictionAccountSummary {
-  totalExposure: number;
-  totalUnrealizedPnl: number;
-  openMarketCount: number;
-  openPositionCount: number;
-}
-
-// ============================================================
-// CONSTANTS
-// ============================================================
-
-export const POLYGON_CHAIN_ID = 137;
-export const PREDICTION_INSTRUMENT_PREFIX = 'POLY:';
-export const PREDICTION_FEE_BPS = 20;
-
-/** Encode a prediction instrument string: POLY:{conditionId}:{outcomeIndex} */
-export function encodePredictionInstrument(conditionId: string, outcomeIndex: number): string {
-  return `${PREDICTION_INSTRUMENT_PREFIX}${conditionId}:${outcomeIndex}`;
-}
-
-/** Decode a POLY: instrument string back to components */
-export function decodePredictionInstrument(instrument: string): { conditionId: string; outcomeIndex: number } | null {
-  if (!instrument.startsWith(PREDICTION_INSTRUMENT_PREFIX)) return null;
-  const parts = instrument.slice(PREDICTION_INSTRUMENT_PREFIX.length).split(':');
-  if (parts.length !== 2) return null;
-  return { conditionId: parts[0], outcomeIndex: parseInt(parts[1], 10) };
-}

package/src/relay.ts

@@ -1,254 +0,0 @@
-import WebSocket from 'ws';
-import type {
-  AgentStatusPayload,
-  AgentToAPIMessage,
-  APIToAgentMessage,
-  RelayCommand,
-  TradeSignal,
-  MessageType,
-  MessageLevel,
-} from '@exagent/sdk';
-import { getLogger } from './logger.js';
-
-export interface RelayClientConfig {
-  url: string;
-  agentId: string;
-  token: string;
-  heartbeatIntervalMs?: number;
-  reconnectMaxAttempts?: number;
-  onCommand?: (command: RelayCommand) => void;
-  onConnected?: () => void;
-  onDisconnected?: () => void;
-  onReconnected?: () => void;
-}
-
-export class RelayClient {
-  private ws: WebSocket | null = null;
-  private config: Required<Omit<RelayClientConfig, 'onCommand' | 'onConnected' | 'onDisconnected' | 'onReconnected'>>;
-  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
-  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
-  private reconnectAttempts = 0;
-  private intentionalClose = false;
-  private authenticated = false;
-  private lastStatus: AgentStatusPayload | null = null;
-  private hasConnectedBefore = false;
-
-  onCommand?: (command: RelayCommand) => void;
-  onConnected?: () => void;
-  onDisconnected?: () => void;
-  onReconnected?: () => void;
-
-  constructor(config: RelayClientConfig) {
-    this.config = {
-      url: config.url,
-      agentId: config.agentId,
-      token: config.token,
-      heartbeatIntervalMs: config.heartbeatIntervalMs ?? 30000,
-      reconnectMaxAttempts: config.reconnectMaxAttempts ?? 50,
-    };
-    this.onCommand = config.onCommand;
-    this.onConnected = config.onConnected;
-    this.onDisconnected = config.onDisconnected;
-    this.onReconnected = config.onReconnected;
-  }
-
-  get isConnected(): boolean {
-    return this.ws?.readyState === WebSocket.OPEN && this.authenticated;
-  }
-
-  async connect(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      try {
-        this.intentionalClose = false;
-        this.ws = new WebSocket(this.config.url);
-
-        const timeout = setTimeout(() => {
-          if (this.ws && this.ws.readyState !== WebSocket.OPEN) {
-            this.ws.terminate();
-            reject(new Error('Connection timeout (15s)'));
-          }
-        }, 15000);
-
-        this.ws.on('open', () => {
-          clearTimeout(timeout);
-          this.reconnectAttempts = 0;
-          this.authenticate();
-        });
-
-        this.ws.on('message', (data: WebSocket.Data) => {
-          try {
-            const msg = JSON.parse(data.toString()) as APIToAgentMessage;
-            this.handleMessage(msg, resolve);
-          } catch {
-            getLogger().error('relay', 'Failed to parse message');
-          }
-        });
-
-        this.ws.on('close', () => {
-          this.cleanup();
-          this.onDisconnected?.();
-          if (!this.intentionalClose) {
-            this.scheduleReconnect();
-          }
-        });
-
-        this.ws.on('error', (err: Error) => {
-          getLogger().error('relay', `WebSocket error: ${err.message}`);
-          if (!this.authenticated) {
-            clearTimeout(timeout);
-            reject(err);
-          }
-        });
-      } catch (err) {
-        reject(err);
-      }
-    });
-  }
-
-  disconnect(): void {
-    this.intentionalClose = true;
-    this.cleanup();
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-
-  private authenticate(): void {
-    this.send({
-      type: 'auth',
-      agentId: this.config.agentId,
-      token: this.config.token,
-    });
-  }
-
-  private handleMessage(msg: APIToAgentMessage, onAuth?: (value: void) => void): void {
-    switch (msg.type) {
-      case 'auth_success':
-        this.authenticated = true;
-        this.startHeartbeat();
-        this.onConnected?.();
-
-        // Emit reconnected event if this is not the first connection
-        if (this.hasConnectedBefore) {
-          this.onReconnected?.();
-        }
-        this.hasConnectedBefore = true;
-
-        onAuth?.();
-        getLogger().info('relay', 'Authenticated', { agentId: this.config.agentId });
-        break;
-
-      case 'auth_error':
-        getLogger().error('relay', `Auth failed: ${msg.error}`);
-        this.disconnect();
-        break;
-
-      case 'command':
-        this.onCommand?.(msg.command);
-        break;
-
-      case 'pong':
-        break;
-    }
-  }
-
-  sendCommandAck(commandId: string, success: boolean, message?: string): void {
-    this.send({
-      type: 'command_ack',
-      agentId: this.config.agentId,
-      commandId,
-      success,
-      message,
-      timestamp: Date.now(),
-    });
-  }
-
-  private send(msg: AgentToAPIMessage | { type: 'auth'; agentId: string; token: string }): void {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(msg));
-    }
-  }
-
-  sendHeartbeat(status: AgentStatusPayload): void {
-    this.lastStatus = status;
-    this.send({
-      type: 'heartbeat',
-      agentId: this.config.agentId,
-      status,
-      timestamp: Date.now(),
-    });
-  }
-
-  sendMessage(
-    messageType: MessageType,
-    level: MessageLevel,
-    title: string,
-    body: string,
-    data?: Record<string, unknown>,
-  ): void {
-    this.send({
-      type: 'message',
-      agentId: this.config.agentId,
-      messageType,
-      level,
-      title,
-      body,
-      data,
-      timestamp: Date.now(),
-    });
-  }
-
-  sendTradeSignal(signal: TradeSignal): void {
-    this.send({
-      type: 'trade_signal',
-      agentId: this.config.agentId,
-      signal,
-      timestamp: Date.now(),
-    });
-  }
-
-  private startHeartbeat(): void {
-    this.stopHeartbeat();
-    this.heartbeatTimer = setInterval(() => {
-      if (this.lastStatus) {
-        this.sendHeartbeat(this.lastStatus);
-      }
-    }, this.config.heartbeatIntervalMs);
-  }
-
-  private stopHeartbeat(): void {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
-    }
-  }
-
-  private cleanup(): void {
-    this.stopHeartbeat();
-    this.authenticated = false;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-  }
-
-  private scheduleReconnect(): void {
-    if (this.reconnectAttempts >= this.config.reconnectMaxAttempts) {
-      getLogger().error('relay', 'Max reconnect attempts reached', { max: this.config.reconnectMaxAttempts });
-      return;
-    }
-
-    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
-    this.reconnectAttempts++;
-    getLogger().info('relay', 'Reconnecting', { delayMs: delay, attempt: this.reconnectAttempts });
-
-    this.reconnectTimer = setTimeout(async () => {
-      try {
-        await this.connect();
-      } catch (err) {
-        getLogger().error('relay', `Reconnect failed: ${(err as Error).message}`);
-      }
-    }, delay);
-  }
-}