@exagent/agent 0.3.1 → 0.3.3

package/dist/cli.js

@@ -8,7 +8,7 @@ import {
   readConfigFile,
   writeConfigFile,
   writeSampleConfig
-} from "./chunk-VDK4XPAC.js";
+} from "./chunk-F4TCYYTD.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -87,6 +87,21 @@ function cancelled() {
   clack.cancel("Setup cancelled.");
   process.exit(0);
 }
+function isNonInteractive() {
+  return process.env.EXAGENT_NONINTERACTIVE === "1" || process.env.EXAGENT_NONINTERACTIVE === "true";
+}
+var LLM_KEY_PREFIXES = {
+  openai: "sk-",
+  anthropic: "sk-ant-"
+};
+function validateLlmKeyFormat(provider, key) {
+  if (!key.trim()) return "API key is required.";
+  const expectedPrefix = LLM_KEY_PREFIXES[provider];
+  if (expectedPrefix && !key.startsWith(expectedPrefix)) {
+    return `${provider} API keys typically start with "${expectedPrefix}". Double-check your key.`;
+  }
+  if (key.length < 10) return "API key seems too short.";
+}
 async function consumeBootstrapPackage(config) {
   if (!config.secrets?.bootstrapToken) {
     return { apiToken: "" };
@@ -114,6 +129,22 @@ async function setupWallet(config) {
     printDone(`Using existing wallet: ${pc.dim(account.address)}`);
     return config.wallet.privateKey;
   }
+  if (isNonInteractive()) {
+    const mode = process.env.EXAGENT_WALLET_MODE || "generate";
+    if (mode === "import") {
+      const key = process.env.EXAGENT_WALLET_KEY;
+      if (!key || !/^0x[a-fA-F0-9]{64}$/.test(key)) {
+        throw new Error("EXAGENT_WALLET_KEY must be a valid 0x-prefixed 64-char hex private key in non-interactive mode");
+      }
+      const address3 = privateKeyToAccount(key).address;
+      printDone(`Wallet imported: ${pc.dim(address3)}`);
+      return key;
+    }
+    const privateKey2 = generatePrivateKey();
+    const address2 = privateKeyToAccount(privateKey2).address;
+    printDone(`Wallet created: ${pc.dim(address2)}`);
+    return privateKey2;
+  }
   const method = await clack.select({
     message: "How would you like to set up your wallet?",
     options: [
@@ -143,7 +174,18 @@ async function setupWallet(config) {
 }
 var LLM_PROVIDERS = ["openai", "anthropic", "google", "deepseek", "mistral", "groq", "together", "ollama"];
 async function setupLlm(config, bootstrapPayload) {
-  let provider = config.llm?.provider || bootstrapPayload.llm?.provider;
+  const hasRealLlmConfig = !!(bootstrapPayload.llm?.apiKey || config.llm?.apiKey);
+  if (isNonInteractive()) {
+    const provider2 = process.env.EXAGENT_LLM_PROVIDER || bootstrapPayload.llm?.provider || (hasRealLlmConfig ? config.llm?.provider : void 0);
+    const model2 = process.env.EXAGENT_LLM_MODEL || bootstrapPayload.llm?.model || (hasRealLlmConfig ? config.llm?.model : void 0);
+    const apiKey2 = process.env.EXAGENT_LLM_KEY || bootstrapPayload.llm?.apiKey || config.llm?.apiKey;
+    if (!provider2) throw new Error("EXAGENT_LLM_PROVIDER required in non-interactive mode");
+    if (!model2) throw new Error("EXAGENT_LLM_MODEL required in non-interactive mode");
+    if (!apiKey2) throw new Error("EXAGENT_LLM_KEY required in non-interactive mode");
+    printDone("LLM configured");
+    return { provider: provider2, model: model2, apiKey: apiKey2 };
+  }
+  let provider = bootstrapPayload.llm?.provider || (hasRealLlmConfig ? config.llm?.provider : void 0);
   if (provider) {
     printInfo(`Provider: ${pc.cyan(provider)} ${pc.dim("(from dashboard)")}`);
   } else {
@@ -154,7 +196,7 @@ async function setupLlm(config, bootstrapPayload) {
     if (clack.isCancel(selected)) cancelled();
     provider = selected;
   }
-  let model = config.llm?.model || bootstrapPayload.llm?.model;
+  let model = bootstrapPayload.llm?.model || (hasRealLlmConfig ? config.llm?.model : void 0);
   if (model) {
     printInfo(`Model: ${pc.cyan(model)} ${pc.dim("(from dashboard)")}`);
   } else {
@@ -185,9 +227,7 @@ async function setupLlm(config, bootstrapPayload) {
   if (!apiKey) {
     const entered = await clack.password({
       message: "LLM API key:",
-      validate: (val) => {
-        if (!val.trim()) return "API key is required.";
-      }
+      validate: (val) => validateLlmKeyFormat(provider, val)
     });
     if (clack.isCancel(entered)) cancelled();
     apiKey = entered;
@@ -196,6 +236,13 @@ async function setupLlm(config, bootstrapPayload) {
   return { provider, model, apiKey };
 }
 async function setupEncryption() {
+  if (isNonInteractive()) {
+    const password3 = process.env.EXAGENT_PASSWORD;
+    if (!password3 || password3.length < 12) {
+      throw new Error("EXAGENT_PASSWORD must be at least 12 characters in non-interactive mode");
+    }
+    return password3;
+  }
   printInfo(`Secrets encrypted with ${pc.cyan("AES-256-GCM")} (${pc.cyan("scrypt")} KDF)`);
   printInfo("The password never leaves this machine.");
   console.log();
@@ -230,6 +277,11 @@ function writeSecureStore(path, secrets, password2) {
   return secureStorePath;
 }
 async function promptSecretPassword(question = "Device password:") {
+  if (isNonInteractive()) {
+    const password3 = process.env.EXAGENT_PASSWORD || process.env.EXAGENT_SECRET_PASSWORD;
+    if (!password3) throw new Error("EXAGENT_PASSWORD required in non-interactive mode");
+    return password3;
+  }
   const password2 = await clack.password({ message: question });
   if (clack.isCancel(password2)) cancelled();
   return password2;
@@ -264,14 +316,20 @@ async function ensureLocalSetup(configPath) {
     llmApiKey: llm.apiKey
   };
   if (!secrets.apiToken) {
-    const token = await clack.password({
-      message: "Agent relay token:",
-      validate: (val) => {
-        if (!val.trim()) return "Relay token is required.";
-      }
-    });
-    if (clack.isCancel(token)) cancelled();
-    secrets.apiToken = token;
+    if (isNonInteractive()) {
+      const token = process.env.EXAGENT_API_TOKEN;
+      if (!token) throw new Error("EXAGENT_API_TOKEN required in non-interactive mode (no relay token from bootstrap)");
+      secrets.apiToken = token;
+    } else {
+      const token = await clack.password({
+        message: "Agent relay token:",
+        validate: (val) => {
+          if (!val.trim()) return "Relay token is required.";
+        }
+      });
+      if (clack.isCancel(token)) cancelled();
+      secrets.apiToken = token;
+    }
   }
   const nextConfig = structuredClone(config);
   nextConfig.llm = {
@@ -301,7 +359,7 @@ async function ensureLocalSetup(configPath) {
 
 // src/cli.ts
 var program = new Command();
-program.name("exagent").description("Exagent \u2014 LLM trading agent runtime").version("0.3.0");
+program.name("exagent").description("Exagent \u2014 LLM trading agent runtime").version("0.3.3");
 program.command("init").description("Create a sample agent configuration file").option("--agent-id <id>", "Agent ID (from dashboard)", "my-agent").option("--api-url <url>", "API server URL", "http://localhost:3002").option("--config <path>", "Config file path", "agent-config.json").action((opts) => {
   printBanner();
   writeSampleConfig(opts.agentId, opts.apiUrl, opts.config);

package/dist/index.js

@@ -43,7 +43,7 @@ import {
   loadConfig,
   loadStrategy,
   writeSampleConfig
-} from "./chunk-VDK4XPAC.js";
+} from "./chunk-F4TCYYTD.js";
 export {
   AcrossAdapter,
   AerodromeAdapter,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exagent/agent",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,7 +19,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.1.0",
-    "@exagent/sdk": "workspace:*",
+    "@exagent/sdk": "^0.2.1",
     "@polymarket/clob-client": "^4.0.0",
     "boxen": "^8.0.1",
     "commander": "^12.0.0",

package/src/cli.ts

@@ -11,7 +11,7 @@ const program = new Command();
 program
   .name('exagent')
   .description('Exagent — LLM trading agent runtime')
-  .version('0.3.0');
+  .version('0.3.3');
 
 program
   .command('init')

package/src/config.ts

@@ -258,7 +258,7 @@ const secureStoreSchema = z.object({
 
 export type RuntimeConfigFile = z.infer<typeof configFileSchema>;
 
-const DEFAULT_SCRYPT_COST = 32768;
+const DEFAULT_SCRYPT_COST = 16384;
 const DEFAULT_SCRYPT_BLOCK_SIZE = 8;
 const DEFAULT_SCRYPT_PARALLELIZATION = 1;
 

package/src/runtime.ts

@@ -58,6 +58,21 @@ try { SDK_VERSION = _require('../package.json').version; } catch {}
 /** Number of consecutive cycle failures before switching to idle */
 const MAX_CONSECUTIVE_FAILURES = 3;
 
+function getCycleErrorHint(category: string, msg: string): string | null {
+  const lower = msg.toLowerCase();
+  if (category === 'auth' || lower.includes('401') || lower.includes('unauthorized') || lower.includes('invalid api key') || lower.includes('authentication'))
+    return 'Check your LLM API key — update via npx exagent setup';
+  if (category === 'network' || lower.includes('econnrefused') || lower.includes('enotfound') || lower.includes('fetch failed') || lower.includes('timeout'))
+    return 'Network connectivity issue — check your internet connection';
+  if (category === 'venue' || lower.includes('hyperliquid') || lower.includes('polymarket') || lower.includes('venue'))
+    return 'Venue API error — the venue may be experiencing issues';
+  if (category === 'strategy' || lower.includes('invalid') && lower.includes('signal') || lower.includes('strategy'))
+    return 'Strategy returned invalid output — check your strategy file';
+  if (lower.includes('rate limit') || lower.includes('429'))
+    return 'Rate limited — consider increasing tradingIntervalMs';
+  return null;
+}
+
 export class AgentRuntime {
   private config: RuntimeConfig;
   private relay: RelayClient;
@@ -809,12 +824,13 @@ export class AgentRuntime {
       timings.totalMs = Date.now() - cycleStart;
 
       const categorized = this.diagnostics.recordError(err as Error);
-      log.error('cycle', `Cycle error: ${errMsg}`, {
+      const hint = getCycleErrorHint(categorized.category, errMsg);
+      log.error('cycle', `Cycle error: ${errMsg}${hint ? ` — ${hint}` : ''}`, {
         cycle: this.cycleCount,
         totalMs: timings.totalMs,
         category: categorized.category,
       });
-      this.signal.reportError('Cycle Error', errMsg);
+      this.signal.reportError('Cycle Error', `${errMsg}${hint ? ` — ${hint}` : ''}`);
 
       this.diagnostics.recordCycle({
         cycleNumber: this.cycleCount,

package/src/setup.ts

@@ -33,6 +33,24 @@ function cancelled(): never {
   process.exit(0);
 }
 
+function isNonInteractive(): boolean {
+  return process.env.EXAGENT_NONINTERACTIVE === '1' || process.env.EXAGENT_NONINTERACTIVE === 'true';
+}
+
+const LLM_KEY_PREFIXES: Record<string, string> = {
+  openai: 'sk-',
+  anthropic: 'sk-ant-',
+};
+
+function validateLlmKeyFormat(provider: string, key: string): string | undefined {
+  if (!key.trim()) return 'API key is required.';
+  const expectedPrefix = LLM_KEY_PREFIXES[provider];
+  if (expectedPrefix && !key.startsWith(expectedPrefix)) {
+    return `${provider} API keys typically start with "${expectedPrefix}". Double-check your key.`;
+  }
+  if (key.length < 10) return 'API key seems too short.';
+}
+
 // ---------------------------------------------------------------------------
 // Step 1: Bootstrap
 // ---------------------------------------------------------------------------
@@ -74,6 +92,24 @@ async function setupWallet(config: RuntimeConfigFile): Promise<string> {
     return config.wallet.privateKey;
   }
 
+  // Non-interactive: env var wallet
+  if (isNonInteractive()) {
+    const mode = process.env.EXAGENT_WALLET_MODE || 'generate';
+    if (mode === 'import') {
+      const key = process.env.EXAGENT_WALLET_KEY;
+      if (!key || !/^0x[a-fA-F0-9]{64}$/.test(key)) {
+        throw new Error('EXAGENT_WALLET_KEY must be a valid 0x-prefixed 64-char hex private key in non-interactive mode');
+      }
+      const address = privateKeyToAccount(key as `0x${string}`).address;
+      printDone(`Wallet imported: ${pc.dim(address)}`);
+      return key;
+    }
+    const privateKey = generatePrivateKey();
+    const address = privateKeyToAccount(privateKey).address;
+    printDone(`Wallet created: ${pc.dim(address)}`);
+    return privateKey;
+  }
+
   const method = await clack.select({
     message: 'How would you like to set up your wallet?',
     options: [
@@ -116,8 +152,24 @@ async function setupLlm(
   config: RuntimeConfigFile,
   bootstrapPayload: BootstrapPayload,
 ): Promise<{ provider: string; model: string; apiKey: string }> {
-  // Provider
-  let provider = config.llm?.provider || bootstrapPayload.llm?.provider;
+  // D8: If bootstrap has no LLM payload AND config has no real apiKey,
+  // the config's provider/model are just wizard defaults — don't trust them.
+  const hasRealLlmConfig = !!(bootstrapPayload.llm?.apiKey || config.llm?.apiKey);
+
+  // Non-interactive mode
+  if (isNonInteractive()) {
+    const provider = process.env.EXAGENT_LLM_PROVIDER || bootstrapPayload.llm?.provider || (hasRealLlmConfig ? config.llm?.provider : undefined);
+    const model = process.env.EXAGENT_LLM_MODEL || bootstrapPayload.llm?.model || (hasRealLlmConfig ? config.llm?.model : undefined);
+    const apiKey = process.env.EXAGENT_LLM_KEY || bootstrapPayload.llm?.apiKey || config.llm?.apiKey;
+    if (!provider) throw new Error('EXAGENT_LLM_PROVIDER required in non-interactive mode');
+    if (!model) throw new Error('EXAGENT_LLM_MODEL required in non-interactive mode');
+    if (!apiKey) throw new Error('EXAGENT_LLM_KEY required in non-interactive mode');
+    printDone('LLM configured');
+    return { provider, model, apiKey };
+  }
+
+  // Provider — only trust config value if we have a real LLM config
+  let provider = bootstrapPayload.llm?.provider || (hasRealLlmConfig ? config.llm?.provider : undefined);
   if (provider) {
     printInfo(`Provider: ${pc.cyan(provider)} ${pc.dim('(from dashboard)')}`);
   } else {
@@ -129,8 +181,8 @@ async function setupLlm(
     provider = selected;
   }
 
-  // Model
-  let model = config.llm?.model || bootstrapPayload.llm?.model;
+  // Model — only trust config value if we have a real LLM config
+  let model = bootstrapPayload.llm?.model || (hasRealLlmConfig ? config.llm?.model : undefined);
   if (model) {
     printInfo(`Model: ${pc.cyan(model)} ${pc.dim('(from dashboard)')}`);
   } else {
@@ -163,9 +215,7 @@ async function setupLlm(
   if (!apiKey) {
     const entered = await clack.password({
       message: 'LLM API key:',
-      validate: (val) => {
-        if (!val.trim()) return 'API key is required.';
-      },
+      validate: (val) => validateLlmKeyFormat(provider, val),
     });
     if (clack.isCancel(entered)) cancelled();
     apiKey = entered;
@@ -180,6 +230,15 @@ async function setupLlm(
 // ---------------------------------------------------------------------------
 
 async function setupEncryption(): Promise<string> {
+  // Non-interactive mode
+  if (isNonInteractive()) {
+    const password = process.env.EXAGENT_PASSWORD;
+    if (!password || password.length < 12) {
+      throw new Error('EXAGENT_PASSWORD must be at least 12 characters in non-interactive mode');
+    }
+    return password;
+  }
+
   printInfo(`Secrets encrypted with ${pc.cyan('AES-256-GCM')} (${pc.cyan('scrypt')} KDF)`);
   printInfo('The password never leaves this machine.');
   console.log();
@@ -228,6 +287,11 @@ function writeSecureStore(path: string, secrets: LocalSecretPayload, password: s
 // ---------------------------------------------------------------------------
 
 export async function promptSecretPassword(question: string = 'Device password:'): Promise<string> {
+  if (isNonInteractive()) {
+    const password = process.env.EXAGENT_PASSWORD || process.env.EXAGENT_SECRET_PASSWORD;
+    if (!password) throw new Error('EXAGENT_PASSWORD required in non-interactive mode');
+    return password;
+  }
   const password = await clack.password({ message: question });
   if (clack.isCancel(password)) cancelled();
   return password;
@@ -287,15 +351,20 @@ export async function ensureLocalSetup(configPath: string): Promise<void> {
   };
 
   if (!secrets.apiToken) {
-    // Prompt for relay token if not available from bootstrap or config
-    const token = await clack.password({
-      message: 'Agent relay token:',
-      validate: (val) => {
-        if (!val.trim()) return 'Relay token is required.';
-      },
-    });
-    if (clack.isCancel(token)) cancelled();
-    secrets.apiToken = token;
+    if (isNonInteractive()) {
+      const token = process.env.EXAGENT_API_TOKEN;
+      if (!token) throw new Error('EXAGENT_API_TOKEN required in non-interactive mode (no relay token from bootstrap)');
+      secrets.apiToken = token;
+    } else {
+      const token = await clack.password({
+        message: 'Agent relay token:',
+        validate: (val) => {
+          if (!val.trim()) return 'Relay token is required.';
+        },
+      });
+      if (clack.isCancel(token)) cancelled();
+      secrets.apiToken = token;
+    }
   }
 
   const nextConfig = structuredClone(config);