@exagent/agent 0.1.1 → 0.1.2

package/dist/index.js

@@ -34,14 +34,21 @@ __export(index_exports, {
   AgentRuntime: () => AgentRuntime,
   AnthropicAdapter: () => AnthropicAdapter,
   BaseLLMAdapter: () => BaseLLMAdapter,
+  DeepSeekAdapter: () => DeepSeekAdapter,
+  GoogleAdapter: () => GoogleAdapter,
+  GroqAdapter: () => GroqAdapter,
   LLMConfigSchema: () => LLMConfigSchema,
   LLMProviderSchema: () => LLMProviderSchema,
   MarketDataService: () => MarketDataService,
+  MistralAdapter: () => MistralAdapter,
   OllamaAdapter: () => OllamaAdapter,
   OpenAIAdapter: () => OpenAIAdapter,
+  RelayClient: () => RelayClient,
+  RelayConfigSchema: () => RelayConfigSchema,
   RiskManager: () => RiskManager,
   RiskUniverseSchema: () => RiskUniverseSchema,
   STRATEGY_TEMPLATES: () => STRATEGY_TEMPLATES,
+  TogetherAdapter: () => TogetherAdapter,
   TradeExecutor: () => TradeExecutor,
   TradingConfigSchema: () => TradingConfigSchema,
   VaultConfigSchema: () => VaultConfigSchema,
@@ -49,9 +56,12 @@ __export(index_exports, {
   VaultPolicySchema: () => VaultPolicySchema,
   createLLMAdapter: () => createLLMAdapter,
   createSampleConfig: () => createSampleConfig,
+  decryptEnvFile: () => decryptEnvFile,
+  encryptEnvFile: () => encryptEnvFile,
   getAllStrategyTemplates: () => getAllStrategyTemplates,
   getStrategyTemplate: () => getStrategyTemplate,
   loadConfig: () => loadConfig,
+  loadSecureEnv: () => loadSecureEnv,
   loadStrategy: () => loadStrategy,
   validateConfig: () => validateConfig,
   validateStrategy: () => validateStrategy
@@ -60,6 +70,8 @@ module.exports = __toCommonJS(index_exports);
 
 // src/runtime.ts
 var import_sdk = require("@exagent/sdk");
+var import_viem2 = require("viem");
+var import_chains2 = require("viem/chains");
 
 // src/llm/openai.ts
 var import_openai = __toESM(require("openai"));
@@ -104,7 +116,7 @@ var OpenAIAdapter = class extends BaseLLMAdapter {
   async chat(messages) {
     try {
       const response = await this.client.chat.completions.create({
-        model: this.config.model || "gpt-4-turbo-preview",
+        model: this.config.model || "gpt-4.1",
         messages: messages.map((m) => ({
           role: m.role,
           content: m.content
@@ -149,7 +161,7 @@ var AnthropicAdapter = class extends BaseLLMAdapter {
     const systemMessage = messages.find((m) => m.role === "system");
     const chatMessages = messages.filter((m) => m.role !== "system");
     const body = {
-      model: this.config.model || "claude-3-opus-20240229",
+      model: this.config.model || "claude-opus-4-5-20251101",
       max_tokens: this.config.maxTokens || 4096,
       temperature: this.config.temperature,
       system: systemMessage?.content,
@@ -186,6 +198,256 @@ var AnthropicAdapter = class extends BaseLLMAdapter {
   }
 };
 
+// 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/deepseek.ts
+var import_openai2 = __toESM(require("openai"));
+var DeepSeekAdapter = class extends BaseLLMAdapter {
+  client;
+  constructor(config) {
+    super(config);
+    if (!config.apiKey) {
+      throw new Error("DeepSeek API key required");
+    }
+    this.client = new import_openai2.default({
+      apiKey: config.apiKey,
+      baseURL: config.endpoint || "https://api.deepseek.com/v1"
+    });
+  }
+  async chat(messages) {
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.config.model || "deepseek-chat",
+        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 DeepSeek");
+      }
+      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 import_openai2.default.APIError) {
+        throw new Error(`DeepSeek API error: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+
+// src/llm/mistral.ts
+var MistralAdapter = class extends BaseLLMAdapter {
+  apiKey;
+  baseUrl;
+  constructor(config) {
+    super(config);
+    if (!config.apiKey) {
+      throw new Error("Mistral API key required");
+    }
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.endpoint || "https://api.mistral.ai/v1";
+  }
+  async chat(messages) {
+    const body = {
+      model: this.config.model || "mistral-large-latest",
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      temperature: this.config.temperature,
+      max_tokens: this.config.maxTokens
+    };
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Mistral API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    const choice = data.choices?.[0];
+    if (!choice || !choice.message) {
+      throw new Error("No response from Mistral");
+    }
+    return {
+      content: choice.message.content || "",
+      usage: data.usage ? {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens
+      } : void 0
+    };
+  }
+};
+
+// src/llm/groq.ts
+var import_openai3 = __toESM(require("openai"));
+var GroqAdapter = class extends BaseLLMAdapter {
+  client;
+  constructor(config) {
+    super(config);
+    if (!config.apiKey) {
+      throw new Error("Groq API key required");
+    }
+    this.client = new import_openai3.default({
+      apiKey: config.apiKey,
+      baseURL: config.endpoint || "https://api.groq.com/openai/v1"
+    });
+  }
+  async chat(messages) {
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.config.model || "llama-3.1-70b-versatile",
+        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 Groq");
+      }
+      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 import_openai3.default.APIError) {
+        throw new Error(`Groq API error: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+
+// src/llm/together.ts
+var import_openai4 = __toESM(require("openai"));
+var TogetherAdapter = class extends BaseLLMAdapter {
+  client;
+  constructor(config) {
+    super(config);
+    if (!config.apiKey) {
+      throw new Error("Together AI API key required");
+    }
+    this.client = new import_openai4.default({
+      apiKey: config.apiKey,
+      baseURL: config.endpoint || "https://api.together.xyz/v1"
+    });
+  }
+  async chat(messages) {
+    try {
+      const response = await this.client.chat.completions.create({
+        model: this.config.model || "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",
+        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 Together AI");
+      }
+      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 import_openai4.default.APIError) {
+        throw new Error(`Together AI API error: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+};
+
 // src/llm/ollama.ts
 var OllamaAdapter = class extends BaseLLMAdapter {
   baseUrl;
@@ -218,7 +480,7 @@ var OllamaAdapter = class extends BaseLLMAdapter {
   }
   async chat(messages) {
     const body = {
-      model: this.config.model || "mistral",
+      model: this.config.model || "llama3.2",
       messages: messages.map((m) => ({
         role: m.role,
         content: m.content
@@ -253,7 +515,7 @@ var OllamaAdapter = class extends BaseLLMAdapter {
   getMetadata() {
     return {
       provider: "ollama",
-      model: this.config.model || "mistral",
+      model: this.config.model || "llama3.2",
       isLocal: true
     };
   }
@@ -266,6 +528,16 @@ async function createLLMAdapter(config) {
       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":
       const adapter = new OllamaAdapter(config);
       await adapter.healthCheck();
@@ -319,7 +591,7 @@ async function loadStrategy(strategyPath) {
   console.log("No custom strategy found, using default (hold) strategy");
   return defaultStrategy;
 }
-async function loadTypeScriptModule(path) {
+async function loadTypeScriptModule(path2) {
   try {
     const tsxPath = require.resolve("tsx");
     const { pathToFileURL } = await import("url");
@@ -330,7 +602,7 @@ async function loadTypeScriptModule(path) {
           "--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))`
+          `import('${pathToFileURL(path2).href}').then(m => console.log(JSON.stringify({ exports: Object.keys(m) }))).catch(e => console.error('ERROR:', e.message))`
         ],
         {
           cwd: process.cwd(),
@@ -353,7 +625,7 @@ async function loadTypeScriptModule(path) {
     const tsx = await import("tsx/esm/api");
     const unregister = tsx.register();
     try {
-      const module2 = await import(path);
+      const module2 = await import(path2);
       return module2;
     } finally {
       unregister();
@@ -1153,7 +1425,268 @@ var VaultManager = class {
   }
 };
 
+// src/relay.ts
+var import_ws = __toESM(require("ws"));
+var import_accounts2 = require("viem/accounts");
+var RelayClient = class {
+  config;
+  ws = null;
+  authenticated = false;
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 50;
+  reconnectTimer = null;
+  heartbeatTimer = null;
+  stopped = false;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Connect to the relay server
+   */
+  async connect() {
+    if (this.stopped) return;
+    const wsUrl = this.config.relay.apiUrl.replace(/^https?:\/\//, (m) => m.includes("https") ? "wss://" : "ws://").replace(/\/$/, "") + "/ws/agent";
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new import_ws.default(wsUrl);
+      } catch (error) {
+        console.error("Relay: Failed to create WebSocket:", error);
+        this.scheduleReconnect();
+        reject(error);
+        return;
+      }
+      const connectTimeout = setTimeout(() => {
+        if (!this.authenticated) {
+          console.error("Relay: Connection timeout");
+          this.ws?.close();
+          this.scheduleReconnect();
+          reject(new Error("Connection timeout"));
+        }
+      }, 15e3);
+      this.ws.on("open", async () => {
+        console.log("Relay: Connected, authenticating...");
+        this.reconnectAttempts = 0;
+        try {
+          await this.authenticate();
+        } catch (error) {
+          console.error("Relay: Authentication failed:", error);
+          this.ws?.close();
+          clearTimeout(connectTimeout);
+          reject(error);
+        }
+      });
+      this.ws.on("message", (raw) => {
+        try {
+          const data = JSON.parse(raw.toString());
+          this.handleMessage(data);
+          if (data.type === "auth_success") {
+            clearTimeout(connectTimeout);
+            this.authenticated = true;
+            this.startHeartbeat();
+            console.log("Relay: Authenticated successfully");
+            resolve();
+          } else if (data.type === "auth_error") {
+            clearTimeout(connectTimeout);
+            console.error(`Relay: Auth rejected: ${data.message}`);
+            reject(new Error(data.message));
+          }
+        } catch {
+        }
+      });
+      this.ws.on("close", (code, reason) => {
+        clearTimeout(connectTimeout);
+        this.authenticated = false;
+        this.stopHeartbeat();
+        if (!this.stopped) {
+          console.log(`Relay: Disconnected (${code}: ${reason.toString() || "unknown"})`);
+          this.scheduleReconnect();
+        }
+      });
+      this.ws.on("error", (error) => {
+        if (!this.stopped) {
+          console.error("Relay: WebSocket error:", error.message);
+        }
+      });
+    });
+  }
+  /**
+   * Authenticate with the relay server using wallet signature
+   */
+  async authenticate() {
+    const account = (0, import_accounts2.privateKeyToAccount)(this.config.privateKey);
+    const timestamp = Math.floor(Date.now() / 1e3);
+    const message = `ExagentRelay:${this.config.agentId}:${timestamp}`;
+    const signature = await (0, import_accounts2.signMessage)({
+      message,
+      privateKey: this.config.privateKey
+    });
+    this.send({
+      type: "auth",
+      agentId: this.config.agentId,
+      wallet: account.address,
+      timestamp,
+      signature
+    });
+  }
+  /**
+   * Handle incoming messages from the relay server
+   */
+  handleMessage(data) {
+    switch (data.type) {
+      case "command":
+        if (data.command && this.config.onCommand) {
+          this.config.onCommand(data.command);
+        }
+        break;
+      case "auth_success":
+      case "auth_error":
+        break;
+      case "error":
+        console.error(`Relay: Server error: ${data.message}`);
+        break;
+    }
+  }
+  /**
+   * Send a status heartbeat
+   */
+  sendHeartbeat(status) {
+    if (!this.authenticated) return;
+    this.send({
+      type: "heartbeat",
+      agentId: this.config.agentId,
+      status
+    });
+  }
+  /**
+   * Send a status update (outside of regular heartbeat)
+   */
+  sendStatusUpdate(status) {
+    if (!this.authenticated) return;
+    this.send({
+      type: "status_update",
+      agentId: this.config.agentId,
+      status
+    });
+  }
+  /**
+   * Send a message to the command center
+   */
+  sendMessage(messageType, level, title, body, data) {
+    if (!this.authenticated) return;
+    this.send({
+      type: "message",
+      agentId: this.config.agentId,
+      messageType,
+      level,
+      title,
+      body,
+      data
+    });
+  }
+  /**
+   * Send a command execution result
+   */
+  sendCommandResult(commandId, success, result) {
+    if (!this.authenticated) return;
+    this.send({
+      type: "command_result",
+      agentId: this.config.agentId,
+      commandId,
+      success,
+      result
+    });
+  }
+  /**
+   * Start the heartbeat timer
+   */
+  startHeartbeat() {
+    this.stopHeartbeat();
+    const interval = this.config.relay.heartbeatIntervalMs || 3e4;
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws?.readyState === import_ws.default.OPEN) {
+        this.ws.ping();
+      }
+    }, interval);
+  }
+  /**
+   * Stop the heartbeat timer
+   */
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  /**
+   * Schedule a reconnection with exponential backoff
+   */
+  scheduleReconnect() {
+    if (this.stopped) return;
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error("Relay: Max reconnection attempts reached. Giving up.");
+      return;
+    }
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+    this.reconnectAttempts++;
+    console.log(
+      `Relay: Reconnecting in ${delay / 1e3}s (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`
+    );
+    this.reconnectTimer = setTimeout(() => {
+      this.connect().catch(() => {
+      });
+    }, delay);
+  }
+  /**
+   * Send a JSON message to the WebSocket
+   */
+  send(data) {
+    if (this.ws?.readyState === import_ws.default.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    }
+  }
+  /**
+   * Check if connected and authenticated
+   */
+  get isConnected() {
+    return this.authenticated && this.ws?.readyState === import_ws.default.OPEN;
+  }
+  /**
+   * Disconnect and stop reconnecting
+   */
+  disconnect() {
+    this.stopped = true;
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close(1e3, "Agent shutting down");
+      this.ws = null;
+    }
+    this.authenticated = false;
+    console.log("Relay: Disconnected");
+  }
+};
+
+// src/browser-open.ts
+var import_child_process2 = require("child_process");
+function openBrowser(url) {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      (0, import_child_process2.exec)(`open "${url}"`);
+    } else if (platform === "win32") {
+      (0, import_child_process2.exec)(`start "" "${url}"`);
+    } else {
+      (0, import_child_process2.exec)(`xdg-open "${url}"`);
+    }
+  } catch {
+  }
+}
+
 // src/runtime.ts
+var FUNDS_LOW_THRESHOLD = 5e-3;
 var AgentRuntime = class {
   config;
   client;
@@ -1163,9 +1696,14 @@ var AgentRuntime = class {
   riskManager;
   marketData;
   vaultManager;
+  relay = null;
   isRunning = false;
+  mode = "idle";
   configHash;
   lastVaultCheck = 0;
+  cycleCount = 0;
+  lastCycleAt = 0;
+  processAlive = true;
   VAULT_CHECK_INTERVAL = 3e5;
   // Check vault status every 5 minutes
   constructor(config) {
@@ -1197,8 +1735,44 @@ var AgentRuntime = class {
     this.riskManager = new RiskManager(this.config.trading);
     this.marketData = new MarketDataService(this.getRpcUrl());
     await this.initializeVaultManager();
+    await this.initializeRelay();
     console.log("Agent initialized successfully");
   }
+  /**
+   * Initialize the relay client for command center connectivity
+   */
+  async initializeRelay() {
+    const relayConfig = this.config.relay;
+    const relayEnabled = process.env.EXAGENT_RELAY_ENABLED !== "false";
+    if (!relayConfig?.enabled || !relayEnabled) {
+      console.log("Relay: Disabled");
+      return;
+    }
+    const apiUrl = process.env.EXAGENT_API_URL || relayConfig.apiUrl;
+    if (!apiUrl) {
+      console.log("Relay: No API URL configured, skipping");
+      return;
+    }
+    this.relay = new RelayClient({
+      agentId: String(this.config.agentId),
+      privateKey: this.config.privateKey,
+      relay: {
+        ...relayConfig,
+        apiUrl
+      },
+      onCommand: (cmd) => this.handleCommand(cmd)
+    });
+    try {
+      await this.relay.connect();
+      console.log("Relay: Connected to command center");
+      this.sendRelayStatus();
+    } catch (error) {
+      console.warn(
+        "Relay: Failed to connect (agent will work locally):",
+        error instanceof Error ? error.message : error
+      );
+    }
+  }
   /**
    * Initialize the vault manager based on config
    */
@@ -1228,7 +1802,9 @@ var AgentRuntime = class {
     }
   }
   /**
-   * Ensure the current wallet is linked to the agent
+   * Ensure the current wallet is linked to the agent.
+   * If the trading wallet differs from the owner, enters a recovery loop
+   * that waits for the owner to link it from the website.
    */
   async ensureWalletLinked() {
     const agentId = BigInt(this.config.agentId);
@@ -1238,9 +1814,31 @@ var AgentRuntime = class {
       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}`
-        );
+        const ccUrl = `https://exagent.io/agents/${encodeURIComponent(this.config.name)}/command-center`;
+        console.log("");
+        console.log("=== WALLET LINKING REQUIRED ===");
+        console.log("");
+        console.log(`  Agent owner:    ${agent?.owner}`);
+        console.log(`  Trading wallet: ${address}`);
+        console.log("");
+        console.log("  Your trading wallet needs to be linked to your agent.");
+        console.log("  Opening the command center in your browser...");
+        console.log(`  ${ccUrl}`);
+        console.log("");
+        openBrowser(ccUrl);
+        console.log("  Waiting for wallet to be linked... (checking every 15s)");
+        console.log("  Press Ctrl+C to exit.");
+        console.log("");
+        while (true) {
+          await this.sleep(15e3);
+          const linked = await this.client.registry.isLinkedWallet(agentId, address);
+          if (linked) {
+            console.log("  Wallet linked! Continuing setup...");
+            console.log("");
+            return;
+          }
+          process.stdout.write(".");
+        }
       }
       await this.client.registry.linkOwnWallet(agentId);
       console.log("Wallet linked successfully");
@@ -1249,8 +1847,9 @@ var AgentRuntime = class {
     }
   }
   /**
-   * Sync the LLM config hash to chain for epoch tracking
-   * This ensures trades are attributed to the correct config epoch
+   * Sync the LLM config hash to chain for epoch tracking.
+   * If the wallet has insufficient gas, enters a recovery loop
+   * that waits for the user to fund the wallet.
    */
   async syncConfigHash() {
     const agentId = BigInt(this.config.agentId);
@@ -1260,9 +1859,50 @@ var AgentRuntime = class {
     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}`);
+      try {
+        await this.client.registry.updateConfig(agentId, this.configHash);
+        const newEpoch = await this.client.registry.getCurrentEpoch(agentId);
+        console.log(`Config updated, new epoch started: ${newEpoch}`);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("insufficient funds") || message.includes("gas") || message.includes("intrinsic gas too low") || message.includes("exceeds the balance")) {
+          const ccUrl = `https://exagent.io/agents/${encodeURIComponent(this.config.name)}/command-center`;
+          const chain = this.config.network === "mainnet" ? import_chains2.base : import_chains2.baseSepolia;
+          const publicClientInstance = (0, import_viem2.createPublicClient)({
+            chain,
+            transport: (0, import_viem2.http)(this.getRpcUrl())
+          });
+          console.log("");
+          console.log("=== ETH NEEDED FOR GAS ===");
+          console.log("");
+          console.log(`  Wallet: ${this.client.address}`);
+          console.log("  Your wallet needs ETH to pay for transaction gas.");
+          console.log("  Opening the command center to fund your wallet...");
+          console.log(`  ${ccUrl}`);
+          console.log("");
+          openBrowser(ccUrl);
+          console.log("  Waiting for ETH... (checking every 15s)");
+          console.log("  Press Ctrl+C to exit.");
+          console.log("");
+          while (true) {
+            await this.sleep(15e3);
+            const balance = await publicClientInstance.getBalance({
+              address: this.client.address
+            });
+            if (balance > BigInt(0)) {
+              console.log("  ETH detected! Retrying config update...");
+              console.log("");
+              await this.client.registry.updateConfig(agentId, this.configHash);
+              const newEpoch = await this.client.registry.getCurrentEpoch(agentId);
+              console.log(`Config updated, new epoch started: ${newEpoch}`);
+              return;
+            }
+            process.stdout.write(".");
+          }
+        } else {
+          throw error;
+        }
+      }
     } else {
       const currentEpoch = await this.client.registry.getCurrentEpoch(agentId);
       console.log(`Config hash matches on-chain (epoch ${currentEpoch})`);
@@ -1275,48 +1915,301 @@ var AgentRuntime = class {
     return this.configHash;
   }
   /**
-   * Start the trading loop
+   * Start the agent in daemon mode.
+   * The agent enters idle mode and waits for commands from the command center.
+   * Trading begins only when a start_trading command is received.
+   *
+   * If relay is not configured, falls back to immediate trading mode.
    */
   async run() {
-    if (this.isRunning) {
-      throw new Error("Agent is already running");
+    this.processAlive = true;
+    if (this.relay) {
+      console.log("");
+      console.log("Agent is in IDLE mode. Waiting for commands from command center.");
+      console.log("Visit https://exagent.io to start trading from the dashboard.");
+      console.log("");
+      this.mode = "idle";
+      this.sendRelayStatus();
+      this.relay.sendMessage(
+        "system",
+        "success",
+        "Agent Connected",
+        `${this.config.name} is online and waiting for commands.`,
+        { wallet: this.client.address }
+      );
+      while (this.processAlive) {
+        if (this.mode === "trading" && this.isRunning) {
+          try {
+            await this.runCycle();
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error("Error in trading cycle:", message);
+            this.relay?.sendMessage(
+              "system",
+              "error",
+              "Cycle Error",
+              message
+            );
+          }
+          await this.sleep(this.config.trading.tradingIntervalMs);
+        } else {
+          this.sendRelayStatus();
+          await this.sleep(3e4);
+        }
+      }
+    } else {
+      if (this.isRunning) {
+        throw new Error("Agent is already running");
+      }
+      this.isRunning = true;
+      this.mode = "trading";
+      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);
+      }
     }
-    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);
+  }
+  /**
+   * Handle a command from the command center
+   */
+  async handleCommand(cmd) {
+    console.log(`Command received: ${cmd.type}`);
+    try {
+      switch (cmd.type) {
+        case "start_trading":
+          if (this.mode === "trading") {
+            this.relay?.sendCommandResult(cmd.id, true, "Already trading");
+            return;
+          }
+          this.mode = "trading";
+          this.isRunning = true;
+          console.log("Trading started via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Trading started");
+          this.relay?.sendMessage(
+            "system",
+            "success",
+            "Trading Started",
+            "Agent is now actively trading."
+          );
+          this.sendRelayStatus();
+          break;
+        case "stop_trading":
+          if (this.mode === "idle") {
+            this.relay?.sendCommandResult(cmd.id, true, "Already idle");
+            return;
+          }
+          this.mode = "idle";
+          this.isRunning = false;
+          console.log("Trading stopped via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Trading stopped");
+          this.relay?.sendMessage(
+            "system",
+            "info",
+            "Trading Stopped",
+            "Agent is now idle. Send start_trading to resume."
+          );
+          this.sendRelayStatus();
+          break;
+        case "update_risk_params": {
+          const params = cmd.params || {};
+          if (params.maxPositionSizeBps !== void 0) {
+            this.config.trading.maxPositionSizeBps = Number(params.maxPositionSizeBps);
+          }
+          if (params.maxDailyLossBps !== void 0) {
+            this.config.trading.maxDailyLossBps = Number(params.maxDailyLossBps);
+          }
+          this.riskManager = new RiskManager(this.config.trading);
+          console.log("Risk params updated via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Risk params updated");
+          this.relay?.sendMessage(
+            "config_updated",
+            "info",
+            "Risk Parameters Updated",
+            `Max position: ${this.config.trading.maxPositionSizeBps / 100}%, Max daily loss: ${this.config.trading.maxDailyLossBps / 100}%`
+          );
+          break;
+        }
+        case "update_trading_interval": {
+          const intervalMs = Number(cmd.params?.intervalMs);
+          if (intervalMs && intervalMs >= 1e3) {
+            this.config.trading.tradingIntervalMs = intervalMs;
+            console.log(`Trading interval updated to ${intervalMs}ms`);
+            this.relay?.sendCommandResult(cmd.id, true, `Interval set to ${intervalMs}ms`);
+          } else {
+            this.relay?.sendCommandResult(cmd.id, false, "Invalid interval (minimum 1000ms)");
+          }
+          break;
+        }
+        case "create_vault": {
+          const result = await this.createVault();
+          this.relay?.sendCommandResult(
+            cmd.id,
+            result.success,
+            result.success ? `Vault created: ${result.vaultAddress}` : result.error
+          );
+          if (result.success) {
+            this.relay?.sendMessage(
+              "vault_created",
+              "success",
+              "Vault Created",
+              `Vault deployed at ${result.vaultAddress}`,
+              { vaultAddress: result.vaultAddress }
+            );
+          }
+          break;
+        }
+        case "refresh_status":
+          this.sendRelayStatus();
+          this.relay?.sendCommandResult(cmd.id, true, "Status refreshed");
+          break;
+        case "shutdown":
+          console.log("Shutdown requested via command center");
+          this.relay?.sendCommandResult(cmd.id, true, "Shutting down");
+          this.relay?.sendMessage(
+            "system",
+            "info",
+            "Shutting Down",
+            "Agent is shutting down. Restart manually to reconnect."
+          );
+          await this.sleep(1e3);
+          this.stop();
+          break;
+        default:
+          console.warn(`Unknown command: ${cmd.type}`);
+          this.relay?.sendCommandResult(cmd.id, false, `Unknown command: ${cmd.type}`);
       }
-      await this.sleep(this.config.trading.tradingIntervalMs);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`Command ${cmd.type} failed:`, message);
+      this.relay?.sendCommandResult(cmd.id, false, message);
     }
   }
+  /**
+   * Send current status to the relay
+   */
+  sendRelayStatus() {
+    if (!this.relay) return;
+    const vaultConfig = this.config.vault || { policy: "disabled" };
+    const status = {
+      mode: this.mode,
+      agentId: String(this.config.agentId),
+      wallet: this.client?.address,
+      cycleCount: this.cycleCount,
+      lastCycleAt: this.lastCycleAt,
+      tradingIntervalMs: this.config.trading.tradingIntervalMs,
+      llm: {
+        provider: this.config.llm.provider,
+        model: this.config.llm.model || "default"
+      },
+      risk: this.riskManager?.getStatus() || {
+        dailyPnL: 0,
+        dailyLossLimit: 0,
+        isLimitHit: false
+      },
+      vault: {
+        policy: vaultConfig.policy,
+        hasVault: false,
+        vaultAddress: null
+      }
+    };
+    this.relay.sendHeartbeat(status);
+  }
   /**
    * Run a single trading cycle
    */
   async runCycle() {
     console.log(`
 --- Trading Cycle: ${(/* @__PURE__ */ new Date()).toISOString()} ---`);
+    this.cycleCount++;
+    this.lastCycleAt = Date.now();
     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);
+    this.checkFundsLow(marketData);
+    let signals;
+    try {
+      signals = await this.strategy(marketData, this.llm, this.config);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("LLM/strategy error:", message);
+      this.relay?.sendMessage(
+        "llm_error",
+        "error",
+        "Strategy Error",
+        message
+      );
+      return;
+    }
     console.log(`Strategy generated ${signals.length} signals`);
     const filteredSignals = this.riskManager.filterSignals(signals, marketData);
     console.log(`${filteredSignals.length} signals passed risk checks`);
+    if (this.riskManager.getStatus().isLimitHit) {
+      this.relay?.sendMessage(
+        "risk_limit_hit",
+        "warning",
+        "Risk Limit Hit",
+        `Daily loss limit reached: ${this.riskManager.getStatus().dailyPnL.toFixed(2)}`
+      );
+    }
     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}`);
+          this.relay?.sendMessage(
+            "trade_executed",
+            "success",
+            "Trade Executed",
+            `${result.signal.action.toUpperCase()}: ${result.signal.reasoning || "No reason provided"}`,
+            {
+              action: result.signal.action,
+              txHash: result.txHash,
+              tokenIn: result.signal.tokenIn,
+              tokenOut: result.signal.tokenOut
+            }
+          );
         } else {
           console.warn(`Trade failed: ${result.error}`);
+          this.relay?.sendMessage(
+            "trade_failed",
+            "error",
+            "Trade Failed",
+            result.error || "Unknown error",
+            { action: result.signal.action }
+          );
         }
       }
     }
+    this.sendRelayStatus();
+  }
+  /**
+   * Check if ETH balance is below threshold and notify
+   */
+  checkFundsLow(marketData) {
+    if (!this.relay) return;
+    const wethAddress = "0x4200000000000000000000000000000000000006";
+    const ethBalance = marketData.balances[wethAddress] || BigInt(0);
+    const ethAmount = Number(ethBalance) / 1e18;
+    if (ethAmount < FUNDS_LOW_THRESHOLD) {
+      this.relay.sendMessage(
+        "funds_low",
+        "warning",
+        "Low Funds",
+        `ETH balance is ${ethAmount.toFixed(6)} ETH. Fund your trading wallet to continue trading.`,
+        {
+          ethBalance: ethAmount.toFixed(6),
+          wallet: this.client.address,
+          threshold: FUNDS_LOW_THRESHOLD
+        }
+      );
+    }
   }
   /**
    * Check for vault auto-creation based on policy
@@ -1330,7 +2223,14 @@ var AgentRuntime = class {
     const result = await this.vaultManager.checkAndAutoCreateVault();
     switch (result.action) {
       case "created":
-        console.log(`\u{1F389} Vault created automatically: ${result.vaultAddress}`);
+        console.log(`Vault created automatically: ${result.vaultAddress}`);
+        this.relay?.sendMessage(
+          "vault_created",
+          "success",
+          "Vault Auto-Created",
+          `Vault deployed at ${result.vaultAddress}`,
+          { vaultAddress: result.vaultAddress }
+        );
         break;
       case "already_exists":
         break;
@@ -1342,11 +2242,16 @@ var AgentRuntime = class {
     }
   }
   /**
-   * Stop the trading loop
+   * Stop the agent process completely
    */
   stop() {
     console.log("Stopping agent...");
     this.isRunning = false;
+    this.processAlive = false;
+    this.mode = "idle";
+    if (this.relay) {
+      this.relay.disconnect();
+    }
   }
   /**
    * Get RPC URL based on network
@@ -1384,6 +2289,7 @@ var AgentRuntime = class {
     const vaultConfig = this.config.vault || { policy: "disabled" };
     return {
       isRunning: this.isRunning,
+      mode: this.mode,
       agentId: Number(this.config.agentId),
       wallet: this.client?.address || "not initialized",
       llm: {
@@ -1397,7 +2303,11 @@ var AgentRuntime = class {
         hasVault: false,
         // Updated async via getVaultStatus
         vaultAddress: null
-      }
+      },
+      relay: {
+        connected: this.relay?.isConnected || false
+      },
+      cycleCount: this.cycleCount
     };
   }
   /**
@@ -1476,6 +2386,11 @@ var VaultConfigSchema = import_zod.z.object({
 var WalletConfigSchema = import_zod.z.object({
   setup: WalletSetupSchema.default("provide")
 }).optional();
+var RelayConfigSchema = import_zod.z.object({
+  enabled: import_zod.z.boolean().default(false),
+  apiUrl: import_zod.z.string().url(),
+  heartbeatIntervalMs: import_zod.z.number().min(5e3).default(3e4)
+}).optional();
 var AgentConfigSchema = import_zod.z.object({
   // Identity (from on-chain registration)
   agentId: import_zod.z.union([import_zod.z.number().positive(), import_zod.z.string()]),
@@ -1491,6 +2406,8 @@ var AgentConfigSchema = import_zod.z.object({
   trading: TradingConfigSchema.default({}),
   // Vault configuration (copy trading)
   vault: VaultConfigSchema.default({}),
+  // Relay configuration (command center)
+  relay: RelayConfigSchema,
   // Allowed tokens (addresses)
   allowedTokens: import_zod.z.array(import_zod.z.string()).optional()
 });
@@ -1519,6 +2436,21 @@ function loadConfig(configPath) {
   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.DEEPSEEK_API_KEY && config.llm.provider === "deepseek") {
+    llmConfig.apiKey = process.env.DEEPSEEK_API_KEY;
+  }
+  if (process.env.MISTRAL_API_KEY && config.llm.provider === "mistral") {
+    llmConfig.apiKey = process.env.MISTRAL_API_KEY;
+  }
+  if (process.env.GROQ_API_KEY && config.llm.provider === "groq") {
+    llmConfig.apiKey = process.env.GROQ_API_KEY;
+  }
+  if (process.env.TOGETHER_API_KEY && config.llm.provider === "together") {
+    llmConfig.apiKey = process.env.TOGETHER_API_KEY;
+  }
   if (process.env.EXAGENT_LLM_URL) {
     llmConfig.endpoint = process.env.EXAGENT_LLM_URL;
   }
@@ -1557,7 +2489,7 @@ function createSampleConfig(agentId, name) {
     network: "testnet",
     llm: {
       provider: "openai",
-      model: "gpt-4-turbo-preview",
+      model: "gpt-4.1",
       temperature: 0.7,
       maxTokens: 4096
     },
@@ -1577,20 +2509,211 @@ function createSampleConfig(agentId, name) {
     }
   };
 }
+
+// src/secure-env.ts
+var crypto = __toESM(require("crypto"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var ALGORITHM = "aes-256-gcm";
+var PBKDF2_ITERATIONS = 1e5;
+var SALT_LENGTH = 32;
+var IV_LENGTH = 16;
+var KEY_LENGTH = 32;
+var SENSITIVE_PATTERNS = [
+  /PRIVATE_KEY$/i,
+  /_API_KEY$/i,
+  /API_KEY$/i,
+  /_SECRET$/i,
+  /^OPENAI_API_KEY$/i,
+  /^ANTHROPIC_API_KEY$/i,
+  /^GOOGLE_AI_API_KEY$/i,
+  /^DEEPSEEK_API_KEY$/i,
+  /^MISTRAL_API_KEY$/i,
+  /^GROQ_API_KEY$/i,
+  /^TOGETHER_API_KEY$/i
+];
+function isSensitiveKey(key) {
+  return SENSITIVE_PATTERNS.some((pattern) => pattern.test(key));
+}
+function deriveKey(passphrase, salt) {
+  return crypto.pbkdf2Sync(passphrase, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha256");
+}
+function encryptValue(value, key) {
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+  let encrypted = cipher.update(value, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const tag = cipher.getAuthTag();
+  return {
+    iv: iv.toString("hex"),
+    encrypted,
+    tag: tag.toString("hex")
+  };
+}
+function decryptValue(encrypted, key, iv, tag) {
+  const decipher = crypto.createDecipheriv(
+    ALGORITHM,
+    key,
+    Buffer.from(iv, "hex")
+  );
+  decipher.setAuthTag(Buffer.from(tag, "hex"));
+  let decrypted = decipher.update(encrypted, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+  return decrypted;
+}
+function parseEnvFile(content) {
+  const entries = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (key && value) {
+      entries.push({ key, value });
+    }
+  }
+  return entries;
+}
+function encryptEnvFile(envPath, passphrase, deleteOriginal = false) {
+  if (!fs.existsSync(envPath)) {
+    throw new Error(`File not found: ${envPath}`);
+  }
+  const content = fs.readFileSync(envPath, "utf-8");
+  const entries = parseEnvFile(content);
+  if (entries.length === 0) {
+    throw new Error("No environment variables found in file");
+  }
+  const salt = crypto.randomBytes(SALT_LENGTH);
+  const key = deriveKey(passphrase, salt);
+  const encryptedEntries = entries.map(({ key: envKey, value }) => {
+    if (isSensitiveKey(envKey)) {
+      const { iv, encrypted, tag } = encryptValue(value, key);
+      return {
+        key: envKey,
+        value: encrypted,
+        encrypted: true,
+        iv,
+        tag
+      };
+    }
+    return {
+      key: envKey,
+      value,
+      encrypted: false
+    };
+  });
+  const encryptedEnv = {
+    version: 1,
+    salt: salt.toString("hex"),
+    entries: encryptedEntries
+  };
+  const encPath = envPath + ".enc";
+  fs.writeFileSync(encPath, JSON.stringify(encryptedEnv, null, 2), { mode: 384 });
+  if (deleteOriginal) {
+    fs.unlinkSync(envPath);
+  }
+  const sensitiveCount = encryptedEntries.filter((e) => e.encrypted).length;
+  const plainCount = encryptedEntries.filter((e) => !e.encrypted).length;
+  console.log(
+    `Encrypted ${sensitiveCount} sensitive values (${plainCount} non-sensitive kept as plaintext)`
+  );
+  return encPath;
+}
+function decryptEnvFile(encPath, passphrase) {
+  if (!fs.existsSync(encPath)) {
+    throw new Error(`Encrypted env file not found: ${encPath}`);
+  }
+  const content = JSON.parse(fs.readFileSync(encPath, "utf-8"));
+  if (content.version !== 1) {
+    throw new Error(`Unsupported encrypted env version: ${content.version}`);
+  }
+  const salt = Buffer.from(content.salt, "hex");
+  const key = deriveKey(passphrase, salt);
+  const result = {};
+  for (const entry of content.entries) {
+    if (entry.encrypted) {
+      if (!entry.iv || !entry.tag) {
+        throw new Error(`Missing encryption metadata for ${entry.key}`);
+      }
+      try {
+        result[entry.key] = decryptValue(entry.value, key, entry.iv, entry.tag);
+      } catch {
+        throw new Error(
+          `Failed to decrypt ${entry.key}. Wrong passphrase or corrupted data.`
+        );
+      }
+    } else {
+      result[entry.key] = entry.value;
+    }
+  }
+  return result;
+}
+function loadSecureEnv(basePath, passphrase) {
+  const encPath = path.join(basePath, ".env.enc");
+  const envPath = path.join(basePath, ".env");
+  if (fs.existsSync(encPath)) {
+    if (!passphrase) {
+      passphrase = process.env.EXAGENT_PASSPHRASE;
+    }
+    if (!passphrase) {
+      console.warn("");
+      console.warn("WARNING: Found .env.enc but no passphrase provided.");
+      console.warn("  Set EXAGENT_PASSPHRASE environment variable or");
+      console.warn("  pass --passphrase when running the agent.");
+      console.warn("  Falling back to plaintext .env file.");
+      console.warn("");
+    } else {
+      const vars = decryptEnvFile(encPath, passphrase);
+      for (const [key, value] of Object.entries(vars)) {
+        process.env[key] = value;
+      }
+      return true;
+    }
+  }
+  if (fs.existsSync(envPath)) {
+    const content = fs.readFileSync(envPath, "utf-8");
+    const entries = parseEnvFile(content);
+    const sensitiveKeys = entries.filter(({ key }) => isSensitiveKey(key)).map(({ key }) => key);
+    if (sensitiveKeys.length > 0) {
+      console.warn("");
+      console.warn("WARNING: Sensitive values stored in plaintext .env file:");
+      for (const key of sensitiveKeys) {
+        console.warn(`  - ${key}`);
+      }
+      console.warn("");
+      console.warn('  Run "npx @exagent/agent encrypt" to secure your keys.');
+      console.warn("");
+    }
+    return false;
+  }
+  return false;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentConfigSchema,
   AgentRuntime,
   AnthropicAdapter,
   BaseLLMAdapter,
+  DeepSeekAdapter,
+  GoogleAdapter,
+  GroqAdapter,
   LLMConfigSchema,
   LLMProviderSchema,
   MarketDataService,
+  MistralAdapter,
   OllamaAdapter,
   OpenAIAdapter,
+  RelayClient,
+  RelayConfigSchema,
   RiskManager,
   RiskUniverseSchema,
   STRATEGY_TEMPLATES,
+  TogetherAdapter,
   TradeExecutor,
   TradingConfigSchema,
   VaultConfigSchema,
@@ -1598,9 +2721,12 @@ function createSampleConfig(agentId, name) {
   VaultPolicySchema,
   createLLMAdapter,
   createSampleConfig,
+  decryptEnvFile,
+  encryptEnvFile,
   getAllStrategyTemplates,
   getStrategyTemplate,
   loadConfig,
+  loadSecureEnv,
   loadStrategy,
   validateConfig,
   validateStrategy