@exagent/agent 0.3.6 → 0.3.7

package/src/llm/together.ts

@@ -1,48 +0,0 @@
-import { getDefaultModel, type LLMMessage, type LLMResponse, type LLMMetadata, type LLMConfig } from '@exagent/sdk';
-import { BaseLLMAdapter } from './base.js';
-
-export class TogetherAdapter extends BaseLLMAdapter {
-  constructor(config: LLMConfig) {
-    super(config);
-  }
-
-  protected async chatImpl(messages: LLMMessage[]): Promise<LLMResponse> {
-    const res = await this.fetchWithTimeout('https://api.together.xyz/v1/chat/completions', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${this.config.apiKey}`,
-      },
-      body: JSON.stringify({
-        model: this.config.model || getDefaultModel('together'),
-        messages: messages.map(m => ({ role: m.role, content: m.content })),
-        temperature: this.getTemperature(),
-        max_tokens: this.getMaxTokens(),
-      }),
-    });
-
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`Together API error ${res.status}: ${body}`);
-    }
-
-    const data = await res.json() as {
-      choices: { message: { content: string } }[];
-      usage?: { prompt_tokens: number; completion_tokens: number };
-    };
-
-    return {
-      content: data.choices[0]?.message?.content || '',
-      tokens: data.usage
-        ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens }
-        : undefined,
-    };
-  }
-
-  getMetadata(): LLMMetadata {
-    return {
-      provider: 'together',
-      model: this.config.model || getDefaultModel('together'),
-    };
-  }
-}

package/src/llm-providers.ts

@@ -1,8 +0,0 @@
-export {
-  LLM_PROVIDERS,
-  getDefaultModel,
-  getProvider,
-  getProviderIds,
-  providerRequiresApiKey,
-} from '@exagent/sdk';
-export type { LlmModel, LlmProvider } from '@exagent/sdk';

package/src/logger.ts

@@ -1,137 +0,0 @@
-/**
- * Structured JSON logger for the agent SDK.
- *
- * Outputs newline-delimited JSON (NDJSON) with consistent fields:
- *   { ts, level, cat, msg, ...data }
- *
- * Categories map to agent subsystems: runtime, llm, strategy, signal,
- * relay, risk, venue, bridge, cycle, diagnostics.
- */
-
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-
-export type LogCategory =
-  | 'runtime'
-  | 'llm'
-  | 'strategy'
-  | 'signal'
-  | 'relay'
-  | 'risk'
-  | 'venue'
-  | 'bridge'
-  | 'cycle'
-  | 'diagnostics';
-
-export interface LogEntry {
-  ts: string;
-  level: LogLevel;
-  cat: LogCategory;
-  msg: string;
-  [key: string]: unknown;
-}
-
-const LEVEL_PRIORITY: Record<LogLevel, number> = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-};
-
-export interface LoggerConfig {
-  /** Minimum log level (default: 'info') */
-  minLevel?: LogLevel;
-  /** Output as JSON (true) or human-readable (false). Default: true */
-  json?: boolean;
-  /** Custom output function (default: console methods) */
-  output?: (entry: LogEntry) => void;
-}
-
-export class Logger {
-  private minLevel: number;
-  private jsonMode: boolean;
-  private output: ((entry: LogEntry) => void) | null;
-
-  constructor(config?: LoggerConfig) {
-    this.minLevel = LEVEL_PRIORITY[config?.minLevel ?? 'info'];
-    this.jsonMode = config?.json ?? true;
-    this.output = config?.output ?? null;
-  }
-
-  debug(cat: LogCategory, msg: string, data?: Record<string, unknown>): void {
-    this.log('debug', cat, msg, data);
-  }
-
-  info(cat: LogCategory, msg: string, data?: Record<string, unknown>): void {
-    this.log('info', cat, msg, data);
-  }
-
-  warn(cat: LogCategory, msg: string, data?: Record<string, unknown>): void {
-    this.log('warn', cat, msg, data);
-  }
-
-  error(cat: LogCategory, msg: string, data?: Record<string, unknown>): void {
-    this.log('error', cat, msg, data);
-  }
-
-  private log(level: LogLevel, cat: LogCategory, msg: string, data?: Record<string, unknown>): void {
-    if (LEVEL_PRIORITY[level] < this.minLevel) return;
-
-    const entry: LogEntry = {
-      ts: new Date().toISOString(),
-      level,
-      cat,
-      msg,
-      ...data,
-    };
-
-    if (this.output) {
-      this.output(entry);
-      return;
-    }
-
-    if (this.jsonMode) {
-      const line = JSON.stringify(entry);
-      switch (level) {
-        case 'error':
-          console.error(line);
-          break;
-        case 'warn':
-          console.warn(line);
-          break;
-        default:
-          console.log(line);
-      }
-    } else {
-      // Human-readable fallback: [cat] msg { data }
-      const prefix = `[${cat}]`;
-      const extra = data && Object.keys(data).length > 0
-        ? ' ' + JSON.stringify(data)
-        : '';
-      switch (level) {
-        case 'error':
-          console.error(`${prefix} ${msg}${extra}`);
-          break;
-        case 'warn':
-          console.warn(`${prefix} ${msg}${extra}`);
-          break;
-        default:
-          console.log(`${prefix} ${msg}${extra}`);
-      }
-    }
-  }
-}
-
-/**
- * Singleton logger instance.
- * Defaults to JSON mode at 'info' level.
- * Call `configureLogger()` before `start()` to customize.
- */
-let globalLogger = new Logger();
-
-export function getLogger(): Logger {
-  return globalLogger;
-}
-
-export function configureLogger(config: LoggerConfig): void {
-  globalLogger = new Logger(config);
-}

package/src/paper/executor.ts

@@ -1,201 +0,0 @@
-import type { TradeSignal, PaperTrade, PaperMetrics, MarketData } from '@exagent/sdk';
-import { randomUUID } from 'node:crypto';
-
-interface PaperPosition {
-  quantity: number;
-  avgPrice: number;
-}
-
-export class PaperExecutor {
-  private cash: number;
-  private positions: Map<string, PaperPosition> = new Map();
-  private trades: PaperTrade[] = [];
-  private equityCurve: { timestamp: number; equity: number }[] = [];
-  private currentPrices: Record<string, number> = {};
-  private slippageBps: number;
-  private feeRate: number;
-  private peakEquity: number;
-  private maxDrawdown = 0;
-
-  constructor(initialCash: number = 10000, slippageBps: number = 50, feeRate: number = 0.002) {
-    this.cash = initialCash;
-    this.slippageBps = slippageBps;
-    this.feeRate = feeRate;
-    this.peakEquity = initialCash;
-    this.recordEquity();
-  }
-
-  execute(signal: TradeSignal, market: MarketData): PaperTrade | null {
-    const marketPrice = market.getPrice(signal.symbol);
-    if (!marketPrice) {
-      console.warn(`[paper] No price for ${signal.symbol}`);
-      return null;
-    }
-
-    const isBuy = signal.side === 'buy' || signal.side === 'long';
-    const slippage = (this.slippageBps / 10000) * marketPrice;
-    const executedPrice = isBuy ? marketPrice + slippage : marketPrice - slippage;
-    const fee = signal.size * executedPrice * this.feeRate;
-
-    let realizedPnL = 0;
-
-    if (isBuy) {
-      const totalCost = signal.size * executedPrice + fee;
-      if (totalCost > this.cash) {
-        console.warn(`[paper] Insufficient funds: need $${totalCost.toFixed(2)}, have $${this.cash.toFixed(2)}`);
-        return null;
-      }
-
-      this.cash -= totalCost;
-      const existing = this.positions.get(signal.symbol);
-      if (existing) {
-        const totalQty = existing.quantity + signal.size;
-        existing.avgPrice = (existing.avgPrice * existing.quantity + executedPrice * signal.size) / totalQty;
-        existing.quantity = totalQty;
-      } else {
-        this.positions.set(signal.symbol, { quantity: signal.size, avgPrice: executedPrice });
-      }
-    } else {
-      const existing = this.positions.get(signal.symbol);
-      if (!existing || existing.quantity < signal.size) {
-        console.warn(`[paper] No position to sell: ${signal.symbol}`);
-        return null;
-      }
-
-      realizedPnL = (executedPrice - existing.avgPrice) * signal.size - fee;
-      const proceeds = signal.size * executedPrice - fee;
-      this.cash += proceeds;
-      existing.quantity -= signal.size;
-      if (existing.quantity <= 0.000001) {
-        this.positions.delete(signal.symbol);
-      }
-    }
-
-    const trade: PaperTrade = {
-      id: randomUUID(),
-      symbol: signal.symbol,
-      side: isBuy ? 'buy' : 'sell',
-      size: signal.size,
-      entryPrice: executedPrice,
-      fee,
-      pnl: realizedPnL !== 0 ? realizedPnL : undefined,
-      timestamp: Date.now(),
-      venue: `paper_${signal.venue}`,
-    };
-
-    this.trades.push(trade);
-    this.recordEquity();
-
-    return trade;
-  }
-
-  /** Update equity snapshot with current market prices */
-  recordEquityWithPrices(prices: Record<string, number>): void {
-    this.currentPrices = prices;
-    this.recordEquity();
-  }
-
-  private recordEquity(): void {
-    const equity = this.getEquity();
-    this.equityCurve.push({ timestamp: Date.now(), equity });
-    if (equity > this.peakEquity) this.peakEquity = equity;
-    const drawdown = (this.peakEquity - equity) / this.peakEquity;
-    if (drawdown > this.maxDrawdown) this.maxDrawdown = drawdown;
-  }
-
-  /** Calculate equity using current market prices (falls back to cost basis if no price available) */
-  getEquity(): number {
-    let positionValue = 0;
-    for (const [symbol, pos] of this.positions) {
-      const currentPrice = this.currentPrices[symbol.toUpperCase()] ?? this.currentPrices[symbol] ?? pos.avgPrice;
-      positionValue += pos.quantity * currentPrice;
-    }
-    return this.cash + positionValue;
-  }
-
-  getCash(): number {
-    return this.cash;
-  }
-
-  getPositions(): Map<string, PaperPosition> {
-    return new Map(this.positions);
-  }
-
-  getTrades(): PaperTrade[] {
-    return [...this.trades];
-  }
-
-  getEquityCurve(): { timestamp: number; equity: number }[] {
-    return [...this.equityCurve];
-  }
-
-  getMetrics(): PaperMetrics {
-    const initialEquity = this.equityCurve[0]?.equity || 0;
-    const currentEquity = this.getEquity();
-    const totalReturn = initialEquity > 0 ? (currentEquity - initialEquity) / initialEquity : 0;
-
-    // Calculate daily returns for Sharpe
-    const dailyReturns = this.calculateDailyReturns();
-    const sharpeRatio = this.calculateSharpe(dailyReturns);
-
-    // Win/loss stats
-    let wins = 0;
-    let losses = 0;
-    let grossProfit = 0;
-    let grossLoss = 0;
-
-    // Match buys and sells to calculate trade PnL
-    const sellTrades = this.trades.filter(t => t.side === 'sell');
-    for (const sell of sellTrades) {
-      const buyTrades = this.trades.filter(t => t.side === 'buy' && t.symbol === sell.symbol);
-      const avgEntry = buyTrades.reduce((sum, t) => sum + t.entryPrice, 0) / (buyTrades.length || 1);
-      const pnl = (sell.entryPrice - avgEntry) * sell.size - sell.fee;
-
-      if (pnl > 0) {
-        wins++;
-        grossProfit += pnl;
-      } else {
-        losses++;
-        grossLoss += Math.abs(pnl);
-      }
-    }
-
-    return {
-      totalReturn,
-      sharpeRatio,
-      maxDrawdown: this.maxDrawdown,
-      winRate: wins + losses > 0 ? wins / (wins + losses) : 0,
-      profitFactor: grossLoss > 0 ? grossProfit / grossLoss : grossProfit > 0 ? Infinity : 0,
-      totalTrades: this.trades.length,
-    };
-  }
-
-  private calculateDailyReturns(): number[] {
-    if (this.equityCurve.length < 2) return [];
-
-    const dailyEquity = new Map<string, number>();
-    for (const point of this.equityCurve) {
-      const date = new Date(point.timestamp).toISOString().slice(0, 10);
-      dailyEquity.set(date, point.equity);
-    }
-
-    const dates = Array.from(dailyEquity.keys()).sort();
-    const returns: number[] = [];
-    for (let i = 1; i < dates.length; i++) {
-      const prev = dailyEquity.get(dates[i - 1])!;
-      const curr = dailyEquity.get(dates[i])!;
-      if (prev > 0) returns.push((curr - prev) / prev);
-    }
-
-    return returns;
-  }
-
-  private calculateSharpe(returns: number[]): number {
-    if (returns.length < 2) return 0;
-    const mean = returns.reduce((a, b) => a + b, 0) / returns.length;
-    const variance = returns.reduce((sum, r) => sum + (r - mean) ** 2, 0) / (returns.length - 1);
-    const std = Math.sqrt(variance);
-    if (std === 0) return 0;
-    return (mean / std) * Math.sqrt(365);
-  }
-}

package/src/paper/index.ts

@@ -1 +0,0 @@
-export { PaperExecutor } from './executor.js';

package/src/perp/client.ts

@@ -1,200 +0,0 @@
-/**
- * Hyperliquid REST Client
- *
- * Info API for read-only queries (positions, fills, metadata).
- * Exchange API for order placement (via orders.ts).
- */
-
-import type {
-  PerpConfig,
-  PerpPosition,
-  AccountSummary,
-  PerpFill,
-  PerpMarketData,
-  AssetMeta,
-  ClearinghouseState,
-  AssetPosition,
-  HyperliquidFill,
-  HyperliquidOrder,
-  L2Book,
-} from './types.js';
-
-export class HyperliquidClient {
-  private readonly apiUrl: string;
-  private meta: AssetMeta[] | null = null;
-  private assetIndexCache: Map<string, number> = new Map();
-
-  constructor(config: PerpConfig) {
-    this.apiUrl = config.apiUrl;
-  }
-
-  // ── INFO API (read-only) ───────────────────────────────────
-
-  async getMeta(): Promise<AssetMeta[]> {
-    if (this.meta) return this.meta;
-    const resp = await this.infoRequest({ type: 'meta' });
-    this.meta = resp.universe as AssetMeta[];
-    this.meta.forEach((asset: AssetMeta, idx: number) => {
-      this.assetIndexCache.set(asset.name, idx);
-    });
-    return this.meta;
-  }
-
-  async getAssetIndex(coin: string): Promise<number> {
-    if (this.assetIndexCache.has(coin)) return this.assetIndexCache.get(coin)!;
-    await this.getMeta();
-    const idx = this.assetIndexCache.get(coin);
-    if (idx === undefined) throw new Error(`Unknown instrument: ${coin}`);
-    return idx;
-  }
-
-  /** Get the size decimal precision for an instrument (for order size rounding) */
-  async getSzDecimals(coin: string): Promise<number> {
-    const meta = await this.getMeta();
-    const asset = meta.find(a => a.name === coin) ?? meta.find(a => a.name.toUpperCase() === coin.toUpperCase());
-    if (!asset) throw new Error(`Unknown instrument: ${coin}`);
-    return asset.szDecimals;
-  }
-
-  async getAllMids(): Promise<Record<string, string>> {
-    return this.infoRequest({ type: 'allMids' });
-  }
-
-  async getClearinghouseState(user: string): Promise<ClearinghouseState> {
-    return this.infoRequest({ type: 'clearinghouseState', user });
-  }
-
-  async getUserFills(user: string, startTime?: number): Promise<HyperliquidFill[]> {
-    return this.infoRequest({
-      type: 'userFills',
-      user,
-      ...(startTime !== undefined && { startTime }),
-    });
-  }
-
-  async getUserFillsByTime(
-    user: string,
-    startTime: number,
-    endTime?: number,
-  ): Promise<HyperliquidFill[]> {
-    return this.infoRequest({
-      type: 'userFillsByTime',
-      user,
-      startTime,
-      ...(endTime !== undefined && { endTime }),
-    });
-  }
-
-  async getOpenOrders(user: string): Promise<HyperliquidOrder[]> {
-    return this.infoRequest({ type: 'openOrders', user });
-  }
-
-  async getL2Book(coin: string, depth?: number): Promise<L2Book> {
-    return this.infoRequest({
-      type: 'l2Book',
-      coin,
-      ...(depth !== undefined && { nSigFigs: depth }),
-    });
-  }
-
-  // ── HIGH-LEVEL HELPERS ─────────────────────────────────────
-
-  async getPositions(user: string): Promise<PerpPosition[]> {
-    const state = await this.getClearinghouseState(user);
-    return state.assetPositions
-      .filter((p) => parseFloat(p.position.szi) !== 0)
-      .map((p) => this.parsePosition(p));
-  }
-
-  async getAccountSummary(user: string): Promise<AccountSummary> {
-    const state = await this.getClearinghouseState(user);
-    const cms = state.crossMarginSummary;
-
-    const totalEquity = parseFloat(cms.accountValue);
-    const totalNotional = parseFloat(cms.totalNtlPos);
-    const totalMarginUsed = parseFloat(cms.totalMarginUsed);
-
-    return {
-      totalEquity,
-      availableMargin: totalEquity - totalMarginUsed,
-      totalMarginUsed,
-      totalUnrealizedPnl: parseFloat(cms.totalRawUsd) - totalEquity,
-      totalNotional,
-      maintenanceMargin: totalMarginUsed * 0.5,
-      effectiveLeverage: totalEquity > 0 ? totalNotional / totalEquity : 0,
-      cashBalance:
-        parseFloat(cms.accountValue) -
-        state.assetPositions.reduce(
-          (sum, p) => sum + parseFloat(p.position.unrealizedPnl),
-          0,
-        ),
-    };
-  }
-
-  async getMarketData(instruments: string[]): Promise<PerpMarketData[]> {
-    const mids = await this.getAllMids();
-    return instruments
-      .filter((inst) => mids[inst] !== undefined)
-      .map((inst) => ({
-        instrument: inst,
-        midPrice: parseFloat(mids[inst]),
-        bestBid: parseFloat(mids[inst]),
-        bestAsk: parseFloat(mids[inst]),
-        funding8h: 0,
-        openInterest: 0,
-        volume24h: 0,
-        priceChange24h: 0,
-      }));
-  }
-
-  parseFill(fill: HyperliquidFill): PerpFill {
-    return {
-      oid: fill.oid,
-      coin: fill.coin,
-      side: fill.side,
-      px: fill.px,
-      sz: fill.sz,
-      fee: fill.fee,
-      time: fill.time,
-      hash: fill.hash,
-      isMaker: fill.startPosition !== fill.px,
-      builderFee: fill.builderFee,
-      liquidation: fill.liquidation,
-    };
-  }
-
-  // ── PRIVATE ────────────────────────────────────────────────
-
-  private parsePosition(ap: AssetPosition): PerpPosition {
-    const pos = ap.position;
-    const size = parseFloat(pos.szi);
-    const entryPrice = parseFloat(pos.entryPx || '0');
-    const markPrice = parseFloat(pos.positionValue || '0') / Math.abs(size || 1);
-
-    return {
-      instrument: pos.coin,
-      assetIndex: this.assetIndexCache.get(pos.coin) ?? -1,
-      size,
-      entryPrice,
-      markPrice,
-      unrealizedPnl: parseFloat(pos.unrealizedPnl),
-      leverage: parseFloat(pos.leverage?.value || '1'),
-      marginType: pos.leverage?.type === 'isolated' ? 'isolated' : 'cross',
-      liquidationPrice: parseFloat(pos.liquidationPx || '0'),
-      notionalUSD: Math.abs(size) * markPrice,
-      marginUsed: parseFloat(pos.marginUsed),
-    };
-  }
-
-  private async infoRequest(body: Record<string, unknown>): Promise<any> {
-    const resp = await fetch(`${this.apiUrl}/info`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body),
-    });
-    if (!resp.ok) {
-      throw new Error(`Hyperliquid Info API error: ${resp.status} ${await resp.text()}`);
-    }
-    return resp.json();
-  }
-}

package/src/perp/index.ts

@@ -1,12 +0,0 @@
-export * from './types.js';
-export { HyperliquidClient } from './client.js';
-export { HyperliquidSigner, getNextNonce, HYPERLIQUID_DOMAIN, HYPERLIQUID_USER_DOMAIN, USER_ACTION_TYPES } from './signer.js';
-export { HyperliquidOrderManager } from './orders.js';
-export { HyperliquidPositionManager } from './positions.js';
-export {
-  HyperliquidWebSocket,
-  type FillCallback,
-  type FundingCallback,
-  type LiquidationCallback,
-  type FundingPayment,
-} from './websocket.js';