@moltium/core 0.1.18 → 0.1.19

package/dist/index.mjs

@@ -216,12 +216,221 @@ var scheduleTaskAction = {
   }
 };
 
+// src/actions/built-in/moltbook.ts
+function getMoltbook(context) {
+  return context.agent?.socialAdapters?.["moltbook"] || null;
+}
+var checkFeedAction = {
+  name: "check_feed",
+  description: "Browse the moltbook feed (personalized or global) to find posts to engage with",
+  async execute(context) {
+    const mb = getMoltbook(context);
+    if (!mb) return { success: false, error: "Moltbook not connected" };
+    const { sort, limit, global: useGlobal } = context.parameters;
+    try {
+      const posts = useGlobal ? await mb.getGlobalFeed({ sort: sort || "hot", limit: limit || 15 }) : await mb.getFeed({ sort: sort || "new", limit: limit || 15 });
+      return { success: true, data: { posts, count: posts.length } };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};
+var checkDMsAction = {
+  name: "check_dms",
+  description: "Check for new DM requests and unread messages from other agents",
+  async execute(context) {
+    const mb = getMoltbook(context);
+    if (!mb) return { success: false, error: "Moltbook not connected" };
+    try {
+      const result = await mb.checkDMs();
+      return { success: true, data: result };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};
+var searchMoltbookAction = {
+  name: "search_moltbook",
+  description: 'Search moltbook for posts and comments by meaning (semantic search). Params: { "query": "..." }',
+  async execute(context) {
+    const mb = getMoltbook(context);
+    if (!mb) return { success: false, error: "Moltbook not connected" };
+    const { query, limit } = context.parameters;
+    if (!query) return { success: false, error: "Missing required parameter: query" };
+    try {
+      const results = await mb.search(query, { limit: limit || 10 });
+      return { success: true, data: { results, count: results.length } };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};
+var commentOnPostAction = {
+  name: "comment_on_post",
+  description: 'Reply to a post with a comment. Params: { "post_id": "...", "content": "..." }',
+  async execute(context) {
+    const mb = getMoltbook(context);
+    if (!mb) return { success: false, error: "Moltbook not connected" };
+    const { post_id, content } = context.parameters;
+    if (!post_id || !content) return { success: false, error: "Missing required parameters: post_id, content" };
+    try {
+      const result = await mb.reply(post_id, content);
+      return { success: true, data: result };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};
+var upvotePostAction = {
+  name: "upvote_post",
+  description: 'Upvote a post you find valuable. Params: { "post_id": "..." }',
+  async execute(context) {
+    const mb = getMoltbook(context);
+    if (!mb) return { success: false, error: "Moltbook not connected" };
+    const { post_id } = context.parameters;
+    if (!post_id) return { success: false, error: "Missing required parameter: post_id" };
+    try {
+      await mb.like(post_id);
+      return { success: true, data: { post_id, action: "upvoted" } };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};
+var downvotePostAction = {
+  name: "downvote_post",
+  description: 'Downvote a post you disagree with. Params: { "post_id": "..." }',
+  async execute(context) {
+    const mb = getMoltbook(context);
+    if (!mb) return { success: false, error: "Moltbook not connected" };
+    const { post_id } = context.parameters;
+    if (!post_id) return { success: false, error: "Missing required parameter: post_id" };
+    try {
+      await mb.downvote(post_id);
+      return { success: true, data: { post_id, action: "downvoted" } };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};
+var browseSubmoltsAction = {
+  name: "browse_submolts",
+  description: "Discover moltbook communities (submolts) to subscribe to",
+  async execute(context) {
+    const mb = getMoltbook(context);
+    if (!mb) return { success: false, error: "Moltbook not connected" };
+    try {
+      const submolts = await mb.listSubmolts();
+      return { success: true, data: { submolts, count: submolts.length } };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};
+var followAgentAction = {
+  name: "follow_agent",
+  description: 'Follow another agent whose posts you enjoy. Params: { "agent_name": "..." }',
+  async execute(context) {
+    const mb = getMoltbook(context);
+    if (!mb) return { success: false, error: "Moltbook not connected" };
+    const { agent_name } = context.parameters;
+    if (!agent_name) return { success: false, error: "Missing required parameter: agent_name" };
+    try {
+      await mb.follow(agent_name);
+      return { success: true, data: { agent_name, action: "followed" } };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};
+var sendDMRequestAction = {
+  name: "send_dm_request",
+  description: 'Request to start a private conversation with another agent. Params: { "to": "...", "message": "..." }',
+  async execute(context) {
+    const mb = getMoltbook(context);
+    if (!mb) return { success: false, error: "Moltbook not connected" };
+    const { to, to_owner, message } = context.parameters;
+    if (!to && !to_owner || !message) return { success: false, error: "Missing required parameters: (to or to_owner), message" };
+    try {
+      const target = to || to_owner || "";
+      const byOwner = !to && !!to_owner;
+      const result = await mb.sendDMRequest(target, message, byOwner);
+      return { success: true, data: result };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};
+var sendDMAction = {
+  name: "send_dm",
+  description: 'Send a message in an existing DM conversation. Params: { "conversation_id": "...", "message": "..." }',
+  async execute(context) {
+    const mb = getMoltbook(context);
+    if (!mb) return { success: false, error: "Moltbook not connected" };
+    const { conversation_id, message, needs_human_input } = context.parameters;
+    if (!conversation_id || !message) return { success: false, error: "Missing required parameters: conversation_id, message" };
+    try {
+      const result = await mb.sendDM(conversation_id, message, needs_human_input);
+      return { success: true, data: result };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};
+var approveDMRequestAction = {
+  name: "approve_dm_request",
+  description: 'Approve a pending DM request from another agent. Params: { "conversation_id": "..." }',
+  async execute(context) {
+    const mb = getMoltbook(context);
+    if (!mb) return { success: false, error: "Moltbook not connected" };
+    const { conversation_id } = context.parameters;
+    if (!conversation_id) return { success: false, error: "Missing required parameter: conversation_id" };
+    try {
+      await mb.approveDMRequest(conversation_id);
+      return { success: true, data: { conversation_id, action: "approved" } };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};
+var readConversationAction = {
+  name: "read_conversation",
+  description: 'Read messages in a DM conversation (marks as read). Params: { "conversation_id": "..." }',
+  async execute(context) {
+    const mb = getMoltbook(context);
+    if (!mb) return { success: false, error: "Moltbook not connected" };
+    const { conversation_id } = context.parameters;
+    if (!conversation_id) return { success: false, error: "Missing required parameter: conversation_id" };
+    try {
+      const detail = await mb.readConversation(conversation_id);
+      return { success: true, data: detail };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};
+var moltbookActions = [
+  checkFeedAction,
+  checkDMsAction,
+  searchMoltbookAction,
+  commentOnPostAction,
+  upvotePostAction,
+  downvotePostAction,
+  browseSubmoltsAction,
+  followAgentAction,
+  sendDMRequestAction,
+  sendDMAction,
+  approveDMRequestAction,
+  readConversationAction
+];
+
 // src/actions/built-in/index.ts
 var builtInActions = [
   postSocialUpdateAction,
   respondToMentionAction,
   dmUserAction,
-  scheduleTaskAction
+  scheduleTaskAction,
+  ...moltbookActions
 ];
 
 // src/llm/prompt.ts
@@ -248,18 +457,33 @@ ${config.llm.systemPrompt}`);
 }
 function buildDecisionPrompt(context, availableActions) {
   const actionList = availableActions.map((a) => `- ${a.name}: ${a.description}`).join("\n");
-  return `Given the current context, decide what action to take next.
+  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) {
+    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.`;
+  }
+  return `You are an autonomous AI agent on moltbook (a social network for AI agents).
+Decide what action to take next based on the current context and your personality.
 
 Available actions:
 ${actionList}
 
 Current context:
 ${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.
 
 Respond with a JSON object:
 {
   "action": "<action_name>",
-  "reasoning": "<brief explanation>",
+  "reasoning": "<brief explanation of why you chose this>",
   "parameters": { <any parameters for the action> }
 }`;
 }
@@ -1135,6 +1359,8 @@ var Agent = class {
   tickTimer;
   systemPrompt;
   socialAdapters = {};
+  recentActions = [];
+  tickCount = 0;
   constructor(config, hooks) {
     this.config = config;
     this.hooks = hooks || {};
@@ -1269,13 +1495,29 @@ var Agent = class {
   }
   async tick() {
     if (this.state !== "running") return;
+    this.tickCount++;
     try {
       if (this.hooks.onTick) {
         await this.hooks.onTick(this);
       }
-      if (this.isSleeping()) return;
+      if (this.isSleeping()) {
+        logger4.info(`Tick #${this.tickCount}: Sleeping \u2014 skipped`);
+        return;
+      }
+      logger4.info(`Tick #${this.tickCount}: Thinking...`);
       const decision = await this.think();
+      logger4.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)}`);
+      }
       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)}` : ""}`);
+      this.recentActions.push({
+        action: decision.action,
+        reasoning: decision.reasoning,
+        time: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (this.recentActions.length > 10) this.recentActions.shift();
       await this.learn({
         type: "action",
         action: decision.action,
@@ -1287,7 +1529,7 @@ var Agent = class {
         await this.fireWebhook("onAction", decision, result);
       }
     } catch (error) {
-      logger4.error(`Tick error: ${error instanceof Error ? error.message : error}`);
+      logger4.error(`Tick #${this.tickCount} error: ${error instanceof Error ? error.message : error}`);
       if (this.hooks.onError && error instanceof Error) {
         await this.hooks.onError(error, this);
       }
@@ -1320,6 +1562,15 @@ var Agent = class {
         this.actionRegistry.register(action);
       }
     }
+    const mb = this.config.social.moltbook;
+    if (mb && mb.enabled !== false) {
+      for (const action of moltbookActions) {
+        if (!this.actionRegistry.has(action.name)) {
+          this.actionRegistry.register(action);
+        }
+      }
+      logger4.info(`Registered ${moltbookActions.length} Moltbook actions`);
+    }
     if (this.config.customActions) {
       for (const action of this.config.customActions) {
         this.actionRegistry.register(action);
@@ -1628,7 +1879,11 @@ Decide what action to take. Respond with JSON:
       agentType: this.config.type,
       currentTime: (/* @__PURE__ */ new Date()).toISOString(),
       state: this.state,
-      personality: this.config.personality.traits
+      tickNumber: this.tickCount,
+      personality: this.config.personality.traits,
+      connectedPlatforms: Object.keys(this.socialAdapters),
+      recentActions: this.recentActions.slice(-5),
+      scheduledTasks: (this.config.scheduling || []).map((t) => t.name)
     };
   }
   async fireWebhook(event, ...args) {
@@ -2356,6 +2611,7 @@ export {
   createLogger,
   createMarkdownAction,
   createRoutes,
+  moltbookActions,
   startServer,
   validateConfig
 };