@exagent/agent 0.1.0 → 0.1.2

package/dist/chunk-WDT62ZH4.mjs

@@ -0,0 +1,1615 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/llm/base.ts
+var BaseLLMAdapter = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  getMetadata() {
+    return {
+      provider: this.config.provider,
+      model: this.config.model || "unknown",
+      isLocal: this.config.provider === "ollama"
+    };
+  }
+  /**
+   * Format model name for display
+   */
+  getDisplayModel() {
+    if (this.config.provider === "ollama") {
+      return `Local (${this.config.model || "ollama"})`;
+    }
+    return this.config.model || this.config.provider;
+  }
+};
+
+// src/llm/openai.ts
+import OpenAI from "openai";
+var OpenAIAdapter = class extends BaseLLMAdapter {
+  client;
+  constructor(config) {
+    super(config);
+    if (!config.apiKey && !config.endpoint) {
+      throw new Error("OpenAI API key or custom endpoint required");
+    }
+    this.client = new OpenAI({
+      apiKey: config.apiKey || "not-needed-for-custom",
+      baseURL: config.endpoint
+    });
+  }
+  async chat(messages) {
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.config.model || "gpt-4.1",
+        messages: messages.map((m) => ({
+          role: m.role,
+          content: m.content
+        })),
+        temperature: this.config.temperature,
+        max_tokens: this.config.maxTokens
+      });
+      const choice = response.choices[0];
+      if (!choice || !choice.message) {
+        throw new Error("No response from OpenAI");
+      }
+      return {
+        content: choice.message.content || "",
+        usage: response.usage ? {
+          promptTokens: response.usage.prompt_tokens,
+          completionTokens: response.usage.completion_tokens,
+          totalTokens: response.usage.total_tokens
+        } : void 0
+      };
+    } catch (error) {
+      if (error instanceof OpenAI.APIError) {
+        throw new Error(`OpenAI API error: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+
+// src/llm/anthropic.ts
+var AnthropicAdapter = class extends BaseLLMAdapter {
+  apiKey;
+  baseUrl;
+  constructor(config) {
+    super(config);
+    if (!config.apiKey) {
+      throw new Error("Anthropic API key required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.endpoint || "https://api.anthropic.com";
+  }
+  async chat(messages) {
+    const systemMessage = messages.find((m) => m.role === "system");
+    const chatMessages = messages.filter((m) => m.role !== "system");
+    const body = {
+      model: this.config.model || "claude-opus-4-5-20251101",
+      max_tokens: this.config.maxTokens || 4096,
+      temperature: this.config.temperature,
+      system: systemMessage?.content,
+      messages: chatMessages.map((m) => ({
+        role: m.role,
+        content: m.content
+      }))
+    };
+    const response = await fetch(`${this.baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    const content = data.content?.map(
+      (block) => block.type === "text" ? block.text : ""
+    ).join("") || "";
+    return {
+      content,
+      usage: data.usage ? {
+        promptTokens: data.usage.input_tokens,
+        completionTokens: data.usage.output_tokens,
+        totalTokens: data.usage.input_tokens + data.usage.output_tokens
+      } : void 0
+    };
+  }
+};
+
+// src/llm/ollama.ts
+var OllamaAdapter = class extends BaseLLMAdapter {
+  baseUrl;
+  constructor(config) {
+    super(config);
+    this.baseUrl = config.endpoint || "http://localhost:11434";
+  }
+  /**
+   * Check if Ollama is running and the model is available
+   */
+  async healthCheck() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/tags`);
+      if (!response.ok) {
+        throw new Error("Ollama server not responding");
+      }
+      const data = await response.json();
+      const models = data.models?.map((m) => m.name) || [];
+      if (this.config.model && !models.some((m) => m.startsWith(this.config.model))) {
+        console.warn(
+          `Model "${this.config.model}" not found locally. Available: ${models.join(", ")}`
+        );
+        console.warn(`Run: ollama pull ${this.config.model}`);
+      }
+    } catch (error) {
+      throw new Error(
+        `Cannot connect to Ollama at ${this.baseUrl}. Make sure Ollama is running (ollama serve) or install it from https://ollama.com`
+      );
+    }
+  }
+  async chat(messages) {
+    const body = {
+      model: this.config.model || "llama3.2",
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      stream: false,
+      options: {
+        temperature: this.config.temperature,
+        num_predict: this.config.maxTokens
+      }
+    };
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Ollama API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    return {
+      content: data.message?.content || "",
+      usage: data.eval_count ? {
+        promptTokens: data.prompt_eval_count || 0,
+        completionTokens: data.eval_count,
+        totalTokens: (data.prompt_eval_count || 0) + data.eval_count
+      } : void 0
+    };
+  }
+  getMetadata() {
+    return {
+      provider: "ollama",
+      model: this.config.model || "llama3.2",
+      isLocal: true
+    };
+  }
+};
+
+// src/llm/google.ts
+var GoogleAdapter = class extends BaseLLMAdapter {
+  apiKey;
+  baseUrl;
+  constructor(config) {
+    super(config);
+    if (!config.apiKey) {
+      throw new Error("Google AI API key required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.endpoint || "https://generativelanguage.googleapis.com/v1beta";
+  }
+  async chat(messages) {
+    const model = this.config.model || "gemini-2.5-flash";
+    const systemMessage = messages.find((m) => m.role === "system");
+    const chatMessages = messages.filter((m) => m.role !== "system");
+    const contents = chatMessages.map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    }));
+    const body = {
+      contents,
+      generationConfig: {
+        temperature: this.config.temperature,
+        maxOutputTokens: this.config.maxTokens || 4096
+      }
+    };
+    if (systemMessage) {
+      body.systemInstruction = {
+        parts: [{ text: systemMessage.content }]
+      };
+    }
+    const url = `${this.baseUrl}/models/${model}:generateContent?key=${this.apiKey}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Google AI API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    const candidate = data.candidates?.[0];
+    if (!candidate?.content?.parts) {
+      throw new Error("No response from Google AI");
+    }
+    const content = candidate.content.parts.map((part) => part.text || "").join("");
+    const usageMetadata = data.usageMetadata;
+    return {
+      content,
+      usage: usageMetadata ? {
+        promptTokens: usageMetadata.promptTokenCount || 0,
+        completionTokens: usageMetadata.candidatesTokenCount || 0,
+        totalTokens: usageMetadata.totalTokenCount || 0
+      } : void 0
+    };
+  }
+};
+
+// src/llm/adapter.ts
+async 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 "ollama":
+      const adapter = new OllamaAdapter(config);
+      await adapter.healthCheck();
+      return adapter;
+    case "custom":
+      return new OpenAIAdapter({
+        ...config,
+        endpoint: config.endpoint
+      });
+    default:
+      throw new Error(`Unsupported LLM provider: ${config.provider}`);
+  }
+}
+
+// src/strategy/loader.ts
+import { existsSync } from "fs";
+import { join } from "path";
+import { spawn } from "child_process";
+async function loadStrategy(strategyPath) {
+  const basePath = strategyPath || process.env.EXAGENT_STRATEGY || "strategy";
+  const tsPath = basePath.endsWith(".ts") || basePath.endsWith(".js") ? basePath : `${basePath}.ts`;
+  const jsPath = basePath.endsWith(".ts") || basePath.endsWith(".js") ? basePath.replace(".ts", ".js") : `${basePath}.js`;
+  const fullTsPath = tsPath.startsWith("/") ? tsPath : join(process.cwd(), tsPath);
+  const fullJsPath = jsPath.startsWith("/") ? jsPath : join(process.cwd(), jsPath);
+  if (existsSync(fullTsPath) && fullTsPath.endsWith(".ts")) {
+    try {
+      const module = await loadTypeScriptModule(fullTsPath);
+      if (typeof module.generateSignals !== "function") {
+        throw new Error("Strategy must export a generateSignals function");
+      }
+      console.log(`Loaded custom strategy from ${tsPath}`);
+      return module.generateSignals;
+    } catch (error) {
+      console.error(`Failed to load strategy from ${tsPath}:`, error);
+      throw error;
+    }
+  }
+  if (existsSync(fullJsPath)) {
+    try {
+      const module = await import(fullJsPath);
+      if (typeof module.generateSignals !== "function") {
+        throw new Error("Strategy must export a generateSignals function");
+      }
+      console.log(`Loaded custom strategy from ${jsPath}`);
+      return module.generateSignals;
+    } catch (error) {
+      console.error(`Failed to load strategy from ${jsPath}:`, error);
+      throw error;
+    }
+  }
+  console.log("No custom strategy found, using default (hold) strategy");
+  return defaultStrategy;
+}
+async function loadTypeScriptModule(path) {
+  try {
+    const tsxPath = __require.resolve("tsx");
+    const { pathToFileURL } = await import("url");
+    const result = await new Promise((resolve, reject) => {
+      const child = spawn(
+        process.execPath,
+        [
+          "--import",
+          "tsx/esm",
+          "-e",
+          `import('${pathToFileURL(path).href}').then(m => console.log(JSON.stringify({ exports: Object.keys(m) }))).catch(e => console.error('ERROR:', e.message))`
+        ],
+        {
+          cwd: process.cwd(),
+          env: process.env,
+          stdio: ["pipe", "pipe", "pipe"]
+        }
+      );
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (data) => stdout += data.toString());
+      child.stderr.on("data", (data) => stderr += data.toString());
+      child.on("close", (code) => {
+        if (code !== 0 || stderr.includes("ERROR:")) {
+          reject(new Error(`Failed to load TypeScript: ${stderr || "Unknown error"}`));
+        } else {
+          resolve(stdout);
+        }
+      });
+    });
+    const tsx = await import("tsx/esm/api");
+    const unregister = tsx.register();
+    try {
+      const module = await import(path);
+      return module;
+    } finally {
+      unregister();
+    }
+  } catch (error) {
+    if (error.code === "MODULE_NOT_FOUND" || error.message.includes("Cannot find module")) {
+      throw new Error(
+        `Cannot load TypeScript strategy. Please either:
+1. Rename your strategy.ts to strategy.js (remove type annotations)
+2. Or compile it: npx tsc strategy.ts --outDir . --esModuleInterop
+3. Or install tsx: npm install tsx`
+      );
+    }
+    throw error;
+  }
+}
+var defaultStrategy = async (_marketData, _llm, _config) => {
+  return [];
+};
+function validateStrategy(fn) {
+  return typeof fn === "function";
+}
+
+// src/strategy/templates.ts
+var STRATEGY_TEMPLATES = [
+  {
+    id: "momentum",
+    name: "Momentum Trader",
+    description: "Follows price trends and momentum indicators. Buys assets with strong upward momentum.",
+    riskLevel: "medium",
+    riskWarnings: [
+      "Momentum strategies can suffer significant losses during trend reversals",
+      "High volatility markets may generate false signals",
+      "Past performance does not guarantee future results",
+      "This strategy may underperform in sideways markets"
+    ],
+    systemPrompt: `You are an AI trading analyst specializing in momentum trading strategies.
+
+Your role is to analyze market data and identify momentum-based trading opportunities.
+
+IMPORTANT CONSTRAINTS:
+- Only recommend trades when there is clear momentum evidence
+- Always consider risk/reward ratios
+- Never recommend more than the configured position size limits
+- Be conservative with confidence scores
+
+When analyzing data, look for:
+1. Price trends (higher highs, higher lows for uptrends)
+2. Volume confirmation (increasing volume on moves)
+3. Relative strength vs market benchmarks
+
+Respond with JSON in this format:
+{
+  "analysis": "Brief market analysis",
+  "signals": [
+    {
+      "action": "buy" | "sell" | "hold",
+      "tokenIn": "0x...",
+      "tokenOut": "0x...",
+      "percentage": 0-100,
+      "confidence": 0-1,
+      "reasoning": "Why this trade"
+    }
+  ]
+}`,
+    exampleCode: `import { StrategyFunction, MarketData, TradeSignal, LLMAdapter, AgentConfig } from '@exagent/agent';
+
+export const generateSignals: StrategyFunction = async (
+  marketData: MarketData,
+  llm: LLMAdapter,
+  config: AgentConfig
+): Promise<TradeSignal[]> => {
+  const response = await llm.chat([
+    { role: 'system', content: MOMENTUM_SYSTEM_PROMPT },
+    { role: 'user', content: JSON.stringify({
+      prices: marketData.prices,
+      balances: formatBalances(marketData.balances),
+      portfolioValue: marketData.portfolioValue,
+    })}
+  ]);
+
+  // Parse LLM response and convert to TradeSignals
+  const parsed = JSON.parse(response.content);
+  return parsed.signals.map(convertToTradeSignal);
+};`
+  },
+  {
+    id: "value",
+    name: "Value Investor",
+    description: "Looks for undervalued assets based on fundamentals. Takes long-term positions.",
+    riskLevel: "low",
+    riskWarnings: [
+      "Value traps can result in prolonged losses",
+      "Requires patience - may underperform for extended periods",
+      "Fundamental analysis may not apply well to all crypto assets",
+      "Market sentiment can override fundamentals for long periods"
+    ],
+    systemPrompt: `You are an AI trading analyst specializing in value investing.
+
+Your role is to identify undervalued assets with strong fundamentals.
+
+IMPORTANT CONSTRAINTS:
+- Focus on long-term value, not short-term price movements
+- Only recommend assets with clear value propositions
+- Consider protocol revenue, TVL, active users, developer activity
+- Be very selective - quality over quantity
+
+When analyzing, consider:
+1. Protocol fundamentals (revenue, TVL, user growth)
+2. Token economics (supply schedule, utility)
+3. Competitive positioning
+4. Valuation relative to peers
+
+Respond with JSON in this format:
+{
+  "analysis": "Brief fundamental analysis",
+  "signals": [
+    {
+      "action": "buy" | "sell" | "hold",
+      "tokenIn": "0x...",
+      "tokenOut": "0x...",
+      "percentage": 0-100,
+      "confidence": 0-1,
+      "reasoning": "Fundamental thesis"
+    }
+  ]
+}`,
+    exampleCode: `import { StrategyFunction } from '@exagent/agent';
+
+export const generateSignals: StrategyFunction = async (marketData, llm, config) => {
+  // Value strategy runs less frequently
+  const response = await llm.chat([
+    { role: 'system', content: VALUE_SYSTEM_PROMPT },
+    { role: 'user', content: JSON.stringify(marketData) }
+  ]);
+
+  return parseSignals(response.content);
+};`
+  },
+  {
+    id: "arbitrage",
+    name: "Arbitrage Hunter",
+    description: "Looks for price discrepancies across DEXs. Requires fast execution.",
+    riskLevel: "high",
+    riskWarnings: [
+      "Arbitrage opportunities are highly competitive - professional bots dominate",
+      "Slippage and gas costs can eliminate profits",
+      "MEV bots may front-run your transactions",
+      "Requires very fast execution and may not be profitable with standard infrastructure",
+      "This strategy is generally NOT recommended for beginners"
+    ],
+    systemPrompt: `You are an AI trading analyst specializing in arbitrage detection.
+
+Your role is to identify price discrepancies that may offer arbitrage opportunities.
+
+IMPORTANT CONSTRAINTS:
+- Account for gas costs in all calculations
+- Account for slippage (assume 0.3% minimum)
+- Only flag opportunities with >1% net profit potential
+- Consider MEV risk - assume some profit extraction
+
+This is an advanced strategy with high competition.
+
+Respond with JSON in this format:
+{
+  "opportunities": [
+    {
+      "description": "What the arbitrage is",
+      "expectedProfit": "Net profit after costs",
+      "confidence": 0-1,
+      "warning": "Risks specific to this opportunity"
+    }
+  ]
+}`,
+    exampleCode: `// Note: Pure arbitrage requires specialized infrastructure
+// This template is for educational purposes
+
+import { StrategyFunction } from '@exagent/agent';
+
+export const generateSignals: StrategyFunction = async (marketData, llm, config) => {
+  // Arbitrage requires real-time price feeds from multiple sources
+  // Standard LLM-based analysis is too slow for most arbitrage
+  console.warn('Arbitrage strategy requires specialized infrastructure');
+  return [];
+};`
+  },
+  {
+    id: "custom",
+    name: "Custom Strategy",
+    description: "Build your own strategy from scratch. Full control over logic and prompts.",
+    riskLevel: "extreme",
+    riskWarnings: [
+      "Custom strategies have no guardrails - you are fully responsible",
+      "LLMs can hallucinate or make errors - always validate outputs",
+      "Test thoroughly on testnet before using real funds",
+      "Consider edge cases: what happens if the LLM returns invalid JSON?",
+      "Your prompts and strategy logic are your competitive advantage - protect them",
+      "Agents may not behave exactly as expected based on your prompts"
+    ],
+    systemPrompt: `// Define your own system prompt here
+
+You are a trading AI. Analyze the market data and provide trading signals.
+
+// Add your specific instructions, constraints, and output format.
+
+Respond with JSON:
+{
+  "signals": []
+}`,
+    exampleCode: `import { StrategyFunction, MarketData, TradeSignal, LLMAdapter, AgentConfig } from '@exagent/agent';
+
+/**
+ * Custom Strategy Template
+ *
+ * Customize this file with your own trading logic and prompts.
+ * Your prompts are YOUR intellectual property - we don't store them.
+ */
+export const generateSignals: StrategyFunction = async (
+  marketData: MarketData,
+  llm: LLMAdapter,
+  config: AgentConfig
+): Promise<TradeSignal[]> => {
+  // Your custom system prompt (this is your secret sauce)
+  const systemPrompt = \`
+    Your custom instructions here...
+  \`;
+
+  // Call the LLM with your prompt
+  const response = await llm.chat([
+    { role: 'system', content: systemPrompt },
+    { role: 'user', content: JSON.stringify(marketData) }
+  ]);
+
+  // Parse and return signals
+  // IMPORTANT: Validate LLM output before using
+  try {
+    const parsed = JSON.parse(response.content);
+    return parsed.signals || [];
+  } catch (e) {
+    console.error('Failed to parse LLM response:', e);
+    return []; // Safe fallback: no trades
+  }
+};`
+  }
+];
+function getStrategyTemplate(id) {
+  return STRATEGY_TEMPLATES.find((t) => t.id === id);
+}
+function getAllStrategyTemplates() {
+  return STRATEGY_TEMPLATES;
+}
+
+// src/trading/executor.ts
+var TradeExecutor = class {
+  client;
+  config;
+  constructor(client, config) {
+    this.client = client;
+    this.config = config;
+  }
+  /**
+   * Execute a single trade signal
+   */
+  async execute(signal) {
+    if (signal.action === "hold") {
+      return { success: true };
+    }
+    try {
+      console.log(`Executing ${signal.action}: ${signal.tokenIn} -> ${signal.tokenOut}`);
+      console.log(`Amount: ${signal.amountIn.toString()}, Confidence: ${signal.confidence}`);
+      if (!this.validateSignal(signal)) {
+        return { success: false, error: "Signal exceeds position limits" };
+      }
+      const result = await this.client.trade({
+        tokenIn: signal.tokenIn,
+        tokenOut: signal.tokenOut,
+        amountIn: signal.amountIn,
+        maxSlippageBps: 100
+        // 1% default slippage
+      });
+      console.log(`Trade executed: ${result.hash}`);
+      return { success: true, txHash: result.hash };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(`Trade failed: ${message}`);
+      return { success: false, error: message };
+    }
+  }
+  /**
+   * Execute multiple trade signals
+   * Returns results for each signal
+   */
+  async executeAll(signals) {
+    const results = [];
+    for (const signal of signals) {
+      const result = await this.execute(signal);
+      results.push({ signal, ...result });
+      if (signals.indexOf(signal) < signals.length - 1) {
+        await this.delay(1e3);
+      }
+    }
+    return results;
+  }
+  /**
+   * Validate a signal against config limits
+   */
+  validateSignal(signal) {
+    if (signal.confidence < 0.5) {
+      console.warn(`Signal confidence ${signal.confidence} below threshold (0.5)`);
+      return false;
+    }
+    return true;
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/trading/risk.ts
+var RiskManager = class {
+  config;
+  dailyPnL = 0;
+  lastResetDate = "";
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Filter signals through risk checks
+   * Returns only signals that pass all guardrails
+   */
+  filterSignals(signals, marketData) {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    if (today !== this.lastResetDate) {
+      this.dailyPnL = 0;
+      this.lastResetDate = today;
+    }
+    if (this.isDailyLossLimitHit(marketData.portfolioValue)) {
+      console.warn("Daily loss limit reached - no new trades");
+      return [];
+    }
+    return signals.filter((signal) => this.validateSignal(signal, marketData));
+  }
+  /**
+   * Validate individual signal against risk limits
+   */
+  validateSignal(signal, marketData) {
+    if (signal.action === "hold") {
+      return true;
+    }
+    const signalValue = this.estimateSignalValue(signal, marketData);
+    const maxPositionValue = marketData.portfolioValue * this.config.maxPositionSizeBps / 1e4;
+    if (signalValue > maxPositionValue) {
+      console.warn(
+        `Signal exceeds position limit: ${signalValue.toFixed(2)} > ${maxPositionValue.toFixed(2)}`
+      );
+      return false;
+    }
+    if (signal.confidence < 0.5) {
+      console.warn(`Signal confidence too low: ${signal.confidence}`);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Check if daily loss limit has been hit
+   */
+  isDailyLossLimitHit(portfolioValue) {
+    const maxLoss = portfolioValue * this.config.maxDailyLossBps / 1e4;
+    return this.dailyPnL < -maxLoss;
+  }
+  /**
+   * Estimate USD value of a trade signal
+   */
+  estimateSignalValue(signal, marketData) {
+    const price = marketData.prices[signal.tokenIn] || 0;
+    const amount = Number(signal.amountIn) / 1e18;
+    return amount * price;
+  }
+  /**
+   * Update daily PnL after a trade
+   */
+  updatePnL(pnl) {
+    this.dailyPnL += pnl;
+  }
+  /**
+   * Get current risk status
+   */
+  getStatus() {
+    return {
+      dailyPnL: this.dailyPnL,
+      dailyLossLimit: this.config.maxDailyLossBps / 100,
+      // As percentage
+      isLimitHit: this.dailyPnL < -(this.config.maxDailyLossBps / 100)
+    };
+  }
+};
+
+// src/trading/market.ts
+var MarketDataService = class {
+  rpcUrl;
+  constructor(rpcUrl) {
+    this.rpcUrl = rpcUrl;
+  }
+  /**
+   * Fetch current market data for the agent
+   */
+  async fetchMarketData(walletAddress, tokenAddresses) {
+    const prices = await this.fetchPrices(tokenAddresses);
+    const balances = await this.fetchBalances(walletAddress, tokenAddresses);
+    const portfolioValue = this.calculatePortfolioValue(balances, prices);
+    return {
+      timestamp: Date.now(),
+      prices,
+      balances,
+      portfolioValue
+    };
+  }
+  /**
+   * Fetch token prices from price oracle
+   */
+  async fetchPrices(tokenAddresses) {
+    const prices = {};
+    const knownPrices = {
+      // WETH
+      "0x4200000000000000000000000000000000000006": 3500,
+      // USDC
+      "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913": 1,
+      // USDbC (bridged USDC)
+      "0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA": 1
+    };
+    for (const address of tokenAddresses) {
+      prices[address.toLowerCase()] = knownPrices[address.toLowerCase()] || 0;
+    }
+    return prices;
+  }
+  /**
+   * Fetch token balances from chain
+   */
+  async fetchBalances(walletAddress, tokenAddresses) {
+    const balances = {};
+    for (const address of tokenAddresses) {
+      balances[address.toLowerCase()] = 0n;
+    }
+    return balances;
+  }
+  /**
+   * Calculate total portfolio value in USD
+   */
+  calculatePortfolioValue(balances, prices) {
+    let total = 0;
+    for (const [address, balance] of Object.entries(balances)) {
+      const price = prices[address.toLowerCase()] || 0;
+      const amount = Number(balance) / 1e18;
+      total += amount * price;
+    }
+    return total;
+  }
+};
+
+// src/vault/manager.ts
+import { createPublicClient, createWalletClient, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { baseSepolia, base } from "viem/chains";
+var ADDRESSES = {
+  testnet: {
+    vaultFactory: "0x5c099daaE33801a907Bb57011c6749655b55dc75",
+    registry: "0xCF48C341e3FebeCA5ECB7eb2535f61A2Ba855d9C",
+    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+  },
+  mainnet: {
+    vaultFactory: "0x0000000000000000000000000000000000000000",
+    // TODO: Deploy
+    registry: "0x0000000000000000000000000000000000000000",
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+    // Base mainnet USDC
+  }
+};
+var VAULT_FACTORY_ABI = [
+  {
+    type: "function",
+    name: "vaults",
+    inputs: [{ name: "agentId", type: "uint256" }, { name: "asset", type: "address" }],
+    outputs: [{ type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "canCreateVault",
+    inputs: [{ name: "creator", type: "address" }],
+    outputs: [{ name: "canCreate", type: "bool" }, { name: "reason", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "createVault",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "asset", type: "address" },
+      { name: "name", type: "string" },
+      { name: "symbol", type: "string" },
+      { name: "feeRecipient", type: "address" }
+    ],
+    outputs: [{ type: "address" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "minimumVeEXARequired",
+    inputs: [],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "eXABurnFee",
+    inputs: [],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  }
+];
+var VAULT_ABI = [
+  {
+    type: "function",
+    name: "totalAssets",
+    inputs: [],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "executeTrade",
+    inputs: [
+      { name: "tokenIn", type: "address" },
+      { name: "tokenOut", type: "address" },
+      { name: "amountIn", type: "uint256" },
+      { name: "minAmountOut", type: "uint256" },
+      { name: "aggregator", type: "address" },
+      { name: "swapData", type: "bytes" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "nonpayable"
+  }
+];
+var VaultManager = class {
+  config;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  publicClient;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  walletClient;
+  addresses;
+  account;
+  chain;
+  cachedVaultAddress = null;
+  lastVaultCheck = 0;
+  VAULT_CACHE_TTL = 6e4;
+  // 1 minute
+  constructor(config) {
+    this.config = config;
+    this.addresses = ADDRESSES[config.network];
+    this.account = privateKeyToAccount(config.walletKey);
+    this.chain = config.network === "mainnet" ? base : baseSepolia;
+    const rpcUrl = config.network === "mainnet" ? "https://mainnet.base.org" : "https://sepolia.base.org";
+    this.publicClient = createPublicClient({
+      chain: this.chain,
+      transport: http(rpcUrl)
+    });
+    this.walletClient = createWalletClient({
+      account: this.account,
+      chain: this.chain,
+      transport: http(rpcUrl)
+    });
+  }
+  /**
+   * Get the agent's vault policy
+   */
+  get policy() {
+    return this.config.vaultConfig.policy;
+  }
+  /**
+   * Check if vault trading is preferred when a vault exists
+   */
+  get preferVaultTrading() {
+    return this.config.vaultConfig.preferVaultTrading;
+  }
+  /**
+   * Get comprehensive vault status
+   */
+  async getVaultStatus() {
+    const vaultAddress = await this.getVaultAddress();
+    const hasVault = vaultAddress !== null;
+    let totalAssets = BigInt(0);
+    if (hasVault && vaultAddress) {
+      try {
+        totalAssets = await this.publicClient.readContract({
+          address: vaultAddress,
+          abi: VAULT_ABI,
+          functionName: "totalAssets"
+        });
+      } catch {
+      }
+    }
+    const [canCreateResult, requirements] = await Promise.all([
+      this.publicClient.readContract({
+        address: this.addresses.vaultFactory,
+        abi: VAULT_FACTORY_ABI,
+        functionName: "canCreateVault",
+        args: [this.account.address]
+      }),
+      this.getRequirements()
+    ]);
+    return {
+      hasVault,
+      vaultAddress,
+      totalAssets,
+      canCreateVault: canCreateResult[0],
+      cannotCreateReason: canCreateResult[0] ? null : canCreateResult[1],
+      requirementsMet: canCreateResult[0] || requirements.isBypassed,
+      requirements
+    };
+  }
+  /**
+   * Get vault creation requirements
+   */
+  async getRequirements() {
+    const [veXARequired, burnFee] = await Promise.all([
+      this.publicClient.readContract({
+        address: this.addresses.vaultFactory,
+        abi: VAULT_FACTORY_ABI,
+        functionName: "minimumVeEXARequired"
+      }),
+      this.publicClient.readContract({
+        address: this.addresses.vaultFactory,
+        abi: VAULT_FACTORY_ABI,
+        functionName: "eXABurnFee"
+      })
+    ]);
+    const isBypassed = veXARequired === BigInt(0) && burnFee === BigInt(0);
+    return { veXARequired, burnFee, isBypassed };
+  }
+  /**
+   * Get the agent's vault address (cached)
+   */
+  async getVaultAddress() {
+    const now = Date.now();
+    if (this.cachedVaultAddress && now - this.lastVaultCheck < this.VAULT_CACHE_TTL) {
+      return this.cachedVaultAddress;
+    }
+    const vaultAddress = await this.publicClient.readContract({
+      address: this.addresses.vaultFactory,
+      abi: VAULT_FACTORY_ABI,
+      functionName: "vaults",
+      args: [this.config.agentId, this.addresses.usdc]
+    });
+    this.lastVaultCheck = now;
+    if (vaultAddress === "0x0000000000000000000000000000000000000000") {
+      this.cachedVaultAddress = null;
+      return null;
+    }
+    this.cachedVaultAddress = vaultAddress;
+    return vaultAddress;
+  }
+  /**
+   * Check if the agent should create a vault based on policy and qualification
+   */
+  async shouldCreateVault() {
+    if (this.policy === "disabled") {
+      return { should: false, reason: "Vault creation disabled by policy" };
+    }
+    if (this.policy === "manual") {
+      return { should: false, reason: "Vault creation set to manual - waiting for owner instruction" };
+    }
+    const status = await this.getVaultStatus();
+    if (status.hasVault) {
+      return { should: false, reason: "Vault already exists" };
+    }
+    if (!status.canCreateVault) {
+      return { should: false, reason: status.cannotCreateReason || "Requirements not met" };
+    }
+    return { should: true, reason: "Agent is qualified and auto-creation is enabled" };
+  }
+  /**
+   * Create a vault for the agent
+   * @returns Vault address if successful
+   */
+  async createVault() {
+    if (this.policy === "disabled") {
+      return { success: false, error: "Vault creation disabled by policy" };
+    }
+    const existingVault = await this.getVaultAddress();
+    if (existingVault) {
+      return { success: false, error: "Vault already exists", vaultAddress: existingVault };
+    }
+    const status = await this.getVaultStatus();
+    if (!status.canCreateVault) {
+      return { success: false, error: status.cannotCreateReason || "Requirements not met" };
+    }
+    const vaultName = this.config.vaultConfig.defaultName || `${this.config.agentName} Trading Vault`;
+    const vaultSymbol = this.config.vaultConfig.defaultSymbol || `ex${this.config.agentName.replace(/[^a-zA-Z]/g, "").slice(0, 4).toUpperCase()}`;
+    const feeRecipient = this.config.vaultConfig.feeRecipient || this.account.address;
+    try {
+      const hash = await this.walletClient.writeContract({
+        address: this.addresses.vaultFactory,
+        abi: VAULT_FACTORY_ABI,
+        functionName: "createVault",
+        args: [
+          this.config.agentId,
+          this.addresses.usdc,
+          vaultName,
+          vaultSymbol,
+          feeRecipient
+        ],
+        chain: this.chain,
+        account: this.account
+      });
+      const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+      if (receipt.status !== "success") {
+        return { success: false, error: "Transaction failed", txHash: hash };
+      }
+      const vaultAddress = await this.getVaultAddress();
+      this.cachedVaultAddress = vaultAddress;
+      return {
+        success: true,
+        vaultAddress,
+        txHash: hash
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Execute a trade through the vault (if it exists and policy allows)
+   * Returns null if should use direct trading instead
+   */
+  async executeVaultTrade(params) {
+    if (!this.preferVaultTrading) {
+      return null;
+    }
+    const vaultAddress = await this.getVaultAddress();
+    if (!vaultAddress) {
+      return null;
+    }
+    const deadline = params.deadline || BigInt(Math.floor(Date.now() / 1e3) + 3600);
+    try {
+      const hash = await this.walletClient.writeContract({
+        address: vaultAddress,
+        abi: VAULT_ABI,
+        functionName: "executeTrade",
+        args: [
+          params.tokenIn,
+          params.tokenOut,
+          params.amountIn,
+          params.minAmountOut,
+          params.aggregator,
+          params.swapData,
+          deadline
+        ],
+        chain: this.chain,
+        account: this.account
+      });
+      return { usedVault: true, txHash: hash };
+    } catch (error) {
+      return {
+        usedVault: true,
+        error: error instanceof Error ? error.message : "Vault trade failed"
+      };
+    }
+  }
+  /**
+   * Run the auto-creation check (call this periodically in the agent loop)
+   * Only creates vault if policy is 'auto_when_qualified'
+   */
+  async checkAndAutoCreateVault() {
+    const shouldCreate = await this.shouldCreateVault();
+    if (!shouldCreate.should) {
+      const status = await this.getVaultStatus();
+      if (status.hasVault) {
+        return { action: "already_exists", vaultAddress: status.vaultAddress, reason: "Vault already exists" };
+      }
+      if (this.policy !== "auto_when_qualified") {
+        return { action: "skipped", reason: shouldCreate.reason };
+      }
+      return { action: "not_qualified", reason: shouldCreate.reason };
+    }
+    const result = await this.createVault();
+    if (result.success) {
+      return {
+        action: "created",
+        vaultAddress: result.vaultAddress,
+        reason: "Vault created automatically"
+      };
+    }
+    return { action: "not_qualified", reason: result.error || "Creation failed" };
+  }
+};
+
+// src/runtime.ts
+import { ExagentClient, ExagentRegistry } from "@exagent/sdk";
+var AgentRuntime = class {
+  config;
+  client;
+  llm;
+  strategy;
+  executor;
+  riskManager;
+  marketData;
+  vaultManager;
+  isRunning = false;
+  configHash;
+  lastVaultCheck = 0;
+  VAULT_CHECK_INTERVAL = 3e5;
+  // Check vault status every 5 minutes
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Initialize the agent runtime
+   */
+  async initialize() {
+    console.log(`Initializing agent: ${this.config.name} (ID: ${this.config.agentId})`);
+    this.client = new ExagentClient({
+      privateKey: this.config.privateKey,
+      network: this.config.network
+    });
+    console.log(`Wallet: ${this.client.address}`);
+    const agent = await this.client.registry.getAgent(BigInt(this.config.agentId));
+    if (!agent) {
+      throw new Error(`Agent ID ${this.config.agentId} not found on-chain. Please register first.`);
+    }
+    console.log(`Agent verified: ${agent.name}`);
+    await this.ensureWalletLinked();
+    console.log(`Initializing LLM: ${this.config.llm.provider}`);
+    this.llm = await createLLMAdapter(this.config.llm);
+    const llmMeta = this.llm.getMetadata();
+    console.log(`LLM ready: ${llmMeta.provider} (${llmMeta.model})`);
+    await this.syncConfigHash();
+    this.strategy = await loadStrategy();
+    this.executor = new TradeExecutor(this.client, this.config);
+    this.riskManager = new RiskManager(this.config.trading);
+    this.marketData = new MarketDataService(this.getRpcUrl());
+    await this.initializeVaultManager();
+    console.log("Agent initialized successfully");
+  }
+  /**
+   * Initialize the vault manager based on config
+   */
+  async initializeVaultManager() {
+    const vaultConfig = this.config.vault || { policy: "disabled", preferVaultTrading: false };
+    this.vaultManager = new VaultManager({
+      agentId: BigInt(this.config.agentId),
+      agentName: this.config.name,
+      network: this.config.network,
+      walletKey: this.config.privateKey,
+      vaultConfig
+    });
+    console.log(`Vault policy: ${vaultConfig.policy}`);
+    const status = await this.vaultManager.getVaultStatus();
+    if (status.hasVault) {
+      console.log(`Vault exists: ${status.vaultAddress}`);
+      console.log(`Vault TVL: ${Number(status.totalAssets) / 1e6} USDC`);
+    } else {
+      console.log("No vault exists for this agent");
+      if (vaultConfig.policy === "auto_when_qualified") {
+        if (status.canCreateVault) {
+          console.log("Agent is qualified to create vault - will attempt on next check");
+        } else {
+          console.log(`Cannot create vault yet: ${status.cannotCreateReason}`);
+        }
+      }
+    }
+  }
+  /**
+   * Ensure the current wallet is linked to the agent
+   */
+  async ensureWalletLinked() {
+    const agentId = BigInt(this.config.agentId);
+    const address = this.client.address;
+    const isLinked = await this.client.registry.isLinkedWallet(agentId, address);
+    if (!isLinked) {
+      console.log("Wallet not linked, linking now...");
+      const agent = await this.client.registry.getAgent(agentId);
+      if (agent?.owner.toLowerCase() !== address.toLowerCase()) {
+        throw new Error(
+          `Cannot link wallet: ${address} is not the owner of agent ${this.config.agentId}. Owner is ${agent?.owner}`
+        );
+      }
+      await this.client.registry.linkOwnWallet(agentId);
+      console.log("Wallet linked successfully");
+    } else {
+      console.log("Wallet already linked");
+    }
+  }
+  /**
+   * Sync the LLM config hash to chain for epoch tracking
+   * This ensures trades are attributed to the correct config epoch
+   */
+  async syncConfigHash() {
+    const agentId = BigInt(this.config.agentId);
+    const llmMeta = this.llm.getMetadata();
+    this.configHash = ExagentRegistry.calculateConfigHash(llmMeta.provider, llmMeta.model);
+    console.log(`Config hash: ${this.configHash}`);
+    const onChainHash = await this.client.registry.getConfigHash(agentId);
+    if (onChainHash !== this.configHash) {
+      console.log("Config changed, updating on-chain...");
+      await this.client.registry.updateConfig(agentId, this.configHash);
+      const newEpoch = await this.client.registry.getCurrentEpoch(agentId);
+      console.log(`Config updated, new epoch started: ${newEpoch}`);
+    } else {
+      const currentEpoch = await this.client.registry.getCurrentEpoch(agentId);
+      console.log(`Config hash matches on-chain (epoch ${currentEpoch})`);
+    }
+  }
+  /**
+   * Get the current config hash (for trade execution)
+   */
+  getConfigHash() {
+    return this.configHash;
+  }
+  /**
+   * Start the trading loop
+   */
+  async run() {
+    if (this.isRunning) {
+      throw new Error("Agent is already running");
+    }
+    this.isRunning = true;
+    console.log("Starting trading loop...");
+    console.log(`Interval: ${this.config.trading.tradingIntervalMs}ms`);
+    while (this.isRunning) {
+      try {
+        await this.runCycle();
+      } catch (error) {
+        console.error("Error in trading cycle:", error);
+      }
+      await this.sleep(this.config.trading.tradingIntervalMs);
+    }
+  }
+  /**
+   * Run a single trading cycle
+   */
+  async runCycle() {
+    console.log(`
+--- Trading Cycle: ${(/* @__PURE__ */ new Date()).toISOString()} ---`);
+    await this.checkVaultAutoCreation();
+    const tokens = this.config.allowedTokens || this.getDefaultTokens();
+    const marketData = await this.marketData.fetchMarketData(this.client.address, tokens);
+    console.log(`Portfolio value: $${marketData.portfolioValue.toFixed(2)}`);
+    const signals = await this.strategy(marketData, this.llm, this.config);
+    console.log(`Strategy generated ${signals.length} signals`);
+    const filteredSignals = this.riskManager.filterSignals(signals, marketData);
+    console.log(`${filteredSignals.length} signals passed risk checks`);
+    if (filteredSignals.length > 0) {
+      const results = await this.executor.executeAll(filteredSignals);
+      for (const result of results) {
+        if (result.success) {
+          console.log(`Trade executed: ${result.signal.action} - ${result.txHash}`);
+        } else {
+          console.warn(`Trade failed: ${result.error}`);
+        }
+      }
+    }
+  }
+  /**
+   * Check for vault auto-creation based on policy
+   */
+  async checkVaultAutoCreation() {
+    const now = Date.now();
+    if (now - this.lastVaultCheck < this.VAULT_CHECK_INTERVAL) {
+      return;
+    }
+    this.lastVaultCheck = now;
+    const result = await this.vaultManager.checkAndAutoCreateVault();
+    switch (result.action) {
+      case "created":
+        console.log(`\u{1F389} Vault created automatically: ${result.vaultAddress}`);
+        break;
+      case "already_exists":
+        break;
+      case "skipped":
+        break;
+      case "not_qualified":
+        console.log(`Vault auto-creation pending: ${result.reason}`);
+        break;
+    }
+  }
+  /**
+   * Stop the trading loop
+   */
+  stop() {
+    console.log("Stopping agent...");
+    this.isRunning = false;
+  }
+  /**
+   * Get RPC URL based on network
+   */
+  getRpcUrl() {
+    if (this.config.network === "mainnet") {
+      return "https://mainnet.base.org";
+    }
+    return "https://sepolia.base.org";
+  }
+  /**
+   * Default tokens to track
+   */
+  getDefaultTokens() {
+    if (this.config.network === "mainnet") {
+      return [
+        "0x4200000000000000000000000000000000000006",
+        // WETH
+        "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+        // USDC
+      ];
+    }
+    return [
+      "0x4200000000000000000000000000000000000006"
+      // WETH
+    ];
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Get current status
+   */
+  getStatus() {
+    const vaultConfig = this.config.vault || { policy: "disabled" };
+    return {
+      isRunning: this.isRunning,
+      agentId: Number(this.config.agentId),
+      wallet: this.client?.address || "not initialized",
+      llm: {
+        provider: this.config.llm.provider,
+        model: this.config.llm.model || "default"
+      },
+      configHash: this.configHash || "not initialized",
+      risk: this.riskManager?.getStatus() || { dailyPnL: 0, dailyLossLimit: 0, isLimitHit: false },
+      vault: {
+        policy: vaultConfig.policy,
+        hasVault: false,
+        // Updated async via getVaultStatus
+        vaultAddress: null
+      }
+    };
+  }
+  /**
+   * Get detailed vault status (async)
+   */
+  async getVaultStatus() {
+    if (!this.vaultManager) {
+      return null;
+    }
+    return this.vaultManager.getVaultStatus();
+  }
+  /**
+   * Manually trigger vault creation (for 'manual' policy)
+   */
+  async createVault() {
+    if (!this.vaultManager) {
+      return { success: false, error: "Vault manager not initialized" };
+    }
+    const policy = this.config.vault?.policy || "disabled";
+    if (policy === "disabled") {
+      return { success: false, error: "Vault creation is disabled by policy" };
+    }
+    return this.vaultManager.createVault();
+  }
+};
+
+// src/types.ts
+import { z } from "zod";
+var WalletSetupSchema = z.enum(["generate", "provide"]);
+var LLMProviderSchema = z.enum(["openai", "anthropic", "google", "deepseek", "mistral", "groq", "together", "ollama", "custom"]);
+var LLMConfigSchema = z.object({
+  provider: LLMProviderSchema,
+  model: z.string().optional(),
+  apiKey: z.string().optional(),
+  endpoint: z.string().url().optional(),
+  temperature: z.number().min(0).max(2).default(0.7),
+  maxTokens: z.number().positive().default(4096)
+});
+var RiskUniverseSchema = z.enum(["core", "established", "derivatives", "emerging", "frontier"]);
+var TradingConfigSchema = z.object({
+  timeHorizon: z.enum(["intraday", "swing", "position"]).default("swing"),
+  maxPositionSizeBps: z.number().min(100).max(1e4).default(1e3),
+  // 1-100%
+  maxDailyLossBps: z.number().min(0).max(1e4).default(500),
+  // 0-100%
+  maxConcurrentPositions: z.number().min(1).max(100).default(5),
+  tradingIntervalMs: z.number().min(1e3).default(6e4)
+  // minimum 1 second
+});
+var VaultPolicySchema = z.enum([
+  "disabled",
+  // Never create a vault - trade with agent's own capital only
+  "manual",
+  // Only create vault when explicitly directed by owner
+  "auto_when_qualified"
+  // Automatically create vault when requirements are met
+]);
+var VaultConfigSchema = z.object({
+  // Policy for vault creation (asked during deployment)
+  policy: VaultPolicySchema.default("manual"),
+  // Default vault name (auto-generated from agent name if not set)
+  defaultName: z.string().optional(),
+  // Default vault symbol (auto-generated if not set)
+  defaultSymbol: z.string().optional(),
+  // Fee recipient for vault fees (default: agent wallet)
+  feeRecipient: z.string().optional(),
+  // When vault exists, trade through vault instead of direct trading
+  // This pools depositors' capital with the agent's trades
+  preferVaultTrading: z.boolean().default(true)
+});
+var WalletConfigSchema = z.object({
+  setup: WalletSetupSchema.default("provide")
+}).optional();
+var AgentConfigSchema = z.object({
+  // Identity (from on-chain registration)
+  agentId: z.union([z.number().positive(), z.string()]),
+  name: z.string().min(3).max(32),
+  // Network
+  network: z.enum(["mainnet", "testnet"]).default("testnet"),
+  // Wallet setup preference
+  wallet: WalletConfigSchema,
+  // LLM
+  llm: LLMConfigSchema,
+  // Trading parameters
+  riskUniverse: RiskUniverseSchema.default("established"),
+  trading: TradingConfigSchema.default({}),
+  // Vault configuration (copy trading)
+  vault: VaultConfigSchema.default({}),
+  // Allowed tokens (addresses)
+  allowedTokens: z.array(z.string()).optional()
+});
+
+// src/config.ts
+import { readFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { config as loadEnv } from "dotenv";
+function loadConfig(configPath) {
+  loadEnv();
+  const configFile = configPath || process.env.EXAGENT_CONFIG || "agent-config.json";
+  const fullPath = configFile.startsWith("/") ? configFile : join2(process.cwd(), configFile);
+  if (!existsSync2(fullPath)) {
+    throw new Error(`Config file not found: ${fullPath}`);
+  }
+  const rawConfig = JSON.parse(readFileSync(fullPath, "utf-8"));
+  const config = AgentConfigSchema.parse(rawConfig);
+  const privateKey = process.env.EXAGENT_PRIVATE_KEY;
+  if (!privateKey) {
+    throw new Error("EXAGENT_PRIVATE_KEY not set in environment");
+  }
+  if (!privateKey.startsWith("0x") || privateKey.length !== 66) {
+    throw new Error("EXAGENT_PRIVATE_KEY must be a valid 32-byte hex string starting with 0x");
+  }
+  const llmConfig = { ...config.llm };
+  if (process.env.OPENAI_API_KEY && config.llm.provider === "openai") {
+    llmConfig.apiKey = process.env.OPENAI_API_KEY;
+  }
+  if (process.env.ANTHROPIC_API_KEY && config.llm.provider === "anthropic") {
+    llmConfig.apiKey = process.env.ANTHROPIC_API_KEY;
+  }
+  if (process.env.GOOGLE_AI_API_KEY && config.llm.provider === "google") {
+    llmConfig.apiKey = process.env.GOOGLE_AI_API_KEY;
+  }
+  if (process.env.EXAGENT_LLM_URL) {
+    llmConfig.endpoint = process.env.EXAGENT_LLM_URL;
+  }
+  if (process.env.EXAGENT_LLM_MODEL) {
+    llmConfig.model = process.env.EXAGENT_LLM_MODEL;
+  }
+  const network = process.env.EXAGENT_NETWORK || config.network;
+  return {
+    ...config,
+    llm: llmConfig,
+    network,
+    privateKey
+  };
+}
+function validateConfig(config) {
+  if (!config.privateKey) {
+    throw new Error("Private key is required");
+  }
+  if (config.llm.provider !== "ollama" && !config.llm.apiKey) {
+    throw new Error(`API key required for ${config.llm.provider} provider`);
+  }
+  if (config.llm.provider === "ollama" && !config.llm.endpoint) {
+    config.llm.endpoint = "http://localhost:11434";
+  }
+  if (config.llm.provider === "custom" && !config.llm.endpoint) {
+    throw new Error("Endpoint required for custom LLM provider");
+  }
+  if (!config.agentId || Number(config.agentId) <= 0) {
+    throw new Error("Valid agent ID required");
+  }
+}
+function createSampleConfig(agentId, name) {
+  return {
+    agentId,
+    name,
+    network: "testnet",
+    llm: {
+      provider: "openai",
+      model: "gpt-4.1",
+      temperature: 0.7,
+      maxTokens: 4096
+    },
+    riskUniverse: "established",
+    trading: {
+      timeHorizon: "swing",
+      maxPositionSizeBps: 1e3,
+      maxDailyLossBps: 500,
+      maxConcurrentPositions: 5,
+      tradingIntervalMs: 6e4
+    },
+    vault: {
+      // Default to manual - user must explicitly enable auto-creation
+      policy: "manual",
+      // Will use agent name for vault name if not set
+      preferVaultTrading: true
+    }
+  };
+}
+
+export {
+  BaseLLMAdapter,
+  OpenAIAdapter,
+  AnthropicAdapter,
+  OllamaAdapter,
+  createLLMAdapter,
+  loadStrategy,
+  validateStrategy,
+  STRATEGY_TEMPLATES,
+  getStrategyTemplate,
+  getAllStrategyTemplates,
+  TradeExecutor,
+  RiskManager,
+  MarketDataService,
+  VaultManager,
+  AgentRuntime,
+  LLMProviderSchema,
+  LLMConfigSchema,
+  RiskUniverseSchema,
+  TradingConfigSchema,
+  VaultPolicySchema,
+  VaultConfigSchema,
+  AgentConfigSchema,
+  loadConfig,
+  validateConfig,
+  createSampleConfig
+};