@moltium/core 0.1.19 → 0.1.21

package/dist/index.js

@@ -30,9 +30,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  A2AClient: () => A2AClient,
+  A2AIntegration: () => A2AIntegration,
   ActionHandler: () => ActionHandler,
   ActionRegistry: () => ActionRegistry,
   Agent: () => Agent,
+  AgentCardBuilder: () => AgentCardBuilder,
   AnthropicProvider: () => AnthropicProvider,
   ConfigLoader: () => ConfigLoader,
   LLMProvider: () => LLMProvider,
@@ -40,6 +43,7 @@ __export(index_exports, {
   MarkdownParser: () => MarkdownParser,
   Memory: () => Memory,
   MoltbookAdapter: () => MoltbookAdapter,
+  MoltiumExecutor: () => MoltiumExecutor,
   OpenAIProvider: () => OpenAIProvider,
   Scheduler: () => Scheduler,
   ShortTermMemory: () => ShortTermMemory,
@@ -49,13 +53,20 @@ __export(index_exports, {
   buildSkillPrompt: () => buildSkillPrompt,
   buildSystemPrompt: () => buildSystemPrompt,
   builtInActions: () => builtInActions,
+  createA2AClient: () => createA2AClient,
+  createA2AIntegration: () => createA2AIntegration,
   createApp: () => createApp,
+  createJoinWorldAction: () => createJoinWorldAction,
+  createLeaveWorldAction: () => createLeaveWorldAction,
   createLogger: () => createLogger,
   createMarkdownAction: () => createMarkdownAction,
+  createQueryWorldAction: () => createQueryWorldAction,
   createRoutes: () => createRoutes,
+  createSendWorldMessageAction: () => createSendWorldMessageAction,
   moltbookActions: () => moltbookActions,
   startServer: () => startServer,
-  validateConfig: () => validateConfig
+  validateConfig: () => validateConfig,
+  worldActions: () => worldActions
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -485,6 +496,140 @@ var moltbookActions = [
   readConversationAction
 ];
 
+// src/actions/built-in/world.ts
+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.`,
+    async execute(context) {
+      const { parameters, agent } = context;
+      const worldUrl = parameters.worldUrl || config?.defaultWorldUrl;
+      if (!worldUrl) {
+        return { success: false, error: 'Parameter "worldUrl" is required' };
+      }
+      const agentPort = process.env.PORT || "3000";
+      const agentHost = process.env.HOST || "localhost";
+      const agentUrl = `http://${agentHost}:${agentPort}`;
+      try {
+        const { default: axios2 } = await import("axios");
+        const response = await axios2.post(`${worldUrl}/world/join`, {
+          agentUrl,
+          walletAddress: parameters.walletAddress || agent?.config?.world?.walletAddress
+        }, { timeout: 1e4 });
+        return {
+          success: true,
+          data: response.data
+        };
+      } catch (error) {
+        const msg = error?.response?.data?.error || error?.message || String(error);
+        return { success: false, error: `Failed to join world: ${msg}` };
+      }
+    }
+  };
+}
+function createLeaveWorldAction(config) {
+  return {
+    name: "leave_world",
+    description: `Leave a world. Parameters: worldUrl (string${config?.defaultWorldUrl ? ", optional" : ", required"}) - the world server URL.`,
+    async execute(context) {
+      const { parameters } = context;
+      const worldUrl = parameters.worldUrl || config?.defaultWorldUrl;
+      if (!worldUrl) {
+        return { success: false, error: 'Parameter "worldUrl" is required' };
+      }
+      const agentPort = process.env.PORT || "3000";
+      const agentHost = process.env.HOST || "localhost";
+      const agentUrl = `http://${agentHost}:${agentPort}`;
+      try {
+        const { default: axios2 } = await import("axios");
+        const response = await axios2.delete(
+          `${worldUrl}/world/agents/${encodeURIComponent(agentUrl)}`,
+          { timeout: 1e4 }
+        );
+        return {
+          success: true,
+          data: response.data
+        };
+      } catch (error) {
+        const msg = error?.response?.data?.error || error?.message || String(error);
+        return { success: false, error: `Failed to leave world: ${msg}` };
+      }
+    }
+  };
+}
+function createQueryWorldAction(config) {
+  return {
+    name: "query_world",
+    description: `Query a world's state, agents, and available actions. Parameters: worldUrl (string${config?.defaultWorldUrl ? ", optional" : ", required"}) - the world server URL, endpoint (string, optional) - specific endpoint: "state", "agents", "actions", or "info" (default: "info").`,
+    async execute(context) {
+      const { parameters } = context;
+      const worldUrl = parameters.worldUrl || config?.defaultWorldUrl;
+      if (!worldUrl) {
+        return { success: false, error: 'Parameter "worldUrl" is required' };
+      }
+      const endpoint = parameters.endpoint || "info";
+      const pathMap = {
+        info: "/",
+        state: "/world/state",
+        agents: "/world/agents",
+        actions: "/world/actions"
+      };
+      const path = pathMap[endpoint] || "/";
+      try {
+        const { default: axios2 } = await import("axios");
+        const response = await axios2.get(`${worldUrl}${path}`, { timeout: 1e4 });
+        return {
+          success: true,
+          data: response.data
+        };
+      } catch (error) {
+        const msg = error?.response?.data?.error || error?.message || String(error);
+        return { success: false, error: `Failed to query world: ${msg}` };
+      }
+    }
+  };
+}
+function createSendWorldMessageAction(config) {
+  return {
+    name: "send_world_message",
+    description: `Send a message to another agent through the world hub. Parameters: worldUrl (string${config?.defaultWorldUrl ? ", optional" : ", required"}) - the world server URL, toAgentUrl (string, optional) - target agent URL (omit to broadcast to all), message (string, required) - the message to send.`,
+    async execute(context) {
+      const { parameters } = context;
+      const worldUrl = parameters.worldUrl || config?.defaultWorldUrl;
+      if (!worldUrl) {
+        return { success: false, error: 'Parameter "worldUrl" is required' };
+      }
+      if (!parameters.message) {
+        return { success: false, error: 'Parameter "message" is required' };
+      }
+      const agentPort = process.env.PORT || "3000";
+      const agentHost = process.env.HOST || "localhost";
+      const agentUrl = `http://${agentHost}:${agentPort}`;
+      try {
+        const { default: axios2 } = await import("axios");
+        const response = await axios2.post(`${worldUrl}/world/message`, {
+          fromAgentUrl: agentUrl,
+          toAgentUrl: parameters.toAgentUrl,
+          message: parameters.message
+        }, { timeout: 15e3 });
+        return {
+          success: true,
+          data: response.data
+        };
+      } catch (error) {
+        const msg = error?.response?.data?.error || error?.message || String(error);
+        return { success: false, error: `Failed to send world message: ${msg}` };
+      }
+    }
+  };
+}
+var worldActions = {
+  createJoinWorldAction,
+  createLeaveWorldAction,
+  createQueryWorldAction,
+  createSendWorldMessageAction
+};
+
 // src/actions/built-in/index.ts
 var builtInActions = [
   postSocialUpdateAction,
@@ -1379,6 +1524,178 @@ var TwitterAdapter = class extends SocialAdapter {
   }
 };
 
+// src/a2a/client.ts
+var import_client = require("@a2a-js/sdk/client");
+var import_uuid = require("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 import_client.A2AClient(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: (0, import_uuid.v4)(),
+          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;
+  }
+};
+function createA2AClient(agentUrlOrConfig) {
+  const config = typeof agentUrlOrConfig === "string" ? { agentUrl: agentUrlOrConfig } : agentUrlOrConfig;
+  return new A2AClient(config);
+}
+
+// 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) {
@@ -1499,6 +1816,9 @@ var Agent = class {
     if (this.hooks.onStart) {
       await this.hooks.onStart(this);
     }
+    if (this.config.world?.url && this.config.world.autoJoin !== false) {
+      await this.autoJoinWorld();
+    }
     this.scheduler.start();
     if (this.config.behaviors.autonomous) {
       this.startAutonomousLoop();
@@ -1632,6 +1952,53 @@ var Agent = class {
       }
       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}`);
+      }
+    }
+    const world = this.config.world;
+    if (world?.url) {
+      const worldUrl = world.url;
+      const worldActionsList = [
+        createJoinWorldAction({ defaultWorldUrl: worldUrl }),
+        createLeaveWorldAction({ defaultWorldUrl: worldUrl }),
+        createQueryWorldAction({ defaultWorldUrl: worldUrl }),
+        createSendWorldMessageAction({ defaultWorldUrl: worldUrl })
+      ];
+      for (const action of worldActionsList) {
+        if (!this.actionRegistry.has(action.name)) {
+          this.actionRegistry.register(action);
+        }
+      }
+      logger4.info(`Registered 4 world actions (world: ${worldUrl})`);
+    }
     if (this.config.customActions) {
       for (const action of this.config.customActions) {
         this.actionRegistry.register(action);
@@ -1918,6 +2285,23 @@ Decide what action to take. Respond with JSON:
       logger4.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}`);
+    try {
+      const result = await this.act("join_world", {
+        worldUrl,
+        walletAddress: this.config.world.walletAddress
+      });
+      if (result.success) {
+        logger4.info(`Successfully joined world: ${worldUrl}`);
+      } else {
+        logger4.warn(`Failed to join world: ${result.error}`);
+      }
+    } catch (error) {
+      logger4.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);
@@ -1980,6 +2364,7 @@ var MarkdownParser = class {
     const memory = this.findSection(sections, "Memory");
     const skills = this.findSection(sections, "Skills");
     const scheduling = this.findSection(sections, "Scheduling");
+    const world = this.findSection(sections, "World");
     const identityData = this.parseIdentity(identity);
     const bioText = bio ? bio.content.trim() : identityData?.personality?.bio || "";
     const config = {
@@ -1991,6 +2376,7 @@ var MarkdownParser = class {
       ...social ? { social: this.parseSocial(social) } : {},
       ...behaviors ? { behaviors: this.parseBehaviors(behaviors) } : {},
       ...memory ? { memory: this.parseMemory(memory) } : {},
+      ...world ? { world: this.parseWorld(world) } : {},
       actions: [],
       ...frontmatter
     };
@@ -2091,6 +2477,16 @@ var MarkdownParser = class {
       retention: fields["retention"]
     };
   }
+  parseWorld(section) {
+    const fields = this.parseKeyValueLines(section.content);
+    const url = fields["url"];
+    if (!url) return void 0;
+    return {
+      url,
+      autoJoin: fields["auto_join"] !== "false",
+      ...fields["wallet_address"] ? { walletAddress: fields["wallet_address"] } : {}
+    };
+  }
   parseSleepSchedule(value) {
     const match = value.match(/(\d{1,2}):?\d{0,2}\s*-\s*(\d{1,2}):?\d{0,2}\s*(.*)?/);
     if (!match) return { start: 22, end: 6 };
@@ -2621,27 +3017,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
+var import_uuid2 = require("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-${(0, import_uuid2.v4)()}`,
+          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-${(0, import_uuid2.v4)()}`,
+          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-${(0, import_uuid2.v4)()}`,
+          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-${(0, import_uuid2.v4)()}`,
+        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
+var import_server = require("@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 import_server.DefaultRequestHandler(
+      this.agentCard,
+      new import_server.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 import_server.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 import_server.DefaultRequestHandler(
+      this.agentCard,
+      new import_server.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 = (0, import_express2.default)();
   app.use(import_express2.default.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);
   };
@@ -2650,9 +3535,12 @@ async function startServer(agent, options = {}) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  A2AClient,
+  A2AIntegration,
   ActionHandler,
   ActionRegistry,
   Agent,
+  AgentCardBuilder,
   AnthropicProvider,
   ConfigLoader,
   LLMProvider,
@@ -2660,6 +3548,7 @@ async function startServer(agent, options = {}) {
   MarkdownParser,
   Memory,
   MoltbookAdapter,
+  MoltiumExecutor,
   OpenAIProvider,
   Scheduler,
   ShortTermMemory,
@@ -2669,12 +3558,19 @@ async function startServer(agent, options = {}) {
   buildSkillPrompt,
   buildSystemPrompt,
   builtInActions,
+  createA2AClient,
+  createA2AIntegration,
   createApp,
+  createJoinWorldAction,
+  createLeaveWorldAction,
   createLogger,
   createMarkdownAction,
+  createQueryWorldAction,
   createRoutes,
+  createSendWorldMessageAction,
   moltbookActions,
   startServer,
-  validateConfig
+  validateConfig,
+  worldActions
 });
 //# sourceMappingURL=index.js.map