@moltium/core 0.1.18 → 0.1.20

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> }
 }`;
 }
@@ -1094,6 +1318,174 @@ var TwitterAdapter = class extends SocialAdapter {
   }
 };
 
+// src/a2a/client.ts
+import { A2AClient as SDKClient } from "@a2a-js/sdk/client";
+import { v4 as uuidv4 } from "uuid";
+var A2AClient = class {
+  sdkClient;
+  config;
+  constructor(config) {
+    this.config = {
+      agentUrl: config.agentUrl,
+      agentCardPath: config.agentCardPath || ".well-known/agent-card.json",
+      timeout: config.timeout || 3e4
+    };
+    const agentUrl = this.config.agentUrl;
+    const agentCardPath = this.config.agentCardPath;
+    this.sdkClient = new SDKClient(agentUrl, agentCardPath);
+  }
+  /**
+   * Send a text message to the agent and get a response
+   * 
+   * @param options Message options including text content
+   * @returns Promise resolving to the agent's response
+   * 
+   * @example
+   * ```typescript
+   * const response = await client.sendMessage({
+   *   text: 'What are your thoughts on AI?',
+   *   contextId: 'conversation-123'
+   * });
+   * 
+   * if (response.success) {
+   *   console.log('Agent replied:', response.reply);
+   * }
+   * ```
+   */
+  async sendMessage(options) {
+    try {
+      const response = await this.sdkClient.sendMessage({
+        message: {
+          kind: "message",
+          messageId: uuidv4(),
+          role: "user",
+          contextId: options.contextId,
+          metadata: options.metadata,
+          parts: [
+            {
+              kind: "text",
+              text: options.text
+            }
+          ]
+        }
+      });
+      const reply = this.extractReply(response);
+      return {
+        success: true,
+        reply,
+        agentUrl: this.config.agentUrl,
+        raw: response
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message || "Unknown error occurred",
+        agentUrl: this.config.agentUrl
+      };
+    }
+  }
+  /**
+   * Extract text reply from A2A protocol response
+   * Handles both Message and Task response types
+   */
+  extractReply(response) {
+    if (!("result" in response) || !response.result) {
+      return JSON.stringify(response);
+    }
+    const result = response.result;
+    if ("kind" in result && result.kind === "message" && "parts" in result) {
+      const textParts = result.parts.filter((part) => part.kind === "text").map((part) => part.text);
+      return textParts.join("\n");
+    }
+    return typeof result === "string" ? result : JSON.stringify(result);
+  }
+  /**
+   * Get the agent card information
+   * 
+   * @returns Promise resolving to the agent card
+   */
+  async getAgentCard() {
+    return this.sdkClient.getAgentCard();
+  }
+  /**
+   * Get the base URL of the agent
+   */
+  getAgentUrl() {
+    return this.config.agentUrl;
+  }
+};
+
+// src/a2a/actions.ts
+function createA2ACommunicationAction(config = {}) {
+  const {
+    defaultAgentUrl,
+    actionName = "talk_to_agent",
+    description,
+    verbose = false
+  } = config;
+  const defaultDescription = description || `Send a message to another A2A-compliant agent and receive their response. Parameters: message (required string) - the message to send, agentUrl (optional string) - target agent URL${defaultAgentUrl ? ` (defaults to ${defaultAgentUrl})` : ""}`;
+  return {
+    name: actionName,
+    description: defaultDescription,
+    async execute(context) {
+      const { parameters } = context;
+      const message = parameters.message;
+      const agentUrl = parameters.agentUrl || defaultAgentUrl;
+      if (!message) {
+        return {
+          success: false,
+          error: 'Parameter "message" is required'
+        };
+      }
+      if (!agentUrl) {
+        return {
+          success: false,
+          error: 'Parameter "agentUrl" is required or defaultAgentUrl must be configured'
+        };
+      }
+      if (verbose) {
+        console.log(`[A2A] Sending message to ${agentUrl}:`, message);
+      }
+      try {
+        const client = new A2AClient({ agentUrl });
+        const response = await client.sendMessage({ text: message });
+        if (verbose) {
+          console.log(`[A2A] Response from ${agentUrl}:`, response.reply);
+        }
+        if (!response.success) {
+          return {
+            success: false,
+            error: response.error || "Failed to communicate with agent"
+          };
+        }
+        return {
+          success: true,
+          data: {
+            reply: response.reply,
+            agentUrl: response.agentUrl
+          }
+        };
+      } catch (error) {
+        if (verbose) {
+          console.error(`[A2A] Error:`, error);
+        }
+        return {
+          success: false,
+          error: error.message || "Unknown error occurred"
+        };
+      }
+    }
+  };
+}
+function createMultipleA2AActions(configs) {
+  return Object.entries(configs).map(
+    ([name, config]) => createA2ACommunicationAction({
+      ...config,
+      actionName: name
+    })
+  );
+}
+
 // src/agent/Agent.ts
 var logger4 = createLogger("Agent");
 function parsePostFrequency(freq) {
@@ -1135,6 +1527,8 @@ var Agent = class {
   tickTimer;
   systemPrompt;
   socialAdapters = {};
+  recentActions = [];
+  tickCount = 0;
   constructor(config, hooks) {
     this.config = config;
     this.hooks = hooks || {};
@@ -1269,13 +1663,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 +1697,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 +1730,46 @@ 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`);
+    }
+    const a2a = this.config.a2a;
+    if (a2a && a2a.enabled !== false) {
+      if (a2a.peers && Object.keys(a2a.peers).length > 0) {
+        const peerActions = createMultipleA2AActions(
+          Object.entries(a2a.peers).reduce((acc, [actionName, url]) => {
+            acc[actionName] = {
+              defaultAgentUrl: url,
+              verbose: a2a.verbose,
+              description: `Communicate with peer agent at ${url}`
+            };
+            return acc;
+          }, {})
+        );
+        for (const action of peerActions) {
+          if (!this.actionRegistry.has(action.name)) {
+            this.actionRegistry.register(action);
+          }
+        }
+        logger4.info(`Registered ${peerActions.length} A2A peer actions`);
+      } else {
+        const genericAction = createA2ACommunicationAction({
+          defaultAgentUrl: a2a.defaultPeerUrl,
+          actionName: a2a.genericActionName || "talk_to_agent",
+          verbose: a2a.verbose
+        });
+        if (!this.actionRegistry.has(genericAction.name)) {
+          this.actionRegistry.register(genericAction);
+        }
+        logger4.info(`Registered generic A2A action: ${genericAction.name}`);
+      }
+    }
     if (this.config.customActions) {
       for (const action of this.config.customActions) {
         this.actionRegistry.register(action);
@@ -1628,7 +2078,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) {
@@ -2305,27 +2759,516 @@ function authMiddleware(req, res, next) {
   next();
 }
 
+// src/a2a/AgentCardBuilder.ts
+var logger7 = createLogger("AgentCardBuilder");
+var AgentCardBuilder = class {
+  /**
+   * Creates an A2A AgentCard from Moltium configuration.
+   * @param config The Moltium agent configuration
+   * @param a2aConfig A2A-specific configuration (URLs, capabilities)
+   * @returns A2A-compliant AgentCard
+   */
+  static build(config, a2aConfig) {
+    const baseUrl = a2aConfig.baseUrl;
+    const skills = this.buildSkills(config);
+    const capabilities = {
+      streaming: a2aConfig.streaming ?? true,
+      pushNotifications: a2aConfig.pushNotifications ?? false,
+      stateTransitionHistory: a2aConfig.stateTransitionHistory ?? true
+    };
+    const defaultInputModes = ["text"];
+    const defaultOutputModes = ["text"];
+    const agentCard = {
+      name: config.name,
+      description: config.personality.bio || `${config.name} - An autonomous AI agent`,
+      protocolVersion: "0.3.0",
+      version: "0.1.0",
+      url: `${baseUrl}/a2a/jsonrpc`,
+      skills,
+      capabilities,
+      defaultInputModes,
+      defaultOutputModes,
+      additionalInterfaces: [
+        { url: `${baseUrl}/a2a/jsonrpc`, transport: "JSONRPC" },
+        { url: `${baseUrl}/a2a/rest`, transport: "HTTP+JSON" }
+      ]
+    };
+    logger7.debug("Built A2A AgentCard", {
+      name: agentCard.name,
+      skillCount: skills.length,
+      baseUrl
+    });
+    return agentCard;
+  }
+  /**
+   * Converts Moltium actions to A2A skills.
+   */
+  static buildSkills(config) {
+    const skills = [];
+    skills.push({
+      id: "chat",
+      name: "Chat",
+      description: `Interact with ${config.name}. ${config.personality.bio || ""}`,
+      tags: ["chat", "conversation"]
+    });
+    const hasPosting = config.actions.some(
+      (a) => a.includes("post") || a.includes("update")
+    );
+    if (hasPosting) {
+      skills.push({
+        id: "social_posting",
+        name: "Social Posting",
+        description: "Post updates and content to social platforms",
+        tags: ["social", "posting"]
+      });
+    }
+    const hasEngagement = config.actions.some(
+      (a) => a.includes("comment") || a.includes("reply") || a.includes("respond")
+    );
+    if (hasEngagement) {
+      skills.push({
+        id: "social_engagement",
+        name: "Social Engagement",
+        description: "Engage with others through comments and replies",
+        tags: ["social", "engagement"]
+      });
+    }
+    const hasSearch = config.actions.some(
+      (a) => a.includes("search") || a.includes("check_feed") || a.includes("browse")
+    );
+    if (hasSearch) {
+      skills.push({
+        id: "content_discovery",
+        name: "Content Discovery",
+        description: "Search and discover relevant content",
+        tags: ["search", "discovery"]
+      });
+    }
+    const hasAnalysis = config.actions.some(
+      (a) => a.includes("analyze") || a.includes("think") || a.includes("research")
+    );
+    if (hasAnalysis) {
+      skills.push({
+        id: "analysis",
+        name: "Analysis & Research",
+        description: "Analyze problems and conduct research",
+        tags: ["analysis", "research", "thinking"]
+      });
+    }
+    return skills;
+  }
+  /**
+   * Updates an agent card with runtime information.
+   */
+  static updateWithRuntime(agentCard, actualPort, actualHost = "localhost") {
+    const protocol = actualHost === "localhost" || actualHost === "127.0.0.1" ? "http" : "https";
+    const baseUrl = `${protocol}://${actualHost}:${actualPort}`;
+    return {
+      ...agentCard,
+      url: `${baseUrl}/a2a/jsonrpc`,
+      additionalInterfaces: [
+        { url: `${baseUrl}/a2a/jsonrpc`, transport: "JSONRPC" },
+        { url: `${baseUrl}/a2a/rest`, transport: "HTTP+JSON" }
+      ]
+    };
+  }
+};
+
+// src/a2a/MoltiumExecutor.ts
+import { v4 as uuidv42 } from "uuid";
+var logger8 = createLogger("MoltiumExecutor");
+var MoltiumExecutor = class {
+  agent;
+  cancelledTasks = /* @__PURE__ */ new Set();
+  constructor(agent) {
+    this.agent = agent;
+  }
+  /**
+   * Executes an A2A request using the Moltium agent.
+   * Converts A2A messages to Moltium actions and publishes results back via the event bus.
+   */
+  async execute(requestContext, eventBus) {
+    const { taskId, contextId, userMessage, task } = requestContext;
+    try {
+      logger8.info(`[A2A] Executing request for task ${taskId}`);
+      if (!task) {
+        const initialTask = {
+          kind: "task",
+          id: taskId,
+          contextId,
+          status: {
+            state: "submitted",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          history: [userMessage]
+        };
+        eventBus.publish(initialTask);
+      }
+      if (this.cancelledTasks.has(taskId)) {
+        this.publishCancellation(taskId, contextId, eventBus);
+        return;
+      }
+      this.publishStatusUpdate(taskId, contextId, "working", eventBus, false);
+      const userContent = this.extractMessageContent(userMessage);
+      const isActionRequest = this.isActionRequest(userContent);
+      let result;
+      if (isActionRequest) {
+        result = await this.executeAction(userContent, taskId);
+      } else {
+        result = await this.executeChat(userContent, taskId);
+      }
+      if (this.cancelledTasks.has(taskId)) {
+        this.publishCancellation(taskId, contextId, eventBus);
+        return;
+      }
+      if (result.success) {
+        await this.publishResult(taskId, contextId, result, eventBus);
+      } else {
+        await this.publishError(taskId, contextId, result.error || "Unknown error", eventBus);
+      }
+      this.publishStatusUpdate(taskId, contextId, "completed", eventBus, true);
+      eventBus.finished();
+      logger8.info(`[A2A] Task ${taskId} completed successfully`);
+    } catch (error) {
+      logger8.error(`[A2A] Task ${taskId} failed`, {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      await this.publishError(taskId, contextId, errorMessage, eventBus);
+      this.publishStatusUpdate(taskId, contextId, "failed", eventBus, true);
+      eventBus.finished();
+    } finally {
+      this.cancelledTasks.delete(taskId);
+    }
+  }
+  /**
+   * Handles task cancellation requests.
+   */
+  async cancelTask(taskId, eventBus) {
+    logger8.info(`[A2A] Cancellation requested for task ${taskId}`);
+    this.cancelledTasks.add(taskId);
+  }
+  /**
+   * Extracts text content from an A2A message.
+   */
+  extractMessageContent(message) {
+    const textParts = message.parts.filter((part) => part.kind === "text");
+    return textParts.map((part) => part.text).join("\n");
+  }
+  /**
+   * Determines if the user message is requesting a specific action.
+   */
+  isActionRequest(content) {
+    const actionKeywords = [
+      "post",
+      "search",
+      "check feed",
+      "browse",
+      "comment",
+      "upvote",
+      "follow",
+      "send dm"
+    ];
+    const lowerContent = content.toLowerCase();
+    return actionKeywords.some((keyword) => lowerContent.includes(keyword));
+  }
+  /**
+   * Executes a chat interaction using the agent's LLM.
+   */
+  async executeChat(userContent, taskId) {
+    try {
+      const llm = this.agent.getLLM();
+      const systemPrompt = this.agent.getSystemPrompt();
+      const response = await llm.generateText(userContent, {
+        systemPrompt,
+        temperature: this.agent.config.llm.temperature
+      });
+      return {
+        success: true,
+        data: { response, type: "chat" }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Chat execution failed: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Executes an action based on the user's request.
+   */
+  async executeAction(userContent, taskId) {
+    try {
+      const decision = await this.agent.think();
+      const result = await this.agent.act(decision.action, decision.parameters);
+      return {
+        success: result.success,
+        data: {
+          action: decision.action,
+          reasoning: decision.reasoning,
+          result: result.data,
+          type: "action"
+        },
+        error: result.error
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Action execution failed: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Publishes a successful result as an A2A artifact.
+   */
+  async publishResult(taskId, contextId, result, eventBus) {
+    const data = result.data;
+    if (data?.type === "chat") {
+      const artifactUpdate = {
+        kind: "artifact-update",
+        taskId,
+        contextId,
+        artifact: {
+          artifactId: `response-${uuidv42()}`,
+          name: "response.txt",
+          parts: [{ kind: "text", text: data.response }]
+        }
+      };
+      eventBus.publish(artifactUpdate);
+    } else if (data?.type === "action") {
+      const resultText = JSON.stringify(
+        {
+          action: data.action,
+          reasoning: data.reasoning,
+          result: data.result
+        },
+        null,
+        2
+      );
+      const artifactUpdate = {
+        kind: "artifact-update",
+        taskId,
+        contextId,
+        artifact: {
+          artifactId: `action-result-${uuidv42()}`,
+          name: "action_result.json",
+          parts: [{ kind: "text", text: resultText }]
+        }
+      };
+      eventBus.publish(artifactUpdate);
+    } else {
+      const resultText = typeof result.data === "string" ? result.data : JSON.stringify(result.data, null, 2);
+      const artifactUpdate = {
+        kind: "artifact-update",
+        taskId,
+        contextId,
+        artifact: {
+          artifactId: `result-${uuidv42()}`,
+          name: "result.txt",
+          parts: [{ kind: "text", text: resultText }]
+        }
+      };
+      eventBus.publish(artifactUpdate);
+    }
+  }
+  /**
+   * Publishes an error as an A2A artifact.
+   */
+  async publishError(taskId, contextId, error, eventBus) {
+    const artifactUpdate = {
+      kind: "artifact-update",
+      taskId,
+      contextId,
+      artifact: {
+        artifactId: `error-${uuidv42()}`,
+        name: "error.txt",
+        parts: [{ kind: "text", text: `Error: ${error}` }]
+      }
+    };
+    eventBus.publish(artifactUpdate);
+  }
+  /**
+   * Publishes a status update event.
+   */
+  publishStatusUpdate(taskId, contextId, state, eventBus, final) {
+    const statusUpdate = {
+      kind: "status-update",
+      taskId,
+      contextId,
+      status: {
+        state,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      final
+    };
+    eventBus.publish(statusUpdate);
+  }
+  /**
+   * Publishes a cancellation status.
+   */
+  publishCancellation(taskId, contextId, eventBus) {
+    logger8.info(`[A2A] Publishing cancellation for task ${taskId}`);
+    this.publishStatusUpdate(taskId, contextId, "canceled", eventBus, true);
+    eventBus.finished();
+    this.cancelledTasks.delete(taskId);
+  }
+};
+
+// src/a2a/integration.ts
+import { DefaultRequestHandler, InMemoryTaskStore, JsonRpcTransportHandler } from "@a2a-js/sdk/server";
+var logger9 = createLogger("A2AIntegration");
+var A2AIntegration = class {
+  agent;
+  agentCard;
+  requestHandler;
+  moltiumExecutor;
+  constructor(agent, options) {
+    this.agent = agent;
+    this.agentCard = AgentCardBuilder.build(agent.config, options.a2aConfig);
+    this.moltiumExecutor = new MoltiumExecutor(agent);
+    this.requestHandler = new DefaultRequestHandler(
+      this.agentCard,
+      new InMemoryTaskStore(),
+      this.moltiumExecutor
+    );
+    logger9.info("A2A integration initialized", {
+      agentName: agent.name,
+      baseUrl: options.a2aConfig.baseUrl
+    });
+  }
+  /**
+   * Creates Express middleware handlers for A2A endpoints.
+   * Returns an object with individual handlers that can be mounted on specific routes.
+   */
+  getHandlers() {
+    return {
+      // Agent Card endpoint - serves the static agent card JSON
+      agentCard: ((req, res) => {
+        res.json(this.agentCard);
+      }),
+      // JSON-RPC endpoint - handles A2A protocol requests
+      jsonRpc: (async (req, res) => {
+        try {
+          const jsonRpcHandler = new JsonRpcTransportHandler(this.requestHandler);
+          const response = await jsonRpcHandler.handle(req.body);
+          res.json(response);
+        } catch (error) {
+          logger9.error("JSON-RPC error:", error);
+          res.status(500).json({
+            jsonrpc: "2.0",
+            error: {
+              code: -32603,
+              message: "Internal error",
+              data: error.message
+            },
+            id: req.body?.id || null
+          });
+        }
+      }),
+      // REST endpoint - simplified HTTP+JSON interface
+      rest: ((req, res) => {
+        res.status(501).json({
+          error: "REST transport not implemented in SDK v0.3.0",
+          message: "Please use the JSON-RPC endpoint at /a2a/jsonrpc"
+        });
+      })
+    };
+  }
+  /**
+   * Updates the agent card with actual runtime information (host/port).
+   */
+  updateAgentCard(actualPort, actualHost = "localhost") {
+    this.agentCard = AgentCardBuilder.updateWithRuntime(this.agentCard, actualPort, actualHost);
+    this.requestHandler = new DefaultRequestHandler(
+      this.agentCard,
+      new InMemoryTaskStore(),
+      this.moltiumExecutor
+    );
+    logger9.info("A2A agent card updated with runtime info", {
+      host: actualHost,
+      port: actualPort,
+      url: this.agentCard.url
+    });
+  }
+  /**
+   * Gets the current agent card.
+   */
+  getAgentCard() {
+    return this.agentCard;
+  }
+  /**
+   * Logs A2A endpoint information.
+   */
+  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-card.json`);
+    logger9.info(`  JSON-RPC:    ${baseUrl}/a2a/jsonrpc`);
+    logger9.info(`  HTTP+JSON:   ${baseUrl}/a2a/rest`);
+  }
+};
+function createA2AIntegration(agent, options = {}) {
+  const a2aConfig = {
+    enabled: true,
+    baseUrl: options.a2aConfig?.baseUrl || "http://localhost:3000",
+    pushNotifications: options.a2aConfig?.pushNotifications ?? false,
+    streaming: options.a2aConfig?.streaming ?? true,
+    stateTransitionHistory: options.a2aConfig?.stateTransitionHistory ?? true
+  };
+  return new A2AIntegration(agent, { a2aConfig, ...options });
+}
+
 // src/server/app.ts
-var logger7 = createLogger("Server");
-function createApp(agent) {
+var logger10 = createLogger("Server");
+var AGENT_CARD_PATH = ".well-known/agent-card.json";
+function createApp(agent, options = {}) {
   const app = express();
   app.use(express.json());
   app.use(requestLogger);
   app.use(authMiddleware);
   app.use(createRoutes(agent));
+  if (options.enableA2A !== false) {
+    const port = options.port || parseInt(process.env.PORT || "3000", 10);
+    const host = options.host || "0.0.0.0";
+    const protocol = host === "localhost" || host === "127.0.0.1" || host === "0.0.0.0" ? "http" : "https";
+    const baseUrl = options.a2aConfig?.baseUrl || `${protocol}://${host}:${port}`;
+    const a2aIntegration = createA2AIntegration(agent, {
+      a2aConfig: {
+        enabled: true,
+        baseUrl,
+        pushNotifications: options.a2aConfig?.pushNotifications ?? false,
+        streaming: options.a2aConfig?.streaming ?? true,
+        stateTransitionHistory: options.a2aConfig?.stateTransitionHistory ?? true
+      }
+    });
+    const handlers = a2aIntegration.getHandlers();
+    app.use(`/${AGENT_CARD_PATH}`, handlers.agentCard);
+    app.use("/a2a/jsonrpc", handlers.jsonRpc);
+    app.use("/a2a/rest", handlers.rest);
+    logger10.info("A2A protocol endpoints enabled");
+  }
   app.use(errorHandler);
   return app;
 }
 async function startServer(agent, options = {}) {
   const port = options.port || parseInt(process.env.PORT || "3000", 10);
   const host = options.host || "0.0.0.0";
-  const app = createApp(agent);
+  const app = createApp(agent, options);
   await agent.start();
   app.listen(port, host, () => {
-    logger7.info(`Agent "${agent.name}" running at http://${host}:${port}`);
+    logger10.info(`Agent "${agent.name}" running at http://${host}:${port}`);
+    if (options.enableA2A !== false) {
+      const protocol = host === "localhost" || host === "127.0.0.1" ? "http" : "https";
+      const baseUrl = `${protocol}://${host}:${port}`;
+      logger10.info("A2A Protocol Endpoints:");
+      logger10.info(`  Agent Card:  ${baseUrl}/.well-known/agent-card.json`);
+      logger10.info(`  JSON-RPC:    ${baseUrl}/a2a/jsonrpc`);
+      logger10.info(`  HTTP+JSON:   ${baseUrl}/a2a/rest`);
+    }
   });
   const shutdown = async () => {
-    logger7.info("Received shutdown signal");
+    logger10.info("Received shutdown signal");
     await agent.stop();
     process.exit(0);
   };
@@ -2333,9 +3276,11 @@ async function startServer(agent, options = {}) {
   process.on("SIGTERM", shutdown);
 }
 export {
+  A2AIntegration,
   ActionHandler,
   ActionRegistry,
   Agent,
+  AgentCardBuilder,
   AnthropicProvider,
   ConfigLoader,
   LLMProvider,
@@ -2343,6 +3288,7 @@ export {
   MarkdownParser,
   Memory,
   MoltbookAdapter,
+  MoltiumExecutor,
   OpenAIProvider,
   Scheduler,
   ShortTermMemory,
@@ -2352,10 +3298,12 @@ export {
   buildSkillPrompt,
   buildSystemPrompt,
   builtInActions,
+  createA2AIntegration,
   createApp,
   createLogger,
   createMarkdownAction,
   createRoutes,
+  moltbookActions,
   startServer,
   validateConfig
 };