@exagent/agent 0.3.3 → 0.3.4

package/dist/chunk-MREXDTWL.js

@@ -1,1555 +0,0 @@
-// src/config.ts
-import { readFileSync, existsSync, writeFileSync } from "fs";
-import { z } from "zod";
-var configSchema = z.object({
-  agentId: z.string(),
-  apiUrl: z.string().url(),
-  apiToken: z.string(),
-  wallet: z.object({
-    privateKey: z.string()
-  }).optional(),
-  llm: z.object({
-    provider: z.enum(["openai", "anthropic", "google", "deepseek", "mistral", "groq", "together", "ollama"]),
-    model: z.string().optional(),
-    apiKey: z.string().optional(),
-    endpoint: z.string().optional(),
-    temperature: z.number().min(0).max(2).optional(),
-    maxTokens: z.number().optional()
-  }),
-  strategy: z.object({
-    file: z.string().optional(),
-    template: z.string().optional()
-  }),
-  trading: z.object({
-    mode: z.enum(["live", "paper"]).default("paper"),
-    timeHorizon: z.enum(["intraday", "swing", "position"]).default("swing"),
-    maxPositionSizeBps: z.number().min(100).max(1e4).default(2e3),
-    maxDailyLossBps: z.number().min(0).max(1e4).default(500),
-    maxConcurrentPositions: z.number().min(1).max(100).default(5),
-    tradingIntervalMs: z.number().min(1e3).default(6e4),
-    maxSlippageBps: z.number().min(10).max(1e3).default(100),
-    minTradeValueUSD: z.number().min(0).default(10),
-    initialCapitalUSD: z.number().optional()
-  }),
-  venues: z.object({
-    hyperliquid_perp: z.object({
-      enabled: z.boolean().default(false),
-      apiUrl: z.string().default("https://api.hyperliquid.xyz"),
-      wsUrl: z.string().default("wss://api.hyperliquid.xyz/ws"),
-      maxLeverage: z.number().min(1).max(50).default(10),
-      maxNotionalUSD: z.number().default(5e4),
-      allowedInstruments: z.array(z.string()).optional()
-    }).optional(),
-    polymarket: z.object({
-      enabled: z.boolean().default(false),
-      clobApiUrl: z.string().default("https://clob.polymarket.com"),
-      gammaApiUrl: z.string().default("https://gamma-api.polymarket.com"),
-      maxNotionalUSD: z.number().default(1e3),
-      maxTotalExposureUSD: z.number().default(5e3),
-      allowedCategories: z.array(z.string()).optional()
-    }).optional()
-  }).optional(),
-  relay: z.object({
-    url: z.string(),
-    heartbeatIntervalMs: z.number().default(3e4),
-    reconnectMaxAttempts: z.number().default(50)
-  })
-});
-function loadConfig(path = "agent-config.json") {
-  if (!existsSync(path)) {
-    throw new Error(`Config file not found: ${path}. Run 'exagent init' first.`);
-  }
-  const raw = readFileSync(path, "utf-8");
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new Error(`Invalid JSON in ${path}`);
-  }
-  const config = parsed;
-  const llm = config.llm || {};
-  if (process.env.EXAGENT_LLM_PROVIDER) llm.provider = process.env.EXAGENT_LLM_PROVIDER;
-  if (process.env.EXAGENT_LLM_MODEL) llm.model = process.env.EXAGENT_LLM_MODEL;
-  if (process.env.EXAGENT_LLM_API_KEY) llm.apiKey = process.env.EXAGENT_LLM_API_KEY;
-  if (process.env.EXAGENT_API_URL) config.apiUrl = process.env.EXAGENT_API_URL;
-  if (process.env.EXAGENT_API_TOKEN) config.apiToken = process.env.EXAGENT_API_TOKEN;
-  if (process.env.EXAGENT_WALLET_PRIVATE_KEY) {
-    config.wallet = { privateKey: process.env.EXAGENT_WALLET_PRIVATE_KEY };
-  }
-  config.llm = llm;
-  const result = configSchema.safeParse(config);
-  if (!result.success) {
-    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
-    throw new Error(`Invalid config:
-${issues}`);
-  }
-  return result.data;
-}
-function generateSampleConfig(agentId, apiUrl) {
-  const config = {
-    agentId,
-    apiUrl,
-    apiToken: "<your-jwt-token>",
-    llm: {
-      provider: "openai",
-      model: "gpt-4o",
-      apiKey: "<your-api-key>"
-    },
-    strategy: {
-      template: "momentum"
-    },
-    trading: {
-      mode: "paper",
-      timeHorizon: "swing",
-      maxPositionSizeBps: 2e3,
-      maxDailyLossBps: 500,
-      maxConcurrentPositions: 5,
-      tradingIntervalMs: 6e4,
-      maxSlippageBps: 100,
-      minTradeValueUSD: 10,
-      initialCapitalUSD: 1e4
-    },
-    relay: {
-      url: apiUrl.replace(/^http/, "ws") + "/ws/agent",
-      heartbeatIntervalMs: 3e4,
-      reconnectMaxAttempts: 50
-    }
-  };
-  return JSON.stringify(config, null, 2);
-}
-function writeSampleConfig(agentId, apiUrl, path = "agent-config.json") {
-  writeFileSync(path, generateSampleConfig(agentId, apiUrl));
-}
-
-// src/relay.ts
-import WebSocket from "ws";
-var RelayClient = class {
-  ws = null;
-  config;
-  heartbeatTimer = null;
-  reconnectTimer = null;
-  reconnectAttempts = 0;
-  intentionalClose = false;
-  authenticated = false;
-  lastStatus = null;
-  onCommand;
-  onConnected;
-  onDisconnected;
-  constructor(config) {
-    this.config = {
-      url: config.url,
-      agentId: config.agentId,
-      token: config.token,
-      heartbeatIntervalMs: config.heartbeatIntervalMs ?? 3e4,
-      reconnectMaxAttempts: config.reconnectMaxAttempts ?? 50
-    };
-    this.onCommand = config.onCommand;
-    this.onConnected = config.onConnected;
-    this.onDisconnected = config.onDisconnected;
-  }
-  get isConnected() {
-    return this.ws?.readyState === WebSocket.OPEN && this.authenticated;
-  }
-  async connect() {
-    return new Promise((resolve2, 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)"));
-          }
-        }, 15e3);
-        this.ws.on("open", () => {
-          clearTimeout(timeout);
-          this.reconnectAttempts = 0;
-          this.authenticate();
-        });
-        this.ws.on("message", (data) => {
-          try {
-            const msg = JSON.parse(data.toString());
-            this.handleMessage(msg, resolve2);
-          } catch {
-            console.error("[relay] Failed to parse message");
-          }
-        });
-        this.ws.on("close", () => {
-          this.cleanup();
-          this.onDisconnected?.();
-          if (!this.intentionalClose) {
-            this.scheduleReconnect();
-          }
-        });
-        this.ws.on("error", (err) => {
-          console.error("[relay] WebSocket error:", err.message);
-          if (!this.authenticated) {
-            clearTimeout(timeout);
-            reject(err);
-          }
-        });
-      } catch (err) {
-        reject(err);
-      }
-    });
-  }
-  disconnect() {
-    this.intentionalClose = true;
-    this.cleanup();
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-  authenticate() {
-    this.send({
-      type: "auth",
-      agentId: this.config.agentId,
-      token: this.config.token
-    });
-  }
-  handleMessage(msg, onAuth) {
-    switch (msg.type) {
-      case "auth_success":
-        this.authenticated = true;
-        this.startHeartbeat();
-        this.onConnected?.();
-        onAuth?.();
-        console.log(`[relay] Authenticated as agent ${this.config.agentId}`);
-        break;
-      case "auth_error":
-        console.error("[relay] Auth failed:", msg.error);
-        this.disconnect();
-        break;
-      case "command":
-        this.onCommand?.(msg.command);
-        break;
-      case "pong":
-        break;
-    }
-  }
-  send(msg) {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(msg));
-    }
-  }
-  sendHeartbeat(status) {
-    this.lastStatus = status;
-    this.send({
-      type: "heartbeat",
-      agentId: this.config.agentId,
-      status,
-      timestamp: Date.now()
-    });
-  }
-  sendMessage(messageType, level, title, body, data) {
-    this.send({
-      type: "message",
-      agentId: this.config.agentId,
-      messageType,
-      level,
-      title,
-      body,
-      data,
-      timestamp: Date.now()
-    });
-  }
-  sendTradeSignal(signal) {
-    this.send({
-      type: "trade_signal",
-      agentId: this.config.agentId,
-      signal,
-      timestamp: Date.now()
-    });
-  }
-  startHeartbeat() {
-    this.stopHeartbeat();
-    this.heartbeatTimer = setInterval(() => {
-      if (this.lastStatus) {
-        this.sendHeartbeat(this.lastStatus);
-      }
-    }, this.config.heartbeatIntervalMs);
-  }
-  stopHeartbeat() {
-    if (this.heartbeatTimer) {
-      clearInterval(this.heartbeatTimer);
-      this.heartbeatTimer = null;
-    }
-  }
-  cleanup() {
-    this.stopHeartbeat();
-    this.authenticated = false;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-  }
-  scheduleReconnect() {
-    if (this.reconnectAttempts >= this.config.reconnectMaxAttempts) {
-      console.error(`[relay] Max reconnect attempts (${this.config.reconnectMaxAttempts}) reached`);
-      return;
-    }
-    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
-    this.reconnectAttempts++;
-    console.log(`[relay] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
-    this.reconnectTimer = setTimeout(async () => {
-      try {
-        await this.connect();
-      } catch (err) {
-        console.error("[relay] Reconnect failed:", err.message);
-      }
-    }, delay);
-  }
-};
-
-// src/signal.ts
-var SignalReporter = class {
-  relay;
-  constructor(relay) {
-    this.relay = relay;
-  }
-  reportTrade(signal) {
-    if (!this.relay.isConnected) {
-      console.warn("[signal] Not connected to relay \u2014 trade signal queued locally");
-      return;
-    }
-    this.relay.sendTradeSignal(signal);
-    this.relay.sendMessage(
-      "trade_executed",
-      "success",
-      `${signal.side.toUpperCase()} ${signal.symbol}`,
-      `${signal.side} ${signal.size} ${signal.symbol} @ $${signal.price.toFixed(2)} on ${signal.venue}`,
-      { signal }
-    );
-  }
-  reportPerpFill(signal) {
-    if (!this.relay.isConnected) return;
-    this.relay.sendTradeSignal(signal);
-    this.relay.sendMessage(
-      "perp_fill",
-      "success",
-      `Perp ${signal.side.toUpperCase()} ${signal.symbol}`,
-      `${signal.side} ${signal.size} ${signal.symbol} @ $${signal.price.toFixed(2)} (${signal.leverage ?? 1}x)`,
-      { signal }
-    );
-  }
-  reportPredictionFill(signal) {
-    if (!this.relay.isConnected) return;
-    this.relay.sendTradeSignal(signal);
-    this.relay.sendMessage(
-      "prediction_fill",
-      "success",
-      `Prediction ${signal.side.toUpperCase()}`,
-      `${signal.side} $${signal.size.toFixed(2)} on ${signal.symbol} @ ${signal.price.toFixed(4)}`,
-      { signal }
-    );
-  }
-  reportError(title, body, data) {
-    if (!this.relay.isConnected) return;
-    this.relay.sendMessage("error", "error", title, body, data);
-  }
-  reportInfo(title, body, data) {
-    if (!this.relay.isConnected) return;
-    this.relay.sendMessage("info", "info", title, body, data);
-  }
-};
-
-// src/store.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync2 } from "fs";
-import { dirname } from "path";
-var FileStore = class {
-  data = {};
-  filePath;
-  constructor(filePath = "data/strategy-store.json") {
-    this.filePath = filePath;
-    this.load();
-  }
-  load() {
-    try {
-      if (existsSync2(this.filePath)) {
-        const raw = readFileSync2(this.filePath, "utf-8");
-        this.data = JSON.parse(raw);
-      }
-    } catch {
-      this.data = {};
-    }
-  }
-  flush() {
-    const dir = dirname(this.filePath);
-    if (!existsSync2(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync2(this.filePath, JSON.stringify(this.data, null, 2));
-  }
-  get(key) {
-    return this.data[key];
-  }
-  set(key, value) {
-    this.data[key] = value;
-    this.flush();
-  }
-  delete(key) {
-    delete this.data[key];
-    this.flush();
-  }
-  keys() {
-    return Object.keys(this.data);
-  }
-};
-
-// src/position-tracker.ts
-var BASE_ASSETS = /* @__PURE__ */ new Set(["ETH", "WETH", "USDC", "USDbC", "DAI", "USDT", "EURC"]);
-var PositionTracker = class {
-  positions = /* @__PURE__ */ new Map();
-  trades = [];
-  realizedPnL = 0;
-  store;
-  constructor(store) {
-    this.store = store;
-    this.load();
-  }
-  load() {
-    const saved = this.store.get("position_tracker");
-    if (saved) {
-      this.positions = new Map(saved.positions);
-      this.trades = saved.trades;
-      this.realizedPnL = saved.realizedPnL;
-    }
-  }
-  save() {
-    this.store.set("position_tracker", {
-      positions: Array.from(this.positions.entries()),
-      trades: this.trades.slice(-1e3),
-      realizedPnL: this.realizedPnL
-    });
-  }
-  recordBuy(token, quantity, price, fee, venue, chain, venueFillId) {
-    if (BASE_ASSETS.has(token)) return;
-    const existing = this.positions.get(token);
-    if (existing) {
-      const totalQty = existing.quantity + quantity;
-      const totalCost = existing.costBasisPerUnit * existing.quantity + price * quantity;
-      existing.costBasisPerUnit = totalCost / totalQty;
-      existing.quantity = totalQty;
-    } else {
-      this.positions.set(token, {
-        token,
-        quantity,
-        costBasisPerUnit: price,
-        entryTimestamp: Date.now(),
-        venue,
-        chain
-      });
-    }
-    this.trades.push({
-      token,
-      action: "buy",
-      quantity,
-      price,
-      fee,
-      timestamp: Date.now(),
-      venue,
-      chain,
-      venueFillId
-    });
-    this.save();
-  }
-  recordSell(token, quantity, price, fee, venue, chain, venueFillId) {
-    if (BASE_ASSETS.has(token)) return;
-    const existing = this.positions.get(token);
-    if (existing) {
-      const pnl = (price - existing.costBasisPerUnit) * quantity - fee;
-      this.realizedPnL += pnl;
-      existing.quantity -= quantity;
-      if (existing.quantity <= 1e-6) {
-        this.positions.delete(token);
-      }
-    }
-    this.trades.push({
-      token,
-      action: "sell",
-      quantity,
-      price,
-      fee,
-      timestamp: Date.now(),
-      venue,
-      chain,
-      venueFillId
-    });
-    this.save();
-  }
-  getSummary(prices) {
-    let totalUnrealizedPnL = 0;
-    const openPositions = Array.from(this.positions.values());
-    for (const pos of openPositions) {
-      const currentPrice = prices[pos.token];
-      if (currentPrice) {
-        totalUnrealizedPnL += (currentPrice - pos.costBasisPerUnit) * pos.quantity;
-      }
-    }
-    return {
-      openPositions,
-      totalUnrealizedPnL,
-      totalRealizedPnL: this.realizedPnL
-    };
-  }
-  getPositions() {
-    return Array.from(this.positions.values());
-  }
-  getTrades(limit) {
-    if (limit) return this.trades.slice(-limit);
-    return [...this.trades];
-  }
-  getRealizedPnL() {
-    return this.realizedPnL;
-  }
-  reset() {
-    this.positions.clear();
-    this.trades = [];
-    this.realizedPnL = 0;
-    this.save();
-  }
-};
-
-// src/llm/base.ts
-var BaseLLMAdapter = class {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  getTemperature() {
-    return this.config.temperature ?? 0.7;
-  }
-  getMaxTokens() {
-    return this.config.maxTokens ?? 4096;
-  }
-};
-
-// src/llm/openai.ts
-var OpenAIAdapter = class extends BaseLLMAdapter {
-  endpoint;
-  constructor(config) {
-    super(config);
-    this.endpoint = config.endpoint || "https://api.openai.com/v1";
-  }
-  async chat(messages) {
-    const res = await fetch(`${this.endpoint}/chat/completions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.config.model || "gpt-4o",
-        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(`OpenAI API error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "openai",
-      model: this.config.model || "gpt-4o"
-    };
-  }
-};
-
-// src/llm/anthropic.ts
-var AnthropicAdapter = class extends BaseLLMAdapter {
-  endpoint;
-  constructor(config) {
-    super(config);
-    this.endpoint = config.endpoint || "https://api.anthropic.com";
-  }
-  async chat(messages) {
-    const systemMessage = messages.find((m) => m.role === "system");
-    const nonSystemMessages = messages.filter((m) => m.role !== "system");
-    const body = {
-      model: this.config.model || "claude-sonnet-4-20250514",
-      messages: nonSystemMessages.map((m) => ({ role: m.role, content: m.content })),
-      max_tokens: this.getMaxTokens(),
-      temperature: this.getTemperature()
-    };
-    if (systemMessage) {
-      body.system = systemMessage.content;
-    }
-    const res = await fetch(`${this.endpoint}/v1/messages`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.config.apiKey || "",
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify(body)
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`Anthropic API error ${res.status}: ${text}`);
-    }
-    const data = await res.json();
-    const textContent = data.content.find((c) => c.type === "text");
-    return {
-      content: textContent?.text || "",
-      tokens: data.usage ? { input: data.usage.input_tokens, output: data.usage.output_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "anthropic",
-      model: this.config.model || "claude-sonnet-4-20250514"
-    };
-  }
-};
-
-// src/llm/google.ts
-var GoogleAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const model = this.config.model || "gemini-2.5-flash";
-    const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${this.config.apiKey}`;
-    const systemMessage = messages.find((m) => m.role === "system");
-    const nonSystemMessages = messages.filter((m) => m.role !== "system");
-    const body = {
-      contents: nonSystemMessages.map((m) => ({
-        role: m.role === "assistant" ? "model" : "user",
-        parts: [{ text: m.content }]
-      })),
-      generationConfig: {
-        temperature: this.getTemperature(),
-        maxOutputTokens: this.getMaxTokens()
-      }
-    };
-    if (systemMessage) {
-      body.systemInstruction = { parts: [{ text: systemMessage.content }] };
-    }
-    const res = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    if (!res.ok) {
-      const text2 = await res.text();
-      throw new Error(`Google AI error ${res.status}: ${text2}`);
-    }
-    const data = await res.json();
-    const text = data.candidates[0]?.content?.parts[0]?.text || "";
-    return {
-      content: text,
-      tokens: data.usageMetadata ? { input: data.usageMetadata.promptTokenCount, output: data.usageMetadata.candidatesTokenCount } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "google",
-      model: this.config.model || "gemini-2.5-flash"
-    };
-  }
-};
-
-// src/llm/deepseek.ts
-var DeepSeekAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const res = await fetch("https://api.deepseek.com/chat/completions", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.config.model || "deepseek-chat",
-        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(`DeepSeek API error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "deepseek",
-      model: this.config.model || "deepseek-chat"
-    };
-  }
-};
-
-// src/llm/mistral.ts
-var MistralAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const res = await fetch("https://api.mistral.ai/v1/chat/completions", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.config.model || "mistral-large-latest",
-        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(`Mistral API error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "mistral",
-      model: this.config.model || "mistral-large-latest"
-    };
-  }
-};
-
-// src/llm/groq.ts
-var GroqAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const res = await fetch("https://api.groq.com/openai/v1/chat/completions", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.config.apiKey}`
-      },
-      body: JSON.stringify({
-        model: this.config.model || "llama-3.3-70b-versatile",
-        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(`Groq API error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "groq",
-      model: this.config.model || "llama-3.3-70b-versatile"
-    };
-  }
-};
-
-// src/llm/together.ts
-var TogetherAdapter = class extends BaseLLMAdapter {
-  constructor(config) {
-    super(config);
-  }
-  async chat(messages) {
-    const res = await fetch("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 || "meta-llama/Llama-3.3-70B-Instruct-Turbo",
-        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();
-    return {
-      content: data.choices[0]?.message?.content || "",
-      tokens: data.usage ? { input: data.usage.prompt_tokens, output: data.usage.completion_tokens } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "together",
-      model: this.config.model || "meta-llama/Llama-3.3-70B-Instruct-Turbo"
-    };
-  }
-};
-
-// src/llm/ollama.ts
-var OllamaAdapter = class extends BaseLLMAdapter {
-  endpoint;
-  constructor(config) {
-    super(config);
-    this.endpoint = config.endpoint || "http://localhost:11434";
-  }
-  async chat(messages) {
-    const res = await fetch(`${this.endpoint}/api/chat`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model: this.config.model || "llama3.3",
-        messages: messages.map((m) => ({ role: m.role, content: m.content })),
-        stream: false,
-        options: {
-          temperature: this.getTemperature(),
-          num_predict: this.getMaxTokens()
-        }
-      })
-    });
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`Ollama error ${res.status}: ${body}`);
-    }
-    const data = await res.json();
-    return {
-      content: data.message?.content || "",
-      tokens: data.prompt_eval_count ? { input: data.prompt_eval_count, output: data.eval_count || 0 } : void 0
-    };
-  }
-  getMetadata() {
-    return {
-      provider: "ollama",
-      model: this.config.model || "llama3.3"
-    };
-  }
-};
-
-// src/llm/index.ts
-function createLLMAdapter(config) {
-  switch (config.provider) {
-    case "openai":
-      return new OpenAIAdapter(config);
-    case "anthropic":
-      return new AnthropicAdapter(config);
-    case "google":
-      return new GoogleAdapter(config);
-    case "deepseek":
-      return new DeepSeekAdapter(config);
-    case "mistral":
-      return new MistralAdapter(config);
-    case "groq":
-      return new GroqAdapter(config);
-    case "together":
-      return new TogetherAdapter(config);
-    case "ollama":
-      return new OllamaAdapter(config);
-    default:
-      throw new Error(`Unknown LLM provider: ${config.provider}`);
-  }
-}
-
-// src/strategy/templates.ts
-var templates = [
-  {
-    id: "momentum",
-    name: "Momentum Trader",
-    description: "Identifies tokens with strong upward price momentum and rides the trend. Uses LLM to analyze price action and market sentiment.",
-    category: "momentum",
-    venues: ["hyperliquid_perp", "hyperliquid_spot"],
-    riskLevel: "moderate",
-    systemPrompt: `You are a momentum trading agent. Analyze the provided market data and identify tokens with strong upward momentum.
-
-Rules:
-- Only trade tokens with clear directional momentum (avoid choppy markets)
-- Use trailing stops to protect gains
-- Size positions based on conviction (higher confidence = larger position)
-- Cut losses quickly if momentum reverses
-- Consider volume as confirmation of momentum
-
-Return a JSON array of trade signals.`,
-    code: `
-const prices = context.market.getPrices();
-const positions = context.position.openPositions;
-
-const messages = [
-  { role: 'system', content: 'You are a momentum trading agent. Analyze market data and return trade signals as a JSON array. Each signal: { symbol, side: "buy"|"sell", confidence: 0-1, reasoning }. Return [] if no opportunities.' },
-  { role: 'user', content: 'Current prices: ' + JSON.stringify(prices) + '\\nOpen positions: ' + JSON.stringify(positions.map(p => p.token)) + '\\nAnalyze for momentum opportunities.' }
-];
-
-const response = await context.llm.chat(messages);
-try {
-  const signals = JSON.parse(response.content);
-  return Array.isArray(signals) ? signals : [];
-} catch {
-  return [];
-}
-`
-  },
-  {
-    id: "value",
-    name: "Value Investor",
-    description: "Identifies undervalued tokens based on fundamental analysis. Buys dips and holds for mean reversion.",
-    category: "value",
-    venues: ["hyperliquid_spot"],
-    riskLevel: "conservative",
-    systemPrompt: `You are a value investing agent. Identify tokens trading below their intrinsic value.
-
-Rules:
-- Focus on established tokens with strong fundamentals
-- Buy on significant dips (>10% from recent highs)
-- Hold positions longer (swing/position timeframe)
-- Avoid chasing pumps
-- Diversify across sectors
-
-Return a JSON array of trade signals.`,
-    code: `
-const prices = context.market.getPrices();
-const positions = context.position.openPositions;
-
-const messages = [
-  { role: 'system', content: 'You are a value investing agent. Identify undervalued tokens. Return trade signals as JSON array: { symbol, side: "buy"|"sell", confidence: 0-1, reasoning }. Return [] if nothing is compelling.' },
-  { role: 'user', content: 'Current prices: ' + JSON.stringify(prices) + '\\nPositions: ' + JSON.stringify(positions.map(p => ({ token: p.token, entry: p.costBasisPerUnit }))) + '\\nLook for value opportunities.' }
-];
-
-const response = await context.llm.chat(messages);
-try {
-  const signals = JSON.parse(response.content);
-  return Array.isArray(signals) ? signals : [];
-} catch {
-  return [];
-}
-`
-  },
-  {
-    id: "arbitrage",
-    name: "Arbitrage Hunter",
-    description: "Scans for price discrepancies across venues and chains. Executes quickly to capture spreads.",
-    category: "arbitrage",
-    venues: ["hyperliquid_perp", "hyperliquid_spot", "uniswap", "aerodrome"],
-    riskLevel: "aggressive",
-    systemPrompt: `You are an arbitrage agent. Find price discrepancies between venues.
-
-Rules:
-- Speed is critical \u2014 execute quickly before spreads close
-- Account for fees and slippage in profitability calculations
-- Only trade when net profit > 0.5% after all costs
-- Monitor cross-chain opportunities (CEX vs DEX spreads)
-
-Return a JSON array of trade signals.`,
-    code: `
-const prices = context.market.getPrices();
-
-const messages = [
-  { role: 'system', content: 'You are an arbitrage agent. Find price discrepancies. Return trade signals as JSON array: { symbol, side: "buy"|"sell", venue, confidence: 0-1, reasoning }. Return [] if no arb opportunities.' },
-  { role: 'user', content: 'Market prices: ' + JSON.stringify(prices) + '\\nScan for cross-venue arbitrage opportunities.' }
-];
-
-const response = await context.llm.chat(messages);
-try {
-  const signals = JSON.parse(response.content);
-  return Array.isArray(signals) ? signals : [];
-} catch {
-  return [];
-}
-`
-  },
-  {
-    id: "hold",
-    name: "Hold (No Trading)",
-    description: "Passive strategy that makes no trades. Useful for monitoring only.",
-    category: "custom",
-    venues: [],
-    riskLevel: "conservative",
-    systemPrompt: "",
-    code: `return [];`
-  }
-];
-function getTemplate(id) {
-  return templates.find((t) => t.id === id);
-}
-function listTemplates() {
-  return [...templates];
-}
-
-// src/strategy/loader.ts
-import { existsSync as existsSync3 } from "fs";
-import { resolve } from "path";
-async function loadStrategy(config) {
-  if (config.file) {
-    return loadFromFile(config.file);
-  }
-  if (config.template) {
-    const template = getTemplate(config.template);
-    if (!template) {
-      throw new Error(`Unknown strategy template: ${config.template}. Available: momentum, value, arbitrage, hold`);
-    }
-    return loadFromCode(template.code);
-  }
-  return holdStrategy;
-}
-async function loadFromFile(filePath) {
-  const resolved = resolve(filePath);
-  if (!existsSync3(resolved)) {
-    throw new Error(`Strategy file not found: ${resolved}`);
-  }
-  try {
-    const mod = await import(resolved);
-    const fn = mod.default || mod.strategy;
-    if (typeof fn !== "function") {
-      throw new Error(`Strategy file must export a default function or 'strategy' function`);
-    }
-    return fn;
-  } catch (err) {
-    throw new Error(`Failed to load strategy from ${resolved}: ${err.message}`);
-  }
-}
-async function loadFromCode(code) {
-  const AsyncFunction = Object.getPrototypeOf(async function() {
-  }).constructor;
-  const fn = new AsyncFunction("context", code);
-  return fn;
-}
-var holdStrategy = async (_context) => {
-  return [];
-};
-
-// src/trading/risk.ts
-var RiskManager = class {
-  params;
-  dailyPnL = 0;
-  dailyFees = 0;
-  lastResetDate = "";
-  initialCapitalUSD;
-  constructor(params, initialCapitalUSD = 1e4) {
-    this.params = params;
-    this.initialCapitalUSD = initialCapitalUSD;
-    this.resetIfNewDay();
-  }
-  filterSignals(signals, market, openPositionCount) {
-    this.resetIfNewDay();
-    if (this.isDailyLossLimitHit()) {
-      console.log("[risk] Daily loss limit hit \u2014 blocking all trades");
-      return [];
-    }
-    return signals.filter((signal) => this.validateSignal(signal, market, openPositionCount));
-  }
-  validateSignal(signal, market, openPositionCount) {
-    const threshold = this.params.confidenceThreshold ?? 0.5;
-    if (signal.confidence !== void 0 && signal.confidence < threshold) {
-      console.log(`[risk] Blocked ${signal.symbol}: confidence ${signal.confidence} < ${threshold}`);
-      return false;
-    }
-    const tradeValue = signal.size * signal.price;
-    const maxPositionValue = this.params.maxPositionSizeBps / 1e4 * this.initialCapitalUSD;
-    if (tradeValue > maxPositionValue) {
-      console.log(`[risk] Blocked ${signal.symbol}: trade $${tradeValue.toFixed(0)} > max $${maxPositionValue.toFixed(0)}`);
-      return false;
-    }
-    if (tradeValue < this.params.minTradeValueUSD) {
-      console.log(`[risk] Blocked ${signal.symbol}: trade $${tradeValue.toFixed(2)} < min $${this.params.minTradeValueUSD}`);
-      return false;
-    }
-    if ((signal.side === "buy" || signal.side === "long") && openPositionCount >= this.params.maxConcurrentPositions) {
-      console.log(`[risk] Blocked ${signal.symbol}: ${openPositionCount} positions >= max ${this.params.maxConcurrentPositions}`);
-      return false;
-    }
-    if (signal.orderType === "market") {
-      const currentPrice = market.getPrice(signal.symbol);
-      if (currentPrice) {
-        const slippageBps = Math.abs(signal.price - currentPrice) / currentPrice * 1e4;
-        if (slippageBps > this.params.maxSlippageBps) {
-          console.log(`[risk] Blocked ${signal.symbol}: slippage ${slippageBps.toFixed(0)}bps > max ${this.params.maxSlippageBps}bps`);
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-  recordTrade(pnl, fee) {
-    this.dailyPnL += pnl;
-    this.dailyFees += fee;
-  }
-  isDailyLossLimitHit() {
-    const limit = this.params.maxDailyLossBps / 1e4 * this.initialCapitalUSD;
-    return this.dailyPnL < -limit;
-  }
-  getDailyPnL() {
-    return this.dailyPnL;
-  }
-  getDailyLossLimit() {
-    return this.params.maxDailyLossBps / 1e4 * this.initialCapitalUSD;
-  }
-  resetIfNewDay() {
-    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    if (today !== this.lastResetDate) {
-      this.dailyPnL = 0;
-      this.dailyFees = 0;
-      this.lastResetDate = today;
-    }
-  }
-};
-
-// src/trading/market.ts
-var MarketDataService = class {
-  prices = {};
-  lastFetch = 0;
-  cacheTTL;
-  constructor(cacheTTLMs = 3e4) {
-    this.cacheTTL = cacheTTLMs;
-  }
-  async refreshPrices(symbols) {
-    if (symbols.length === 0) return this.prices;
-    const now = Date.now();
-    if (now - this.lastFetch < this.cacheTTL && Object.keys(this.prices).length > 0) {
-      return this.prices;
-    }
-    try {
-      const ids = symbols.map((s) => s.toLowerCase()).join(",");
-      const res = await fetch(
-        `https://api.coingecko.com/api/v3/simple/price?ids=${ids}&vs_currencies=usd`
-      );
-      if (res.ok) {
-        const data = await res.json();
-        for (const [id, price] of Object.entries(data)) {
-          this.prices[id.toUpperCase()] = price.usd;
-        }
-        this.lastFetch = now;
-      }
-    } catch (err) {
-      console.warn("[market] Price fetch failed:", err.message);
-    }
-    return this.prices;
-  }
-  getPrice(symbol) {
-    return this.prices[symbol.toUpperCase()];
-  }
-  getPrices() {
-    return { ...this.prices };
-  }
-  setPrice(symbol, price) {
-    this.prices[symbol.toUpperCase()] = price;
-  }
-  setPrices(prices) {
-    for (const [symbol, price] of Object.entries(prices)) {
-      this.prices[symbol.toUpperCase()] = price;
-    }
-  }
-  getOHLCV(_symbol, _timeframe) {
-    return [];
-  }
-};
-
-// src/paper/executor.ts
-import { randomUUID } from "crypto";
-var PaperExecutor = class {
-  cash;
-  positions = /* @__PURE__ */ new Map();
-  trades = [];
-  equityCurve = [];
-  slippageBps;
-  feeRate;
-  peakEquity;
-  maxDrawdown = 0;
-  constructor(initialCash = 1e4, slippageBps = 50, feeRate = 2e-3) {
-    this.cash = initialCash;
-    this.slippageBps = slippageBps;
-    this.feeRate = feeRate;
-    this.peakEquity = initialCash;
-    this.recordEquity();
-  }
-  execute(signal, market) {
-    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 / 1e4 * marketPrice;
-    const executedPrice = isBuy ? marketPrice + slippage : marketPrice - slippage;
-    const fee = signal.size * executedPrice * this.feeRate;
-    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;
-      }
-      const proceeds = signal.size * executedPrice - fee;
-      this.cash += proceeds;
-      existing.quantity -= signal.size;
-      if (existing.quantity <= 1e-6) {
-        this.positions.delete(signal.symbol);
-      }
-    }
-    const trade = {
-      id: randomUUID(),
-      symbol: signal.symbol,
-      side: isBuy ? "buy" : "sell",
-      size: signal.size,
-      entryPrice: executedPrice,
-      fee,
-      timestamp: Date.now(),
-      venue: `paper_${signal.venue}`
-    };
-    this.trades.push(trade);
-    this.recordEquity();
-    return trade;
-  }
-  recordEquity() {
-    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;
-  }
-  getEquity() {
-    let positionValue = 0;
-    for (const [, pos] of this.positions) {
-      positionValue += pos.quantity * pos.avgPrice;
-    }
-    return this.cash + positionValue;
-  }
-  getCash() {
-    return this.cash;
-  }
-  getPositions() {
-    return new Map(this.positions);
-  }
-  getTrades() {
-    return [...this.trades];
-  }
-  getEquityCurve() {
-    return [...this.equityCurve];
-  }
-  getMetrics() {
-    const initialEquity = this.equityCurve[0]?.equity || 0;
-    const currentEquity = this.getEquity();
-    const totalReturn = initialEquity > 0 ? (currentEquity - initialEquity) / initialEquity : 0;
-    const dailyReturns = this.calculateDailyReturns();
-    const sharpeRatio = this.calculateSharpe(dailyReturns);
-    let wins = 0;
-    let losses = 0;
-    let grossProfit = 0;
-    let grossLoss = 0;
-    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
-    };
-  }
-  calculateDailyReturns() {
-    if (this.equityCurve.length < 2) return [];
-    const dailyEquity = /* @__PURE__ */ new Map();
-    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 = [];
-    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;
-  }
-  calculateSharpe(returns) {
-    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);
-  }
-};
-
-// src/runtime.ts
-var SDK_VERSION = "0.1.0";
-var AgentRuntime = class {
-  config;
-  relay;
-  signal;
-  store;
-  positions;
-  llm;
-  strategy = null;
-  risk;
-  market;
-  paper = null;
-  mode = "idle";
-  cycleCount = 0;
-  lastCycleAt = 0;
-  tradingInterval = null;
-  running = false;
-  constructor(config) {
-    this.config = config;
-    this.store = new FileStore(`data/${config.agentId}-store.json`);
-    this.positions = new PositionTracker(this.store);
-    this.market = new MarketDataService();
-    this.risk = new RiskManager(
-      {
-        maxPositionSizeBps: config.trading.maxPositionSizeBps,
-        maxDailyLossBps: config.trading.maxDailyLossBps,
-        maxConcurrentPositions: config.trading.maxConcurrentPositions,
-        maxSlippageBps: config.trading.maxSlippageBps,
-        minTradeValueUSD: config.trading.minTradeValueUSD
-      },
-      config.trading.initialCapitalUSD
-    );
-    this.llm = createLLMAdapter(config.llm);
-    this.relay = new RelayClient({
-      url: config.relay.url,
-      agentId: config.agentId,
-      token: config.apiToken,
-      heartbeatIntervalMs: config.relay.heartbeatIntervalMs,
-      reconnectMaxAttempts: config.relay.reconnectMaxAttempts,
-      onCommand: (cmd) => this.handleCommand(cmd),
-      onConnected: () => {
-        console.log(`[runtime] Connected to command center`);
-        this.sendStatus();
-      },
-      onDisconnected: () => {
-        console.log(`[runtime] Disconnected from command center`);
-      }
-    });
-    this.signal = new SignalReporter(this.relay);
-    if (config.trading.mode === "paper") {
-      this.paper = new PaperExecutor(config.trading.initialCapitalUSD ?? 1e4);
-    }
-  }
-  async start() {
-    console.log(`[runtime] Starting agent ${this.config.agentId}`);
-    console.log(`[runtime] Mode: ${this.config.trading.mode}`);
-    console.log(`[runtime] LLM: ${this.config.llm.provider}/${this.config.llm.model}`);
-    try {
-      this.strategy = await loadStrategy(this.config.strategy);
-      console.log(`[runtime] Strategy loaded`);
-    } catch (err) {
-      console.error(`[runtime] Failed to load strategy:`, err.message);
-      this.strategy = null;
-    }
-    try {
-      await this.relay.connect();
-      this.signal.reportInfo("Agent Started", `Agent ${this.config.agentId} connected to command center`);
-    } catch (err) {
-      console.error(`[runtime] Failed to connect to relay:`, err.message);
-      console.log(`[runtime] Will retry in background...`);
-    }
-    this.running = true;
-    this.mode = "idle";
-    this.sendStatus();
-    if (this.config.trading.mode === "paper" || this.config.trading.mode === "live") {
-      this.startTrading();
-    }
-    process.on("SIGTERM", () => this.stop());
-    process.on("SIGINT", () => this.stop());
-  }
-  async stop() {
-    console.log(`[runtime] Stopping agent ${this.config.agentId}`);
-    this.running = false;
-    this.stopTrading();
-    this.signal.reportInfo("Agent Stopped", `Agent ${this.config.agentId} shutting down`);
-    this.relay.disconnect();
-    console.log(`[runtime] Agent stopped`);
-    process.exit(0);
-  }
-  startTrading() {
-    if (this.tradingInterval) return;
-    this.mode = this.config.trading.mode === "paper" ? "paper" : "trading";
-    console.log(`[runtime] Trading started (${this.mode}, interval: ${this.config.trading.tradingIntervalMs}ms)`);
-    this.sendStatus();
-    this.signal.reportInfo("Trading Started", `Mode: ${this.mode}`);
-    this.runCycle();
-    this.tradingInterval = setInterval(() => {
-      this.runCycle();
-    }, this.config.trading.tradingIntervalMs);
-  }
-  stopTrading() {
-    if (this.tradingInterval) {
-      clearInterval(this.tradingInterval);
-      this.tradingInterval = null;
-    }
-    this.mode = "idle";
-    this.sendStatus();
-    console.log(`[runtime] Trading stopped`);
-  }
-  async runCycle() {
-    if (!this.running || !this.strategy) return;
-    this.cycleCount++;
-    this.lastCycleAt = Date.now();
-    try {
-      const prices = this.market.getPrices();
-      const positionSummary = this.positions.getSummary(prices);
-      const signals = await this.strategy({
-        llm: this.llm,
-        market: this.market,
-        position: positionSummary,
-        store: this.store,
-        config: this.config.trading,
-        log: (msg) => {
-          console.log(`[strategy] ${msg}`);
-          this.signal.reportInfo("Strategy Log", msg);
-        }
-      });
-      if (!Array.isArray(signals) || signals.length === 0) {
-        this.sendStatus();
-        return;
-      }
-      const filtered = this.risk.filterSignals(signals, this.market, positionSummary.openPositions.length);
-      for (const sig of filtered) {
-        try {
-          if (this.paper) {
-            const trade = this.paper.execute(sig, this.market);
-            if (trade) {
-              this.signal.reportTrade({
-                ...sig,
-                price: trade.entryPrice,
-                fee: trade.fee,
-                venue: trade.venue,
-                venueFillId: trade.id,
-                venueTimestamp: new Date(trade.timestamp).toISOString()
-              });
-            }
-          } else {
-            console.log(`[runtime] Live trade signal: ${sig.side} ${sig.size} ${sig.symbol}`);
-          }
-        } catch (err) {
-          console.error(`[runtime] Trade execution error:`, err.message);
-          this.signal.reportError("Trade Error", err.message);
-        }
-      }
-    } catch (err) {
-      console.error(`[runtime] Cycle error:`, err.message);
-      this.signal.reportError("Cycle Error", err.message);
-      this.mode = "idle";
-    }
-    this.sendStatus();
-  }
-  handleCommand(command) {
-    console.log(`[runtime] Command received: ${command.type}`);
-    switch (command.type) {
-      case "start_trading":
-        this.startTrading();
-        break;
-      case "stop_trading":
-        this.stopTrading();
-        break;
-      case "update_risk_params":
-        if (command.params) {
-          console.log(`[runtime] Risk params updated`);
-        }
-        break;
-      case "get_status":
-        this.sendStatus();
-        break;
-      case "reload_config":
-        console.log(`[runtime] Config reload requested`);
-        break;
-      default:
-        console.warn(`[runtime] Unknown command: ${command.type}`);
-    }
-  }
-  sendStatus() {
-    const status = {
-      mode: this.mode,
-      agentId: this.config.agentId,
-      sdkVersion: SDK_VERSION,
-      cycleCount: this.cycleCount,
-      lastCycleAt: this.lastCycleAt,
-      tradingIntervalMs: this.config.trading.tradingIntervalMs,
-      llm: {
-        provider: this.config.llm.provider,
-        model: this.config.llm.model || "default"
-      },
-      risk: {
-        dailyPnL: this.risk.getDailyPnL(),
-        dailyLossLimit: this.risk.getDailyLossLimit(),
-        isLimitHit: this.risk.isDailyLossLimitHit()
-      },
-      positions: {
-        openPositions: this.positions.getPositions().length,
-        totalUnrealizedPnL: 0,
-        totalRealizedPnL: this.positions.getRealizedPnL()
-      }
-    };
-    if (this.paper) {
-      const metrics = this.paper.getMetrics();
-      status.paper = {
-        active: true,
-        simulatedValue: this.paper.getEquity(),
-        simulatedPnLPct: metrics.totalReturn * 100
-      };
-      status.portfolioValue = this.paper.getEquity();
-    }
-    this.relay.sendHeartbeat(status);
-  }
-};
-
-export {
-  loadConfig,
-  generateSampleConfig,
-  writeSampleConfig,
-  RelayClient,
-  SignalReporter,
-  FileStore,
-  PositionTracker,
-  createLLMAdapter,
-  getTemplate,
-  listTemplates,
-  loadStrategy,
-  RiskManager,
-  MarketDataService,
-  PaperExecutor,
-  AgentRuntime
-};