@moltium/core 0.1.28 → 0.1.30

package/dist/index.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,208 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/logger.ts
+function createLogger(label) {
+  return import_winston.default.createLogger({
+    level: logLevel,
+    format: import_winston.default.format.combine(
+      import_winston.default.format.timestamp({ format: "HH:mm:ss" }),
+      import_winston.default.format.label({ label }),
+      import_winston.default.format.printf(({ timestamp, level, label: label2, message, ...meta }) => {
+        const lvlColor = levelColors[level] || colors.white;
+        const lvl = `${lvlColor}${level.toUpperCase().padEnd(5)}${colors.reset}`;
+        const mod = `${colors.magenta}[${label2}]${colors.reset}`;
+        const ts = `${colors.dim}${timestamp}${colors.reset}`;
+        const metaStr = Object.keys(meta).length > 0 ? ` ${colors.dim}${JSON.stringify(meta)}${colors.reset}` : "";
+        return `${ts} ${lvl} ${mod} ${message}${metaStr}`;
+      })
+    ),
+    transports: [new import_winston.default.transports.Console()]
+  });
+}
+var import_winston, logLevel, colors, levelColors;
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    import_winston = __toESM(require("winston"), 1);
+    logLevel = process.env.LOG_LEVEL || "info";
+    colors = {
+      reset: "\x1B[0m",
+      dim: "\x1B[2m",
+      bold: "\x1B[1m",
+      cyan: "\x1B[36m",
+      yellow: "\x1B[33m",
+      green: "\x1B[32m",
+      red: "\x1B[31m",
+      magenta: "\x1B[35m",
+      blue: "\x1B[34m",
+      white: "\x1B[37m",
+      gray: "\x1B[90m"
+    };
+    levelColors = {
+      error: colors.red,
+      warn: colors.yellow,
+      info: colors.green,
+      debug: colors.gray
+    };
+  }
+});
+
+// src/wallet/AgentWallet.ts
+var AgentWallet_exports = {};
+__export(AgentWallet_exports, {
+  AgentWallet: () => AgentWallet
+});
+var logger3, AgentWallet;
+var init_AgentWallet = __esm({
+  "src/wallet/AgentWallet.ts"() {
+    "use strict";
+    init_logger();
+    logger3 = createLogger("AgentWallet");
+    AgentWallet = class {
+      constructor(privateKey, rpcUrl) {
+        this.privateKey = privateKey;
+        if (!privateKey.startsWith("0x")) {
+          this.privateKey = `0x${privateKey}`;
+        }
+        if (rpcUrl) {
+          this.connect(rpcUrl);
+        }
+      }
+      ethers;
+      wallet;
+      // ethers.Wallet
+      provider;
+      // ethers.JsonRpcProvider
+      _address = null;
+      /**
+       * Lazy-load ethers.js (optional peer dependency)
+       */
+      async loadEthers() {
+        if (this.ethers) return this.ethers;
+        try {
+          this.ethers = await import("ethers");
+          return this.ethers;
+        } catch {
+          throw new Error(
+            "ethers.js is required for wallet operations. Install it: npm install ethers"
+          );
+        }
+      }
+      /**
+       * Ensure wallet is initialized
+       */
+      async ensureWallet() {
+        if (this.wallet) return;
+        const ethers = await this.loadEthers();
+        if (this.provider) {
+          this.wallet = new ethers.Wallet(this.privateKey, this.provider);
+        } else {
+          this.wallet = new ethers.Wallet(this.privateKey);
+        }
+        this._address = this.wallet.address;
+      }
+      /**
+       * Connect to a blockchain RPC endpoint
+       */
+      connect(rpcUrl) {
+        this._rpcUrl = rpcUrl;
+        this.wallet = null;
+        this.provider = null;
+      }
+      _rpcUrl;
+      /**
+       * Ensure provider is connected
+       */
+      async ensureProvider() {
+        if (this.provider) return;
+        if (!this._rpcUrl) {
+          throw new Error("No RPC URL configured. Call connect(rpcUrl) first.");
+        }
+        const ethers = await this.loadEthers();
+        this.provider = new ethers.JsonRpcProvider(this._rpcUrl);
+        this.wallet = new ethers.Wallet(this.privateKey, this.provider);
+        this._address = this.wallet.address;
+      }
+      /**
+       * Get the wallet address derived from the private key.
+       * This is synchronous if ethers is already loaded, otherwise async.
+       */
+      getAddress() {
+        if (this._address) return this._address;
+        try {
+          const ethers = require("ethers");
+          const addr = ethers.computeAddress(this.privateKey);
+          this._address = addr;
+          return addr;
+        } catch {
+          throw new Error(
+            "ethers.js is required for wallet operations. Install it: npm install ethers"
+          );
+        }
+      }
+      /**
+       * Get wallet address (async version — always works)
+       */
+      async getAddressAsync() {
+        if (this._address) return this._address;
+        const ethers = await this.loadEthers();
+        const addr = ethers.computeAddress(this.privateKey);
+        this._address = addr;
+        return addr;
+      }
+      /**
+       * Send native tokens (MON/ETH) to an address
+       * @param to Recipient address
+       * @param amountWei Amount in wei (string)
+       * @returns Transaction hash
+       */
+      async sendPayment(to, amountWei) {
+        await this.ensureProvider();
+        logger3.info(`Sending payment: ${amountWei} wei to ${to}`);
+        const tx = await this.wallet.sendTransaction({
+          to,
+          value: BigInt(amountWei)
+        });
+        logger3.info(`Payment sent, waiting for confirmation...`, { txHash: tx.hash });
+        const receipt = await tx.wait();
+        if (receipt.status !== 1) {
+          throw new Error(`Payment transaction failed: ${tx.hash}`);
+        }
+        logger3.info(`Payment confirmed`, { txHash: tx.hash });
+        return tx.hash;
+      }
+      /**
+       * Sign a message with the wallet's private key
+       * @param message Message to sign
+       * @returns Signature hex string
+       */
+      async signMessage(message) {
+        await this.ensureWallet();
+        return this.wallet.signMessage(message);
+      }
+      /**
+       * Get wallet balance in wei
+       * @returns Balance as string (wei)
+       */
+      async getBalance() {
+        await this.ensureProvider();
+        const balance = await this.provider.getBalance(this.wallet.address);
+        return balance.toString();
+      }
+      /**
+       * Get formatted balance (in ETH/MON)
+       */
+      async getFormattedBalance() {
+        await this.ensureProvider();
+        const ethers = await this.loadEthers();
+        const balance = await this.provider.getBalance(this.wallet.address);
+        return ethers.formatEther(balance);
+      }
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -36,6 +241,7 @@ __export(index_exports, {
   ActionRegistry: () => ActionRegistry,
   Agent: () => Agent,
   AgentCardBuilder: () => AgentCardBuilder,
+  AgentWallet: () => AgentWallet,
   AnthropicProvider: () => AnthropicProvider,
   ConfigLoader: () => ConfigLoader,
   LLMProvider: () => LLMProvider,
@@ -70,25 +276,8 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/logger.ts
-var import_winston = __toESM(require("winston"), 1);
-var logLevel = process.env.LOG_LEVEL || "info";
-function createLogger(label) {
-  return import_winston.default.createLogger({
-    level: logLevel,
-    format: import_winston.default.format.combine(
-      import_winston.default.format.timestamp(),
-      import_winston.default.format.label({ label }),
-      import_winston.default.format.printf(({ timestamp, level, label: label2, message, ...meta }) => {
-        const metaStr = Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : "";
-        return `${timestamp} [${label2}] ${level}: ${message}${metaStr}`;
-      })
-    ),
-    transports: [new import_winston.default.transports.Console()]
-  });
-}
-
 // src/agent/scheduler.ts
+init_logger();
 var logger = createLogger("Scheduler");
 var Scheduler = class {
   jobs = [];
@@ -168,6 +357,7 @@ var ActionRegistry = class {
 };
 
 // src/actions/ActionHandler.ts
+init_logger();
 var logger2 = createLogger("ActionHandler");
 var ActionExecutionError = class extends Error {
   constructor(message, actionName, recoverable = true) {
@@ -497,10 +687,12 @@ var moltbookActions = [
 ];
 
 // src/actions/built-in/world.ts
+init_logger();
+var logger4 = createLogger("WorldActions");
 function createJoinWorldAction(config) {
   return {
     name: "join_world",
-    description: `Join a world by URL. The world will fetch this agent's A2A Agent Card and evaluate admission. Parameters: worldUrl (string${config?.defaultWorldUrl ? ", optional" : ", required"}) - the world server URL${config?.defaultWorldUrl ? ` (defaults to ${config.defaultWorldUrl})` : ""}, walletAddress (string, optional) - wallet address for blockchain worlds.`,
+    description: `Join a world by URL. The world will fetch this agent's A2A Agent Card and evaluate admission. If the world requires an entry fee, the agent will pay automatically using its wallet. Parameters: worldUrl (string${config?.defaultWorldUrl ? ", optional" : ", required"}) - the world server URL${config?.defaultWorldUrl ? ` (defaults to ${config.defaultWorldUrl})` : ""}, walletAddress (string, optional) - wallet address for blockchain worlds.`,
     async execute(context) {
       const { parameters, agent } = context;
       const worldUrl = parameters.worldUrl || config?.defaultWorldUrl;
@@ -510,11 +702,45 @@ function createJoinWorldAction(config) {
       const agentPort = process.env.PORT || "3000";
       const agentHost = process.env.HOST || "localhost";
       const agentUrl = `http://${agentHost}:${agentPort}`;
+      const walletAddress = parameters.walletAddress || agent?.config?.world?.walletAddress;
       try {
         const { default: axios2 } = await import("axios");
+        let paymentTxHash;
+        try {
+          const infoRes = await axios2.get(`${worldUrl}/world/join-info`, { timeout: 5e3 });
+          const joinInfo = infoRes.data;
+          if (joinInfo.requiresPayment && joinInfo.entryFee && joinInfo.entryFee !== "0") {
+            const privateKey = agent?.config?.world?.privateKey;
+            if (!privateKey) {
+              return {
+                success: false,
+                error: "World requires entry fee but agent has no wallet private key configured. Set AGENT_WALLET_PRIVATE_KEY in your .env file."
+              };
+            }
+            logger4.info(`World requires entry fee: ${joinInfo.entryFee} wei`);
+            const { AgentWallet: AgentWallet2 } = await Promise.resolve().then(() => (init_AgentWallet(), AgentWallet_exports));
+            const wallet = new AgentWallet2(privateKey, joinInfo.rpcUrl);
+            const balance = await wallet.getBalance();
+            if (BigInt(balance) < BigInt(joinInfo.entryFee)) {
+              const { formatEther } = await import("ethers");
+              return {
+                success: false,
+                error: `Insufficient balance to pay entry fee. Need ${formatEther(joinInfo.entryFee)} MON, have ${formatEther(balance)} MON`
+              };
+            }
+            logger4.info(`Paying entry fee to ${joinInfo.paymentAddress}...`);
+            paymentTxHash = await wallet.sendPayment(joinInfo.paymentAddress, joinInfo.entryFee);
+            logger4.info(`Entry fee paid. TX: ${paymentTxHash}`);
+          }
+        } catch (infoError) {
+          if (infoError?.response?.status !== 404) {
+            logger4.debug(`Could not query join-info: ${infoError.message}`);
+          }
+        }
         const response = await axios2.post(`${worldUrl}/world/join`, {
           agentUrl,
-          walletAddress: parameters.walletAddress || agent?.config?.world?.walletAddress
+          walletAddress,
+          paymentTxHash
         }, { timeout: 1e4 });
         return {
           success: true,
@@ -663,17 +889,39 @@ ${config.llm.systemPrompt}`);
 }
 function buildDecisionPrompt(context, availableActions) {
   const actionList = availableActions.map((a) => `- ${a.name}: ${a.description}`).join("\n");
+  const actionNames = availableActions.map((a) => a.name);
+  const hasWorldActions = actionNames.some(
+    (n) => ["send_world_message", "query_world", "join_world", "leave_world"].includes(n)
+  );
+  const hasSocialActions = actionNames.some(
+    (n) => ["post_social_update", "respond_to_mention"].includes(n)
+  );
   const recent = context.recentActions || [];
   const recentNames = recent.map((r) => r.action);
   const lastAction = recentNames.length > 0 ? recentNames[recentNames.length - 1] : "none";
   let varietyHint = "";
   if (recentNames.length > 0) {
+    const suggestions = [];
+    if (hasWorldActions) {
+      suggestions.push("querying the world for agents", "sending messages to other agents", "responding to conversations");
+    }
+    if (hasSocialActions) {
+      suggestions.push("posting content", "responding to mentions");
+    }
+    const suggestStr = suggestions.length > 0 ? `
+Vary between: ${suggestions.join(", ")}.` : "";
     varietyHint = `
 Your recent actions (most recent last): ${recentNames.join(" \u2192 ")}
-IMPORTANT: Do NOT repeat "${lastAction}" again. Choose a DIFFERENT action to keep your behavior varied and interesting.
-Vary between: posting content, checking your feed, replying to others, checking DMs, browsing communities, searching for topics, and following interesting agents.`;
+IMPORTANT: Do NOT repeat "${lastAction}" again. Choose a DIFFERENT action to keep your behavior varied and interesting.` + suggestStr;
+  }
+  let preamble = "You are an autonomous AI agent.";
+  if (hasWorldActions) {
+    preamble += " You are connected to a world with other agents.";
+    preamble += " Use send_world_message to communicate with other agents (provide toAgentUrl and message parameters).";
+    preamble += " Use query_world to discover agents and world state.";
+    preamble += ' IMPORTANT: Only use actions from the "Available actions" list below. Do NOT invent action names.';
   }
-  return `You are an autonomous AI agent on moltbook (a social network for AI agents).
+  return `${preamble}
 Decide what action to take next based on the current context and your personality.
 
 Available actions:
@@ -684,7 +932,7 @@ ${JSON.stringify(context, null, 2)}
 ${varietyHint}
 
 Think about what would be most natural and valuable right now.
-If the action generates content (post, comment, DM), include the actual content in parameters.
+Choose ONLY from the available actions listed above.
 
 Respond with a JSON object:
 {
@@ -711,7 +959,8 @@ Execute these instructions step by step and return the result as a JSON object:
 }
 
 // src/actions/interpreter.ts
-var logger3 = createLogger("MarkdownInterpreter");
+init_logger();
+var logger5 = createLogger("MarkdownInterpreter");
 var LLMInterpretationError = class extends Error {
   constructor(message) {
     super(message);
@@ -723,7 +972,7 @@ function createMarkdownAction(name, description, llmProvider) {
     name,
     description,
     execute: async (context) => {
-      logger3.info(`Interpreting markdown skill: ${name}`);
+      logger5.info(`Interpreting markdown skill: ${name}`);
       const prompt = buildSkillPrompt(name, description, context.parameters);
       try {
         const response = await llmProvider.generateText(prompt, {
@@ -744,7 +993,7 @@ function createMarkdownAction(name, description, llmProvider) {
       } catch (error) {
         if (error instanceof LLMInterpretationError) throw error;
         const message = error instanceof Error ? error.message : String(error);
-        logger3.error(`Markdown skill interpretation failed: ${name}`, { error: message });
+        logger5.error(`Markdown skill interpretation failed: ${name}`, { error: message });
         throw new LLMInterpretationError(
           `Failed to interpret skill "${name}": ${message}`
         );
@@ -1524,6 +1773,9 @@ var TwitterAdapter = class extends SocialAdapter {
   }
 };
 
+// src/agent/Agent.ts
+init_logger();
+
 // src/a2a/client.ts
 var import_client = require("@a2a-js/sdk/client");
 var import_uuid = require("uuid");
@@ -1697,7 +1949,7 @@ function createMultipleA2AActions(configs) {
 }
 
 // src/agent/Agent.ts
-var logger4 = createLogger("Agent");
+var logger6 = createLogger("Agent");
 function parsePostFrequency(freq) {
   const lower = freq.toLowerCase().trim();
   if (lower === "realtime") return 5 * 60 * 1e3;
@@ -1793,7 +2045,17 @@ var Agent = class {
   // ── Lifecycle ──
   async init() {
     this.state = "initializing";
-    logger4.info(`Initializing agent: ${this.config.name}`);
+    logger6.info(`Initializing agent: ${this.config.name}`);
+    if (this.config.world?.privateKey && !this.config.world.walletAddress) {
+      try {
+        const { AgentWallet: AgentWallet2 } = await Promise.resolve().then(() => (init_AgentWallet(), AgentWallet_exports));
+        const wallet = new AgentWallet2(this.config.world.privateKey);
+        this.config.world.walletAddress = await wallet.getAddressAsync();
+        logger6.info(`Wallet address derived: ${this.config.world.walletAddress}`);
+      } catch (error) {
+        logger6.warn(`Failed to derive wallet address: ${error.message}`);
+      }
+    }
     this.initLLM();
     this.registerActions();
     await this.initSocialAdapters();
@@ -1802,7 +2064,7 @@ var Agent = class {
       await this.hooks.onInit(this);
     }
     await this.postStartupMessages();
-    logger4.info(`Agent initialized: ${this.config.name}`);
+    logger6.info(`Agent initialized: ${this.config.name}`);
   }
   async start() {
     if (this.state !== "initializing" && this.state !== "idle") {
@@ -1812,7 +2074,7 @@ var Agent = class {
       await this.init();
     }
     this.state = "running";
-    logger4.info(`Agent started: ${this.config.name}`);
+    logger6.info(`Agent started: ${this.config.name}`);
     if (this.hooks.onStart) {
       await this.hooks.onStart(this);
     }
@@ -1826,7 +2088,7 @@ var Agent = class {
   }
   async stop() {
     this.state = "stopping";
-    logger4.info(`Stopping agent: ${this.config.name}`);
+    logger6.info(`Stopping agent: ${this.config.name}`);
     if (this.tickTimer) {
       clearInterval(this.tickTimer);
       this.tickTimer = void 0;
@@ -1839,7 +2101,7 @@ var Agent = class {
       await this.hooks.onShutdown(this);
     }
     this.state = "stopped";
-    logger4.info(`Agent stopped: ${this.config.name}`);
+    logger6.info(`Agent stopped: ${this.config.name}`);
   }
   // ── Decision Loop ──
   async think() {
@@ -1859,7 +2121,7 @@ var Agent = class {
       },
       { systemPrompt: this.systemPrompt, temperature: this.config.llm.temperature }
     );
-    logger4.debug(`Decision: ${decision.action} \u2014 ${decision.reasoning}`);
+    logger6.debug(`Decision: ${decision.action} \u2014 ${decision.reasoning}`);
     return decision;
   }
   async act(actionName, parameters = {}) {
@@ -1882,17 +2144,17 @@ var Agent = class {
         await this.hooks.onTick(this);
       }
       if (this.isSleeping()) {
-        logger4.info(`Tick #${this.tickCount}: Sleeping \u2014 skipped`);
+        logger6.info(`Tick #${this.tickCount}: Sleeping \u2014 skipped`);
         return;
       }
-      logger4.info(`Tick #${this.tickCount}: Thinking...`);
+      logger6.info(`Tick #${this.tickCount}: Thinking...`);
       const decision = await this.think();
-      logger4.info(`Tick #${this.tickCount}: Decision \u2192 ${decision.action} | Reasoning: ${decision.reasoning}`);
+      logger6.info(`Tick #${this.tickCount}: Decision \u2192 ${decision.action} | Reasoning: ${decision.reasoning}`);
       if (decision.parameters && Object.keys(decision.parameters).length > 0) {
-        logger4.info(`Tick #${this.tickCount}: Parameters \u2192 ${JSON.stringify(decision.parameters)}`);
+        logger6.info(`Tick #${this.tickCount}: Parameters \u2192 ${JSON.stringify(decision.parameters)}`);
       }
       const result = await this.act(decision.action, decision.parameters);
-      logger4.info(`Tick #${this.tickCount}: Result \u2192 success=${result.success}${result.data ? ` data=${JSON.stringify(result.data).slice(0, 200)}` : ""}`);
+      logger6.info(`Tick #${this.tickCount}: Result \u2192 success=${result.success}${result.data ? ` data=${JSON.stringify(result.data).slice(0, 200)}` : ""}`);
       this.recentActions.push({
         action: decision.action,
         reasoning: decision.reasoning,
@@ -1910,7 +2172,7 @@ var Agent = class {
         await this.fireWebhook("onAction", decision, result);
       }
     } catch (error) {
-      logger4.error(`Tick #${this.tickCount} error: ${error instanceof Error ? error.message : error}`);
+      logger6.error(`Tick #${this.tickCount} error: ${error instanceof Error ? error.message : error}`);
       if (this.hooks.onError && error instanceof Error) {
         await this.hooks.onError(error, this);
       }
@@ -1950,7 +2212,7 @@ var Agent = class {
           this.actionRegistry.register(action);
         }
       }
-      logger4.info(`Registered ${moltbookActions.length} Moltbook actions`);
+      logger6.info(`Registered ${moltbookActions.length} Moltbook actions`);
     }
     const a2a = this.config.a2a;
     if (a2a && a2a.enabled !== false) {
@@ -1970,7 +2232,7 @@ var Agent = class {
             this.actionRegistry.register(action);
           }
         }
-        logger4.info(`Registered ${peerActions.length} A2A peer actions`);
+        logger6.info(`Registered ${peerActions.length} A2A peer actions`);
       } else {
         const genericAction = createA2ACommunicationAction({
           defaultAgentUrl: a2a.defaultPeerUrl,
@@ -1980,7 +2242,7 @@ var Agent = class {
         if (!this.actionRegistry.has(genericAction.name)) {
           this.actionRegistry.register(genericAction);
         }
-        logger4.info(`Registered generic A2A action: ${genericAction.name}`);
+        logger6.info(`Registered generic A2A action: ${genericAction.name}`);
       }
     }
     const world = this.config.world;
@@ -1997,7 +2259,7 @@ var Agent = class {
           this.actionRegistry.register(action);
         }
       }
-      logger4.info(`Registered 4 world actions (world: ${worldUrl})`);
+      logger6.info(`Registered 4 world actions (world: ${worldUrl})`);
     }
     if (this.config.customActions) {
       for (const action of this.config.customActions) {
@@ -2010,7 +2272,7 @@ var Agent = class {
     await this.initMoltbook(social);
     await this.initTwitter(social);
     if (Object.keys(this.socialAdapters).length === 0) {
-      logger4.warn("Social: No adapters connected. Set MOLTBOOK_API_KEY or Twitter env vars in your .env to enable.");
+      logger6.warn("Social: No adapters connected. Set MOLTBOOK_API_KEY or Twitter env vars in your .env to enable.");
     }
   }
   async initMoltbook(social) {
@@ -2021,13 +2283,13 @@ var Agent = class {
     const explicitlyDisabled = configMoltbook && configMoltbook.enabled === false && !envKey;
     const shouldConnect = !isPlaceholder && !explicitlyDisabled;
     if (explicitlyDisabled) {
-      logger4.info("Moltbook: Disabled in config and no MOLTBOOK_API_KEY in env \u2014 skipping");
+      logger6.info("Moltbook: Disabled in config and no MOLTBOOK_API_KEY in env \u2014 skipping");
       return;
     }
     if (isPlaceholder) {
       if (configMoltbook?.enabled || envKey) {
-        logger4.warn("Moltbook: MOLTBOOK_API_KEY is missing or still a placeholder.");
-        logger4.warn("  Fix: Set a valid MOLTBOOK_API_KEY in your .env file.");
+        logger6.warn("Moltbook: MOLTBOOK_API_KEY is missing or still a placeholder.");
+        logger6.warn("  Fix: Set a valid MOLTBOOK_API_KEY in your .env file.");
       }
       return;
     }
@@ -2045,16 +2307,16 @@ var Agent = class {
       ...configMoltbook?.apiKey ? {} : { apiKey },
       ...configMoltbook?.baseUrl ? {} : { baseUrl }
     };
-    logger4.info(`Moltbook: API key detected from ${source}`);
-    logger4.info(`Moltbook: Connecting to ${baseUrl} ...`);
+    logger6.info(`Moltbook: API key detected from ${source}`);
+    logger6.info(`Moltbook: Connecting to ${baseUrl} ...`);
     const adapter = new MoltbookAdapter(effectiveConfig);
     try {
       await adapter.connect();
       this.socialAdapters["moltbook"] = adapter;
       social.moltbook = effectiveConfig;
-      logger4.info(`Moltbook: Connected successfully (submolt: ${defaultSubmolt})`);
+      logger6.info(`Moltbook: Connected successfully (submolt: ${defaultSubmolt})`);
     } catch (error) {
-      logger4.error(`Moltbook: Connection FAILED \u2014 ${error.message || error}`);
+      logger6.error(`Moltbook: Connection FAILED \u2014 ${error.message || error}`);
       this.logPlatformError("Moltbook", error);
     }
   }
@@ -2073,23 +2335,23 @@ var Agent = class {
     const hasAllCreds = hasKey && apiSecret && accessToken && accessSecret;
     const explicitlyDisabled = configTwitter && configTwitter.enabled === false && !envApiKey;
     if (explicitlyDisabled) {
-      logger4.info("Twitter: Disabled in config and no TWITTER_API_KEY in env \u2014 skipping");
+      logger6.info("Twitter: Disabled in config and no TWITTER_API_KEY in env \u2014 skipping");
       return;
     }
     if (!hasKey) {
       if (configTwitter?.enabled || envApiKey) {
-        logger4.warn("Twitter: Credentials are missing or still placeholders.");
-        logger4.warn("  Fix: Set valid Twitter keys in your .env file.");
+        logger6.warn("Twitter: Credentials are missing or still placeholders.");
+        logger6.warn("  Fix: Set valid Twitter keys in your .env file.");
       }
       return;
     }
     if (!hasAllCreds) {
-      logger4.warn("Twitter: Some credentials are missing. Need: TWITTER_API_KEY, TWITTER_API_SECRET, TWITTER_ACCESS_TOKEN, TWITTER_ACCESS_SECRET");
+      logger6.warn("Twitter: Some credentials are missing. Need: TWITTER_API_KEY, TWITTER_API_SECRET, TWITTER_ACCESS_TOKEN, TWITTER_ACCESS_SECRET");
       return;
     }
     const source = creds?.apiKey ? "config" : "environment";
-    logger4.info(`Twitter: Credentials detected from ${source}`);
-    logger4.info("Twitter: Connecting...");
+    logger6.info(`Twitter: Credentials detected from ${source}`);
+    logger6.info("Twitter: Connecting...");
     const effectiveConfig = {
       enabled: true,
       ...configTwitter,
@@ -2100,16 +2362,16 @@ var Agent = class {
       await adapter.connect();
       this.socialAdapters["twitter"] = adapter;
       social.twitter = effectiveConfig;
-      logger4.info("Twitter: Connected successfully");
+      logger6.info("Twitter: Connected successfully");
     } catch (error) {
-      logger4.error(`Twitter: Connection FAILED \u2014 ${error.message || error}`);
+      logger6.error(`Twitter: Connection FAILED \u2014 ${error.message || error}`);
       this.logPlatformError("Twitter", error);
     }
   }
   async postStartupMessages() {
     const adapters = Object.entries(this.socialAdapters);
     if (adapters.length === 0) {
-      logger4.info("Startup post: No connected social adapters \u2014 skipping");
+      logger6.info("Startup post: No connected social adapters \u2014 skipping");
       return;
     }
     let content;
@@ -2124,18 +2386,18 @@ Write only the post content, nothing else. Keep it concise and natural.`;
         temperature: this.config.llm.temperature ?? 0.8,
         maxTokens: 280
       })).trim();
-      logger4.info(`Startup post: LLM generated content (${content.length} chars)`);
+      logger6.info(`Startup post: LLM generated content (${content.length} chars)`);
     } catch (error) {
-      logger4.warn(`Startup post: LLM generation failed (${error.message}), using fallback`);
+      logger6.warn(`Startup post: LLM generation failed (${error.message}), using fallback`);
       content = `${this.config.name} is now online and ready.`;
     }
     for (const [platform, adapter] of adapters) {
-      logger4.info(`Startup post: Posting to ${platform}...`);
+      logger6.info(`Startup post: Posting to ${platform}...`);
       try {
         const result = await adapter.post(content);
-        logger4.info(`Startup post: ${platform} SUCCESS \u2014 id=${result.id}${result.url ? ` url=${result.url}` : ""}`);
+        logger6.info(`Startup post: ${platform} SUCCESS \u2014 id=${result.id}${result.url ? ` url=${result.url}` : ""}`);
       } catch (error) {
-        logger4.error(`Startup post: ${platform} FAILED \u2014 ${error.message || error}`);
+        logger6.error(`Startup post: ${platform} FAILED \u2014 ${error.message || error}`);
         this.logPlatformError(platform, error);
       }
     }
@@ -2158,7 +2420,7 @@ Write only the post content, nothing else. Keep it concise and natural.`;
               await this.scheduledPost("moltbook");
             }
           });
-          logger4.info(`Scheduler: Moltbook posting every ${formatInterval(intervalMs)}`);
+          logger6.info(`Scheduler: Moltbook posting every ${formatInterval(intervalMs)}`);
         }
       }
     }
@@ -2174,7 +2436,7 @@ Write only the post content, nothing else. Keep it concise and natural.`;
               await this.scheduledPost("twitter");
             }
           });
-          logger4.info(`Scheduler: Twitter posting every ${formatInterval(intervalMs)}`);
+          logger6.info(`Scheduler: Twitter posting every ${formatInterval(intervalMs)}`);
         }
       }
     }
@@ -2190,7 +2452,7 @@ Write only the post content, nothing else. Keep it concise and natural.`;
           await this.executeScheduledTask(task);
         }
       });
-      logger4.info(`Scheduler: "${task.name}" every ${formatInterval(task.intervalMs)}`);
+      logger6.info(`Scheduler: "${task.name}" every ${formatInterval(task.intervalMs)}`);
     }
   }
   async scheduledPost(platform) {
@@ -2206,15 +2468,15 @@ Write only the post content, nothing else. Keep it concise and natural.`;
         maxTokens: 280
       });
       const result = await adapter.post(content.trim());
-      logger4.info(`Scheduled post: ${platform} SUCCESS \u2014 id=${result.id}`);
+      logger6.info(`Scheduled post: ${platform} SUCCESS \u2014 id=${result.id}`);
     } catch (error) {
-      logger4.error(`Scheduled post: ${platform} FAILED \u2014 ${error.message || error}`);
+      logger6.error(`Scheduled post: ${platform} FAILED \u2014 ${error.message || error}`);
       this.logPlatformError(platform, error);
     }
   }
   async executeScheduledTask(task) {
     try {
-      logger4.info(`Scheduled task: Running "${task.name}"`);
+      logger6.info(`Scheduled task: Running "${task.name}"`);
       const prompt = `You are ${this.config.name}, an autonomous agent. Execute the following scheduled task.
 
 Task: ${task.name}
@@ -2239,74 +2501,74 @@ Decide what action to take. Respond with JSON:
         { systemPrompt: this.systemPrompt, temperature: this.config.llm.temperature }
       );
       const result = await this.act(decision.action, decision.parameters);
-      logger4.info(`Scheduled task: "${task.name}" completed \u2014 action=${decision.action}, success=${result.success}`);
+      logger6.info(`Scheduled task: "${task.name}" completed \u2014 action=${decision.action}, success=${result.success}`);
     } catch (error) {
-      logger4.error(`Scheduled task: "${task.name}" FAILED \u2014 ${error.message || error}`);
+      logger6.error(`Scheduled task: "${task.name}" FAILED \u2014 ${error.message || error}`);
     }
   }
   logPlatformError(platform, error) {
     if (!error.response) {
       if (error.code === "ENOTFOUND") {
-        logger4.error(`  ${platform}: DNS lookup failed \u2014 check the base URL.`);
+        logger6.error(`  ${platform}: DNS lookup failed \u2014 check the base URL.`);
       } else if (error.code === "ECONNREFUSED") {
-        logger4.error(`  ${platform}: Connection refused \u2014 is the server running?`);
+        logger6.error(`  ${platform}: Connection refused \u2014 is the server running?`);
       } else if (error.code === "ETIMEDOUT" || error.code === "ECONNABORTED") {
-        logger4.error(`  ${platform}: Request timed out.`);
+        logger6.error(`  ${platform}: Request timed out.`);
       } else {
-        logger4.error(`  ${platform}: Network error (${error.code || "unknown"})`);
+        logger6.error(`  ${platform}: Network error (${error.code || "unknown"})`);
       }
       return;
     }
     const status = error.response.status;
     const data = error.response.data;
-    logger4.error(`  ${platform}: HTTP ${status}`);
+    logger6.error(`  ${platform}: HTTP ${status}`);
     if (data) {
-      if (data.error) logger4.error(`  ${platform}: API error: ${data.error}`);
-      if (data.hint) logger4.error(`  ${platform}: API hint: ${data.hint}`);
-      if (!data.error && !data.hint) logger4.error(`  ${platform}: Response: ${JSON.stringify(data)}`);
+      if (data.error) logger6.error(`  ${platform}: API error: ${data.error}`);
+      if (data.hint) logger6.error(`  ${platform}: API hint: ${data.hint}`);
+      if (!data.error && !data.hint) logger6.error(`  ${platform}: Response: ${JSON.stringify(data)}`);
     }
     if (status === 401) {
-      logger4.error(`  ${platform}: Your API key was rejected. Verify it is correct and the agent is claimed.`);
+      logger6.error(`  ${platform}: Your API key was rejected. Verify it is correct and the agent is claimed.`);
     } else if (status === 403) {
-      logger4.error(`  ${platform}: Forbidden \u2014 your agent may not be claimed yet or lacks permissions.`);
+      logger6.error(`  ${platform}: Forbidden \u2014 your agent may not be claimed yet or lacks permissions.`);
     } else if (status === 429) {
       const retryMin = data?.retry_after_minutes;
       const retrySec = data?.retry_after_seconds;
       if (retryMin) {
-        logger4.error(`  ${platform}: Rate limited \u2014 try again in ${retryMin} minute(s).`);
+        logger6.error(`  ${platform}: Rate limited \u2014 try again in ${retryMin} minute(s).`);
       } else if (retrySec) {
-        logger4.error(`  ${platform}: Rate limited \u2014 try again in ${retrySec} second(s).`);
+        logger6.error(`  ${platform}: Rate limited \u2014 try again in ${retrySec} second(s).`);
       } else {
-        logger4.error(`  ${platform}: Rate limited \u2014 wait before retrying.`);
+        logger6.error(`  ${platform}: Rate limited \u2014 wait before retrying.`);
       }
     } else if (status === 404) {
-      logger4.error(`  ${platform}: Endpoint not found \u2014 check the base URL.`);
+      logger6.error(`  ${platform}: Endpoint not found \u2014 check the base URL.`);
     } else if (status >= 500) {
-      logger4.error(`  ${platform}: Server error \u2014 the platform may be temporarily down.`);
+      logger6.error(`  ${platform}: Server error \u2014 the platform may be temporarily down.`);
     }
   }
   async autoJoinWorld() {
     const worldUrl = this.config.world.url;
-    logger4.info(`Auto-joining world: ${worldUrl}`);
+    logger6.info(`Auto-joining world: ${worldUrl}`);
     try {
       const result = await this.act("join_world", {
         worldUrl,
         walletAddress: this.config.world.walletAddress
       });
       if (result.success) {
-        logger4.info(`Successfully joined world: ${worldUrl}`);
+        logger6.info(`Successfully joined world: ${worldUrl}`);
       } else {
-        logger4.warn(`Failed to join world: ${result.error}`);
+        logger6.warn(`Failed to join world: ${result.error}`);
       }
     } catch (error) {
-      logger4.warn(`Auto-join world failed: ${error?.message || error}`);
+      logger6.warn(`Auto-join world failed: ${error?.message || error}`);
     }
   }
   startAutonomousLoop() {
     const actionsPerHour = typeof this.config.behaviors.actionsPerHour === "function" ? this.config.behaviors.actionsPerHour({}) : this.config.behaviors.actionsPerHour || 5;
     const intervalMs = Math.floor(36e5 / actionsPerHour);
     this.tickTimer = setInterval(() => this.tick(), intervalMs);
-    logger4.info(`Autonomous loop started: ~${actionsPerHour} actions/hour (every ${intervalMs}ms)`);
+    logger6.info(`Autonomous loop started: ~${actionsPerHour} actions/hour (every ${intervalMs}ms)`);
   }
   isSleeping() {
     const schedule = this.config.behaviors.sleepSchedule;
@@ -2341,7 +2603,7 @@ Decide what action to take. Respond with JSON:
         await axios2.post(hook, { event, data: args });
       }
     } catch (error) {
-      logger4.error(`Webhook ${event} failed: ${error}`);
+      logger6.error(`Webhook ${event} failed: ${error}`);
     }
   }
 };
@@ -2481,10 +2743,18 @@ var MarkdownParser = class {
     const fields = this.parseKeyValueLines(section.content);
     const url = fields["url"];
     if (!url) return void 0;
+    let privateKey;
+    const pkField = fields["wallet_private_key"];
+    if (pkField === "env") {
+      privateKey = process.env.AGENT_WALLET_PRIVATE_KEY;
+    } else if (pkField && pkField.startsWith("0x")) {
+      privateKey = pkField;
+    }
     return {
       url,
       autoJoin: fields["auto_join"] !== "false",
-      ...fields["wallet_address"] ? { walletAddress: fields["wallet_address"] } : {}
+      ...fields["wallet_address"] ? { walletAddress: fields["wallet_address"] } : {},
+      ...privateKey ? { privateKey } : {}
     };
   }
   parseSleepSchedule(value) {
@@ -2659,7 +2929,8 @@ var ConfigLoader = class {
 };
 
 // src/memory/longterm.ts
-var logger5 = createLogger("LongTermMemory");
+init_logger();
+var logger7 = createLogger("LongTermMemory");
 var LongTermMemory = class extends Memory {
   redisConfig;
   postgresConfig;
@@ -2835,9 +3106,9 @@ var LongTermMemory = class extends Memory {
     try {
       const { default: Redis } = await import("ioredis");
       this.redis = new Redis(this.redisConfig.url);
-      logger5.info("Redis connection established");
+      logger7.info("Redis connection established");
     } catch (error) {
-      logger5.error(`Failed to connect to Redis: ${error}`);
+      logger7.error(`Failed to connect to Redis: ${error}`);
       throw error;
     }
   }
@@ -2850,9 +3121,9 @@ var LongTermMemory = class extends Memory {
         connectionString: this.postgresConfig.url
       });
       await this.pg.query("SELECT 1");
-      logger5.info("Postgres connection established");
+      logger7.info("Postgres connection established");
     } catch (error) {
-      logger5.error(`Failed to connect to Postgres: ${error}`);
+      logger7.error(`Failed to connect to Postgres: ${error}`);
       throw error;
     }
   }
@@ -2994,13 +3265,14 @@ function createRoutes(agent) {
 }
 
 // src/server/middleware.ts
-var logger6 = createLogger("Server");
+init_logger();
+var logger8 = createLogger("Server");
 function requestLogger(req, _res, next) {
-  logger6.debug(`${req.method} ${req.path}`);
+  logger8.debug(`${req.method} ${req.path}`);
   next();
 }
 function errorHandler(err, _req, res, _next) {
-  logger6.error(`Server error: ${err.message}`);
+  logger8.error(`Server error: ${err.message}`);
   res.status(500).json({ error: err.message });
 }
 function authMiddleware(req, res, next) {
@@ -3017,8 +3289,12 @@ function authMiddleware(req, res, next) {
   next();
 }
 
+// src/server/app.ts
+init_logger();
+
 // src/a2a/AgentCardBuilder.ts
-var logger7 = createLogger("AgentCardBuilder");
+init_logger();
+var logger9 = createLogger("AgentCardBuilder");
 var AgentCardBuilder = class {
   /**
    * Creates an A2A AgentCard from Moltium configuration.
@@ -3040,7 +3316,7 @@ var AgentCardBuilder = class {
       name: config.name,
       description: config.personality.bio || `${config.name} - An autonomous AI agent`,
       protocolVersion: "0.3.0",
-      version: "0.1.28",
+      version: "0.1.30",
       url: `${baseUrl}/a2a/jsonrpc`,
       skills,
       capabilities,
@@ -3051,7 +3327,7 @@ var AgentCardBuilder = class {
         { url: `${baseUrl}/a2a/rest`, transport: "HTTP+JSON" }
       ]
     };
-    logger7.debug("Built A2A AgentCard", {
+    logger9.debug("Built A2A AgentCard", {
       name: agentCard.name,
       skillCount: skills.length,
       baseUrl
@@ -3133,8 +3409,9 @@ var AgentCardBuilder = class {
 };
 
 // src/a2a/MoltiumExecutor.ts
+init_logger();
 var import_uuid2 = require("uuid");
-var logger8 = createLogger("MoltiumExecutor");
+var logger10 = createLogger("MoltiumExecutor");
 var MoltiumExecutor = class {
   agent;
   cancelledTasks = /* @__PURE__ */ new Set();
@@ -3148,7 +3425,7 @@ var MoltiumExecutor = class {
   async execute(requestContext, eventBus) {
     const { taskId, contextId, userMessage, task } = requestContext;
     try {
-      logger8.info(`[A2A] Executing request for task ${taskId}`);
+      logger10.info(`[A2A] Executing request for task ${taskId}`);
       if (!task) {
         const initialTask = {
           kind: "task",
@@ -3186,9 +3463,9 @@ var MoltiumExecutor = class {
       }
       this.publishStatusUpdate(taskId, contextId, "completed", eventBus, true);
       eventBus.finished();
-      logger8.info(`[A2A] Task ${taskId} completed successfully`);
+      logger10.info(`[A2A] Task ${taskId} completed successfully`);
     } catch (error) {
-      logger8.error(`[A2A] Task ${taskId} failed`, {
+      logger10.error(`[A2A] Task ${taskId} failed`, {
         error: error instanceof Error ? error.message : String(error)
       });
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -3203,7 +3480,7 @@ var MoltiumExecutor = class {
    * Handles task cancellation requests.
    */
   async cancelTask(taskId, eventBus) {
-    logger8.info(`[A2A] Cancellation requested for task ${taskId}`);
+    logger10.info(`[A2A] Cancellation requested for task ${taskId}`);
     this.cancelledTasks.add(taskId);
   }
   /**
@@ -3365,7 +3642,7 @@ var MoltiumExecutor = class {
    * Publishes a cancellation status.
    */
   publishCancellation(taskId, contextId, eventBus) {
-    logger8.info(`[A2A] Publishing cancellation for task ${taskId}`);
+    logger10.info(`[A2A] Publishing cancellation for task ${taskId}`);
     this.publishStatusUpdate(taskId, contextId, "canceled", eventBus, true);
     eventBus.finished();
     this.cancelledTasks.delete(taskId);
@@ -3374,7 +3651,8 @@ var MoltiumExecutor = class {
 
 // src/a2a/integration.ts
 var import_server = require("@a2a-js/sdk/server");
-var logger9 = createLogger("A2AIntegration");
+init_logger();
+var logger11 = createLogger("A2AIntegration");
 var A2AIntegration = class {
   agent;
   agentCard;
@@ -3389,7 +3667,7 @@ var A2AIntegration = class {
       new import_server.InMemoryTaskStore(),
       this.moltiumExecutor
     );
-    logger9.info("A2A integration initialized", {
+    logger11.info("A2A integration initialized", {
       agentName: agent.name,
       baseUrl: options.a2aConfig.baseUrl
     });
@@ -3411,7 +3689,7 @@ var A2AIntegration = class {
           const response = await jsonRpcHandler.handle(req.body);
           res.json(response);
         } catch (error) {
-          logger9.error("JSON-RPC error:", error);
+          logger11.error("JSON-RPC error:", error);
           res.status(500).json({
             jsonrpc: "2.0",
             error: {
@@ -3442,7 +3720,7 @@ var A2AIntegration = class {
       new import_server.InMemoryTaskStore(),
       this.moltiumExecutor
     );
-    logger9.info("A2A agent card updated with runtime info", {
+    logger11.info("A2A agent card updated with runtime info", {
       host: actualHost,
       port: actualPort,
       url: this.agentCard.url
@@ -3460,10 +3738,10 @@ var A2AIntegration = class {
   logEndpoints(host, port) {
     const protocol = host === "localhost" || host === "127.0.0.1" ? "http" : "https";
     const baseUrl = `${protocol}://${host}:${port}`;
-    logger9.info("A2A endpoints available:");
-    logger9.info(`  Agent Card:  ${baseUrl}/.well-known/agent.json`);
-    logger9.info(`  JSON-RPC:    ${baseUrl}/a2a/jsonrpc`);
-    logger9.info(`  HTTP+JSON:   ${baseUrl}/a2a/rest`);
+    logger11.info("A2A endpoints available:");
+    logger11.info(`  Agent Card:  ${baseUrl}/.well-known/agent.json`);
+    logger11.info(`  JSON-RPC:    ${baseUrl}/a2a/jsonrpc`);
+    logger11.info(`  HTTP+JSON:   ${baseUrl}/a2a/rest`);
   }
 };
 function createA2AIntegration(agent, options = {}) {
@@ -3478,7 +3756,7 @@ function createA2AIntegration(agent, options = {}) {
 }
 
 // src/server/app.ts
-var logger10 = createLogger("Server");
+var logger12 = createLogger("Server");
 var AGENT_CARD_PATH = ".well-known/agent.json";
 function createApp(agent, options = {}) {
   const app = (0, import_express2.default)();
@@ -3504,9 +3782,10 @@ function createApp(agent, options = {}) {
     });
     const handlers = a2aIntegration.getHandlers();
     app.use(`/${AGENT_CARD_PATH}`, handlers.agentCard);
+    app.use("/.well-known/agent-card.json", handlers.agentCard);
     app.use("/a2a/jsonrpc", handlers.jsonRpc);
     app.use("/a2a/rest", handlers.rest);
-    logger10.info("A2A protocol endpoints enabled");
+    logger12.info("A2A protocol endpoints enabled");
   }
   app.use(errorHandler);
   return app;
@@ -3517,28 +3796,34 @@ async function startServer(agent, options = {}) {
   const app = createApp(agent, options);
   await new Promise((resolve2) => {
     app.listen(port, host, () => {
-      logger10.info(`Agent "${agent.name}" running at http://${host}:${port}`);
+      logger12.info(`Agent "${agent.name}" running at http://${host}:${port}`);
       if (options.enableA2A !== false) {
         const logHost = host === "0.0.0.0" ? "localhost" : host;
         const protocol = logHost === "localhost" || logHost === "127.0.0.1" ? "http" : "https";
         const baseUrl = `${protocol}://${logHost}:${port}`;
-        logger10.info("A2A Protocol Endpoints:");
-        logger10.info(`  Agent Card:  ${baseUrl}/.well-known/agent.json`);
-        logger10.info(`  JSON-RPC:    ${baseUrl}/a2a/jsonrpc`);
-        logger10.info(`  HTTP+JSON:   ${baseUrl}/a2a/rest`);
+        logger12.info("A2A Protocol Endpoints:");
+        logger12.info(`  Agent Card:  ${baseUrl}/.well-known/agent.json`);
+        logger12.info(`  JSON-RPC:    ${baseUrl}/a2a/jsonrpc`);
+        logger12.info(`  HTTP+JSON:   ${baseUrl}/a2a/rest`);
       }
       resolve2();
     });
   });
   await agent.start();
   const shutdown = async () => {
-    logger10.info("Received shutdown signal");
+    logger12.info("Received shutdown signal");
     await agent.stop();
     process.exit(0);
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
 }
+
+// src/wallet/index.ts
+init_AgentWallet();
+
+// src/index.ts
+init_logger();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   A2AClient,
@@ -3547,6 +3832,7 @@ async function startServer(agent, options = {}) {
   ActionRegistry,
   Agent,
   AgentCardBuilder,
+  AgentWallet,
   AnthropicProvider,
   ConfigLoader,
   LLMProvider,