@moltium/world-core 0.1.18 → 0.1.20

package/dist/index.js

@@ -113,7 +113,21 @@ var WorldConfigSchema = z.object({
   blockchain: BlockchainConfigSchema.optional(),
   token: TokenConfigSchema.optional(),
   rules: z.array(z.any()).optional(),
-  agentUrls: z.array(z.string().url()).optional()
+  agentUrls: z.array(z.string().url()).optional(),
+  actions: z.array(z.object({
+    name: z.string().min(1),
+    description: z.string(),
+    parameters: z.record(z.object({
+      type: z.enum(["string", "number", "boolean", "object"]),
+      required: z.boolean().optional(),
+      description: z.string().optional()
+    })).optional()
+  })).optional(),
+  orchestration: z.object({
+    broadcastOnTick: z.boolean().optional(),
+    tickTimeout: z.number().int().positive().optional(),
+    promptTemplate: z.string().optional()
+  }).optional()
 });
 function validateWorldConfig(config) {
   try {
@@ -413,7 +427,7 @@ async function createLevelDBAdapter(config) {
 }
 
 // src/engine/World.ts
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv43 } from "uuid";
 
 // src/discovery/AgentEvaluator.ts
 var logger2 = createLogger("AgentEvaluator");
@@ -768,8 +782,538 @@ var BlockchainClient = class {
   }
 };
 
+// src/a2a/WorldA2AClient.ts
+import { A2AClient } from "@moltium/core";
+var logger4 = createLogger("WorldA2AClient");
+var WorldA2AClient = class {
+  clients = /* @__PURE__ */ new Map();
+  /**
+   * Add an agent to the client pool
+   */
+  addAgent(agentUrl) {
+    if (this.clients.has(agentUrl)) {
+      logger4.debug(`Agent already in client pool: ${agentUrl}`);
+      return;
+    }
+    const client = new A2AClient({ agentUrl });
+    this.clients.set(agentUrl, client);
+    logger4.info(`Added agent to A2A client pool: ${agentUrl}`);
+  }
+  /**
+   * Remove an agent from the client pool
+   */
+  removeAgent(agentUrl) {
+    this.clients.delete(agentUrl);
+    logger4.info(`Removed agent from A2A client pool: ${agentUrl}`);
+  }
+  /**
+   * Send an A2A message to a specific agent
+   */
+  async sendToAgent(agentUrl, message, metadata) {
+    const client = this.clients.get(agentUrl);
+    if (!client) {
+      return {
+        success: false,
+        error: `Agent not in client pool: ${agentUrl}`,
+        agentUrl
+      };
+    }
+    try {
+      const response = await client.sendMessage({ text: message, metadata });
+      logger4.debug(`A2A message sent to ${agentUrl}`, { success: response.success });
+      return response;
+    } catch (error) {
+      logger4.error(`Failed to send A2A message to ${agentUrl}:`, error);
+      return {
+        success: false,
+        error: error?.message || String(error),
+        agentUrl
+      };
+    }
+  }
+  /**
+   * Broadcast an A2A message to all agents in the pool
+   */
+  async broadcastToAll(message, metadata) {
+    const results = /* @__PURE__ */ new Map();
+    const promises = Array.from(this.clients.entries()).map(
+      async ([agentUrl]) => {
+        const response = await this.sendToAgent(agentUrl, message, metadata);
+        results.set(agentUrl, response);
+      }
+    );
+    await Promise.allSettled(promises);
+    logger4.info(`Broadcast complete: ${results.size} agents`, {
+      succeeded: Array.from(results.values()).filter((r) => r.success).length,
+      failed: Array.from(results.values()).filter((r) => !r.success).length
+    });
+    return results;
+  }
+  /**
+   * Get the number of agents in the pool
+   */
+  get size() {
+    return this.clients.size;
+  }
+  /**
+   * Check if an agent is in the pool
+   */
+  has(agentUrl) {
+    return this.clients.has(agentUrl);
+  }
+  /**
+   * Get all agent URLs in the pool
+   */
+  getAgentUrls() {
+    return Array.from(this.clients.keys());
+  }
+};
+
+// src/engine/WorldActions.ts
+var logger5 = createLogger("WorldActions");
+var WorldActionsRegistry = class {
+  actions = /* @__PURE__ */ new Map();
+  /**
+   * Register a world action
+   */
+  register(action) {
+    if (this.actions.has(action.name)) {
+      logger5.warn(`Overwriting existing action: ${action.name}`);
+    }
+    this.actions.set(action.name, action);
+    logger5.debug(`Registered world action: ${action.name}`);
+  }
+  /**
+   * Register multiple actions at once
+   */
+  registerAll(actions) {
+    for (const action of actions) {
+      this.register(action);
+    }
+  }
+  /**
+   * Get all registered actions
+   */
+  getAll() {
+    return Array.from(this.actions.values());
+  }
+  /**
+   * Get a specific action by name
+   */
+  get(name) {
+    return this.actions.get(name);
+  }
+  /**
+   * Check if an action exists
+   */
+  has(name) {
+    return this.actions.has(name);
+  }
+  /**
+   * Validate an action name and its parameters
+   */
+  validate(actionName, params) {
+    const action = this.actions.get(actionName);
+    if (!action) {
+      return { valid: false, error: `Unknown action: ${actionName}` };
+    }
+    if (!action.parameters) {
+      return { valid: true };
+    }
+    for (const [paramName, paramDef] of Object.entries(action.parameters)) {
+      if (paramDef.required && !(paramName in params)) {
+        return {
+          valid: false,
+          error: `Missing required parameter: ${paramName} for action ${actionName}`
+        };
+      }
+      if (paramName in params && params[paramName] !== void 0) {
+        const actualType = typeof params[paramName];
+        if (paramDef.type === "object") {
+          if (actualType !== "object" || params[paramName] === null) {
+            return {
+              valid: false,
+              error: `Parameter ${paramName} must be an object`
+            };
+          }
+        } else if (actualType !== paramDef.type) {
+          return {
+            valid: false,
+            error: `Parameter ${paramName} must be of type ${paramDef.type}, got ${actualType}`
+          };
+        }
+      }
+    }
+    return { valid: true };
+  }
+  /**
+   * Get action names as a simple list (for tick context)
+   */
+  getActionNames() {
+    return Array.from(this.actions.keys());
+  }
+  /**
+   * Get actions as a serializable summary (for tick context)
+   */
+  toSummary() {
+    return this.getAll().map((a) => ({
+      name: a.name,
+      description: a.description,
+      ...a.parameters && { parameters: a.parameters }
+    }));
+  }
+};
+
+// src/engine/ActionProcessor.ts
+import { v4 as uuidv4 } from "uuid";
+var logger6 = createLogger("ActionProcessor");
+var ActionProcessor = class {
+  constructor(rules, actionsRegistry) {
+    this.rules = rules;
+    this.actionsRegistry = actionsRegistry;
+  }
+  /**
+   * Process an agent's tick response: validate action and check rules
+   */
+  async process(response, agent, worldContext) {
+    const violations = [];
+    const events = [];
+    if (response.error || !response.action) {
+      return { accepted: false, violations: [], events: [] };
+    }
+    const actionValidation = this.actionsRegistry.validate(
+      response.action,
+      response.parameters || {}
+    );
+    if (!actionValidation.valid) {
+      logger6.warn(`Invalid action from ${response.agentUrl}: ${actionValidation.error}`);
+      violations.push({
+        ruleId: "_action_validation",
+        severity: "warning",
+        message: actionValidation.error,
+        agentUrl: response.agentUrl,
+        action: "warn"
+      });
+      return { accepted: false, violations, events: [] };
+    }
+    const ruleContext = {
+      world: {
+        phase: worldContext.phase,
+        tick: worldContext.tick,
+        agents: worldContext.agents
+      },
+      event: {
+        id: uuidv4(),
+        type: "agent_action",
+        timestamp: Date.now(),
+        agentUrl: response.agentUrl,
+        data: {
+          action: response.action,
+          parameters: response.parameters
+        }
+      },
+      agent
+    };
+    for (const rule of this.rules) {
+      try {
+        const violation = await rule.evaluate(ruleContext);
+        if (violation) {
+          violations.push(violation);
+          logger6.warn(`Rule violation: ${rule.name}`, {
+            agentUrl: response.agentUrl,
+            action: response.action,
+            severity: violation.severity
+          });
+        }
+      } catch (error) {
+        logger6.error(`Rule evaluation error (${rule.name}):`, error);
+      }
+    }
+    const blocking = violations.filter(
+      (v) => v.severity === "error" || v.severity === "critical"
+    );
+    if (blocking.length > 0) {
+      return { accepted: false, violations, events: [] };
+    }
+    events.push({
+      id: uuidv4(),
+      type: "action_executed",
+      timestamp: Date.now(),
+      agentUrl: response.agentUrl,
+      data: {
+        action: response.action,
+        parameters: response.parameters
+      }
+    });
+    return {
+      accepted: true,
+      violations,
+      stateUpdates: {
+        [`lastAction_${response.agentUrl}`]: {
+          action: response.action,
+          parameters: response.parameters,
+          tick: worldContext.tick
+        }
+      },
+      events
+    };
+  }
+  /**
+   * Update the rules list
+   */
+  setRules(rules) {
+    this.rules = rules;
+  }
+};
+
+// src/engine/TickOrchestrator.ts
+import { v4 as uuidv42 } from "uuid";
+var logger7 = createLogger("TickOrchestrator");
+var TickOrchestrator = class {
+  constructor(a2aClient, actionsRegistry, rules, config) {
+    this.a2aClient = a2aClient;
+    this.actionsRegistry = actionsRegistry;
+    this.actionProcessor = new ActionProcessor(rules, actionsRegistry);
+    this.orchestrationConfig = {
+      broadcastOnTick: config?.broadcastOnTick ?? true,
+      tickTimeout: config?.tickTimeout ?? 1e4,
+      promptTemplate: config?.promptTemplate
+    };
+  }
+  actionProcessor;
+  orchestrationConfig;
+  /**
+   * Execute a single world tick
+   */
+  async executeTick(tick, agents, state, worldName) {
+    const result = {
+      tick,
+      responses: /* @__PURE__ */ new Map(),
+      events: [],
+      stateUpdates: {},
+      errors: []
+    };
+    if (agents.length === 0 || !this.orchestrationConfig.broadcastOnTick) {
+      logger7.debug(`Tick ${tick}: no agents to broadcast to`);
+      return result;
+    }
+    const tickContext = this.buildTickContext(tick, agents, state, worldName);
+    const message = JSON.stringify(tickContext);
+    logger7.debug(`Tick ${tick}: broadcasting to ${agents.length} agents`);
+    const responses = await this.a2aClient.broadcastToAll(message, {
+      type: "world_tick",
+      tick,
+      worldName
+    });
+    const agentsMap = /* @__PURE__ */ new Map();
+    for (const agent of agents) {
+      agentsMap.set(agent.url, agent);
+    }
+    for (const [agentUrl, a2aResponse] of responses) {
+      const tickResponse = this.parseAgentResponse(agentUrl, a2aResponse);
+      result.responses.set(agentUrl, tickResponse);
+      if (tickResponse.error) {
+        result.errors.push({ agentUrl, error: tickResponse.error });
+        continue;
+      }
+      const agent = agentsMap.get(agentUrl);
+      if (!agent || !tickResponse.action) continue;
+      const processResult = await this.actionProcessor.process(
+        tickResponse,
+        agent,
+        { phase: state.phase, tick, agents: agentsMap }
+      );
+      if (processResult.accepted) {
+        if (processResult.stateUpdates) {
+          Object.assign(result.stateUpdates, processResult.stateUpdates);
+        }
+        if (processResult.events) {
+          result.events.push(...processResult.events);
+        }
+      }
+      for (const violation of processResult.violations) {
+        result.events.push({
+          id: uuidv42(),
+          type: "rule_violation",
+          timestamp: Date.now(),
+          agentUrl,
+          data: {
+            ruleId: violation.ruleId,
+            severity: violation.severity,
+            message: violation.message
+          }
+        });
+      }
+    }
+    result.events.push({
+      id: uuidv42(),
+      type: "tick",
+      timestamp: Date.now(),
+      data: {
+        tick,
+        agentsBroadcasted: agents.length,
+        responsesReceived: result.responses.size,
+        errorsCount: result.errors.length
+      }
+    });
+    logger7.info(`Tick ${tick} complete`, {
+      responses: result.responses.size,
+      errors: result.errors.length,
+      stateUpdates: Object.keys(result.stateUpdates).length
+    });
+    return result;
+  }
+  /**
+   * Build the tick context that gets sent to each agent
+   */
+  buildTickContext(tick, agents, state, worldName) {
+    const availableActions = this.actionsRegistry.toSummary();
+    const agentsSummary = agents.map((a) => ({
+      name: a.name,
+      role: a.role || "participant",
+      skills: a.skills.map((s) => s.id)
+    }));
+    const prompt = this.orchestrationConfig.promptTemplate || `You are participating in world "${worldName}". Current tick: ${tick}. Choose an action from the available actions and respond with a JSON object: { "action": "<action_name>", "parameters": { ... } }. You may also include a "message" field for free-form communication.`;
+    return {
+      type: "world_tick",
+      tick,
+      worldName,
+      state: {
+        phase: state.phase,
+        tick: state.tick,
+        round: state.round,
+        metadata: state.metadata
+      },
+      availableActions,
+      agents: agentsSummary,
+      prompt
+    };
+  }
+  /**
+   * Parse an A2A response into an AgentTickResponse
+   */
+  parseAgentResponse(agentUrl, a2aResponse) {
+    if (!a2aResponse.success) {
+      return {
+        agentUrl,
+        error: a2aResponse.error || "A2A communication failed"
+      };
+    }
+    const reply = a2aResponse.reply;
+    if (!reply) {
+      return { agentUrl, message: "" };
+    }
+    try {
+      const parsed = JSON.parse(reply);
+      return {
+        agentUrl,
+        action: parsed.action,
+        parameters: parsed.parameters || {},
+        message: parsed.message
+      };
+    } catch {
+      return {
+        agentUrl,
+        message: reply
+      };
+    }
+  }
+  /**
+   * Update orchestration config
+   */
+  setConfig(config) {
+    Object.assign(this.orchestrationConfig, config);
+  }
+  /**
+   * Update rules on the action processor
+   */
+  setRules(rules) {
+    this.actionProcessor.setRules(rules);
+  }
+};
+
+// src/a2a/MessageRouter.ts
+var logger8 = createLogger("MessageRouter");
+var MessageRouter = class {
+  constructor(a2aClient, getAgents) {
+    this.a2aClient = a2aClient;
+    this.getAgents = getAgents;
+  }
+  /**
+   * Route a message from one agent to another
+   */
+  async route(fromAgentUrl, toAgentUrl, message) {
+    const agents = this.getAgents();
+    const sender = agents.find((a) => a.url === fromAgentUrl);
+    if (!sender) {
+      return {
+        success: false,
+        error: `Sender not in world: ${fromAgentUrl}`
+      };
+    }
+    const recipient = agents.find((a) => a.url === toAgentUrl);
+    if (!recipient) {
+      return {
+        success: false,
+        error: `Recipient not in world: ${toAgentUrl}`
+      };
+    }
+    const wrappedMessage = JSON.stringify({
+      type: "world_message",
+      from: {
+        url: sender.url,
+        name: sender.name,
+        role: sender.role
+      },
+      message
+    });
+    logger8.info(`Routing message: ${sender.name} \u2192 ${recipient.name}`);
+    return this.a2aClient.sendToAgent(toAgentUrl, wrappedMessage, {
+      type: "world_message",
+      fromAgentUrl
+    });
+  }
+  /**
+   * Broadcast a message from one agent to all other agents in the world
+   */
+  async routeToAll(fromAgentUrl, message) {
+    const agents = this.getAgents();
+    const sender = agents.find((a) => a.url === fromAgentUrl);
+    if (!sender) {
+      const result = /* @__PURE__ */ new Map();
+      result.set(fromAgentUrl, {
+        success: false,
+        error: `Sender not in world: ${fromAgentUrl}`
+      });
+      return result;
+    }
+    const wrappedMessage = JSON.stringify({
+      type: "world_broadcast",
+      from: {
+        url: sender.url,
+        name: sender.name,
+        role: sender.role
+      },
+      message
+    });
+    const results = /* @__PURE__ */ new Map();
+    const recipients = agents.filter((a) => a.url !== fromAgentUrl);
+    const promises = recipients.map(async (recipient) => {
+      const response = await this.a2aClient.sendToAgent(
+        recipient.url,
+        wrappedMessage,
+        { type: "world_broadcast", fromAgentUrl }
+      );
+      results.set(recipient.url, response);
+    });
+    await Promise.allSettled(promises);
+    logger8.info(`Broadcast from ${sender.name} to ${recipients.length} agents`);
+    return results;
+  }
+};
+
 // src/engine/World.ts
-var logger4 = createLogger("World");
+var logger9 = createLogger("World");
 var World = class {
   constructor(config) {
     this.config = config;
@@ -784,9 +1328,26 @@ var World = class {
     this.agents = /* @__PURE__ */ new Map();
     this.cardFetcher = new CardFetcher();
     this.evaluator = new AgentEvaluator(config.admission);
-    logger4.info(`World "${config.name}" created`, {
+    this.a2aClient = new WorldA2AClient();
+    this.actionsRegistry = new WorldActionsRegistry();
+    this.orchestrator = new TickOrchestrator(
+      this.a2aClient,
+      this.actionsRegistry,
+      config.rules || [],
+      config.orchestration
+    );
+    this.messageRouter = new MessageRouter(
+      this.a2aClient,
+      () => this.getAgents()
+    );
+    if (config.actions && config.actions.length > 0) {
+      this.actionsRegistry.registerAll(config.actions);
+      logger9.info(`Registered ${config.actions.length} world actions`);
+    }
+    logger9.info(`World "${config.name}" created`, {
       type: config.type || "generic",
-      maxAgents: config.admission.maxAgents
+      maxAgents: config.admission.maxAgents,
+      orchestration: !!config.orchestration?.broadcastOnTick
     });
   }
   state;
@@ -797,21 +1358,26 @@ var World = class {
   evaluator;
   tickInterval = null;
   autoSaveInterval = null;
+  // Agent-World bridge components
+  a2aClient;
+  actionsRegistry;
+  orchestrator;
+  messageRouter;
   /**
    * Initialize the world (connect persistence, restore state, discover agents)
    */
   async init() {
-    logger4.info("Initializing world...");
+    logger9.info("Initializing world...");
     this.setState("initializing");
     try {
       if (this.config.persistence) {
-        logger4.info(`Connecting to persistence backend: ${this.config.persistence.type}`);
+        logger9.info(`Connecting to persistence backend: ${this.config.persistence.type}`);
         this.persistence = await createPersistence(this.config.persistence);
         await this.persistence.connect();
         const savedState = await this.persistence.loadState();
         if (savedState) {
           this.state = savedState;
-          logger4.info("Restored world state from persistence", {
+          logger9.info("Restored world state from persistence", {
             phase: savedState.phase,
             tick: savedState.tick
           });
@@ -819,16 +1385,16 @@ var World = class {
           for (const agent of savedAgents) {
             this.agents.set(agent.url, agent);
           }
-          logger4.info(`Restored ${savedAgents.length} agents from persistence`);
+          logger9.info(`Restored ${savedAgents.length} agents from persistence`);
         }
       }
       if (this.config.blockchain) {
-        logger4.info("Initializing blockchain client...");
+        logger9.info("Initializing blockchain client...");
         this.blockchainClient = new BlockchainClient(this.config.blockchain);
         await this.blockchainClient.init();
       }
       if (this.config.agentUrls && this.config.agentUrls.length > 0) {
-        logger4.info(`Discovering ${this.config.agentUrls.length} pre-configured agents...`);
+        logger9.info(`Discovering ${this.config.agentUrls.length} pre-configured agents...`);
         const results = await this.cardFetcher.fetchCards(this.config.agentUrls);
         for (let i = 0; i < results.length; i++) {
           const result = results[i];
@@ -836,7 +1402,7 @@ var World = class {
             try {
               await this.admitAgent(result.card);
             } catch (error) {
-              logger4.warn(`Failed to admit pre-configured agent:`, error.message);
+              logger9.warn(`Failed to admit pre-configured agent:`, error.message);
             }
           }
         }
@@ -845,12 +1411,12 @@ var World = class {
         this.startAutoSave();
       }
       this.setState("ready");
-      logger4.info("World initialized successfully", {
+      logger9.info("World initialized successfully", {
         agents: this.agents.size,
         persistence: this.config.persistence?.type || "none"
       });
     } catch (error) {
-      logger4.error("Failed to initialize world:", error);
+      logger9.error("Failed to initialize world:", error);
       this.setState("failed");
       throw error;
     }
@@ -860,13 +1426,13 @@ var World = class {
    */
   async start() {
     if (this.state.phase === "running") {
-      logger4.warn("World is already running");
+      logger9.warn("World is already running");
       return;
     }
-    logger4.info("Starting world simulation...");
+    logger9.info("Starting world simulation...");
     this.setState("running");
     await this.logEvent({
-      id: uuidv4(),
+      id: uuidv43(),
       type: "world_started",
       timestamp: Date.now()
     });
@@ -878,7 +1444,7 @@ var World = class {
    * Stop the world simulation
    */
   async stop() {
-    logger4.info("Stopping world...");
+    logger9.info("Stopping world...");
     this.setState("stopped");
     if (this.tickInterval) {
       clearInterval(this.tickInterval);
@@ -892,11 +1458,11 @@ var World = class {
       await this.persistence.saveState(this.state);
     }
     await this.logEvent({
-      id: uuidv4(),
+      id: uuidv43(),
       type: "world_stopped",
       timestamp: Date.now()
     });
-    logger4.info("World stopped");
+    logger9.info("World stopped");
   }
   /**
    * Admit an agent to the world
@@ -911,15 +1477,15 @@ var World = class {
       if (!isValid) {
         throw new Error("Agent not registered in on-chain AgentRegistry");
       }
-      logger4.info(`Agent validated on-chain: ${card.name}`);
+      logger9.info(`Agent validated on-chain: ${card.name}`);
     }
     if (this.blockchainClient && this.config.blockchain?.requireMembership && walletAddress) {
       const hasMembership = await this.blockchainClient.hasMembership(walletAddress);
       if (!hasMembership) {
-        logger4.info(`Minting membership NFT for agent: ${card.name}`);
+        logger9.info(`Minting membership NFT for agent: ${card.name}`);
         await this.blockchainClient.mintMembership(walletAddress);
       } else {
-        logger4.info(`Agent already has membership: ${card.name}`);
+        logger9.info(`Agent already has membership: ${card.name}`);
       }
     }
     const profile = {
@@ -938,17 +1504,18 @@ var World = class {
       walletAddress
     };
     this.agents.set(profile.url, profile);
+    this.a2aClient.addAgent(profile.url);
     if (this.persistence) {
       await this.persistence.saveAgent(profile);
     }
     await this.logEvent({
-      id: uuidv4(),
+      id: uuidv43(),
       type: "agent_joined",
       timestamp: Date.now(),
       agentUrl: profile.url,
       data: { name: profile.name, role: profile.role }
     });
-    logger4.info(`Agent admitted: ${profile.name}`, {
+    logger9.info(`Agent admitted: ${profile.name}`, {
       role: profile.role,
       totalAgents: this.agents.size
     });
@@ -962,17 +1529,18 @@ var World = class {
       throw new Error(`Agent not found: ${agentUrl}`);
     }
     this.agents.delete(agentUrl);
+    this.a2aClient.removeAgent(agentUrl);
     if (this.persistence) {
       await this.persistence.removeAgent(agentUrl);
     }
     await this.logEvent({
-      id: uuidv4(),
+      id: uuidv43(),
       type: "agent_left",
       timestamp: Date.now(),
       agentUrl,
       data: { name: agent.name }
     });
-    logger4.info(`Agent removed: ${agent.name}`, {
+    logger9.info(`Agent removed: ${agent.name}`, {
       totalAgents: this.agents.size
     });
   }
@@ -988,6 +1556,18 @@ var World = class {
   getState() {
     return { ...this.state };
   }
+  /**
+   * Get the message router (for agent-to-agent communication via server)
+   */
+  getMessageRouter() {
+    return this.messageRouter;
+  }
+  /**
+   * Get the actions registry
+   */
+  getActionsRegistry() {
+    return this.actionsRegistry;
+  }
   /**
    * Log an event
    */
@@ -1011,10 +1591,10 @@ var World = class {
     this.autoSaveInterval = setInterval(async () => {
       if (this.persistence) {
         await this.persistence.saveState(this.state);
-        logger4.debug("Auto-saved world state");
+        logger9.debug("Auto-saved world state");
       }
     }, interval);
-    logger4.info(`Auto-save enabled (interval: ${interval}ms)`);
+    logger9.info(`Auto-save enabled (interval: ${interval}ms)`);
   }
   /**
    * Start simulation ticking
@@ -1023,31 +1603,48 @@ var World = class {
     const interval = this.config.simulation.tickIntervalMs;
     this.tickInterval = setInterval(async () => {
       this.state.tick++;
-      await this.logEvent({
-        id: uuidv4(),
-        type: "tick",
-        timestamp: Date.now(),
-        data: { tick: this.state.tick }
-      });
-      logger4.debug(`Tick ${this.state.tick}`);
+      this.state.timestamp = Date.now();
+      try {
+        const tickResult = await this.orchestrator.executeTick(
+          this.state.tick,
+          this.getAgents(),
+          this.state,
+          this.config.name
+        );
+        if (tickResult.stateUpdates && Object.keys(tickResult.stateUpdates).length > 0) {
+          Object.assign(this.state.metadata, tickResult.stateUpdates);
+        }
+        for (const event of tickResult.events) {
+          await this.logEvent(event);
+        }
+      } catch (error) {
+        logger9.error(`Tick ${this.state.tick} orchestration error:`, error);
+        await this.logEvent({
+          id: uuidv43(),
+          type: "tick_error",
+          timestamp: Date.now(),
+          data: { tick: this.state.tick, error: error?.message || String(error) }
+        });
+      }
+      logger9.debug(`Tick ${this.state.tick}`);
       if (this.config.simulation?.maxTicks && this.state.tick >= this.config.simulation.maxTicks) {
-        logger4.info("Max ticks reached, stopping world");
+        logger9.info("Max ticks reached, stopping world");
         await this.stop();
       }
     }, interval);
-    logger4.info(`Simulation ticking enabled (interval: ${interval}ms)`);
+    logger9.info(`Simulation ticking enabled (interval: ${interval}ms)`);
   }
 };
 
 // src/server/app.ts
 import express from "express";
-var logger5 = createLogger("WorldServer");
+var logger10 = createLogger("WorldServer");
 function createWorldApp(world) {
   const app = express();
   app.use(express.json());
   app.use(express.urlencoded({ extended: true }));
   app.use((req, res, next) => {
-    logger5.debug(`${req.method} ${req.path}`, {
+    logger10.debug(`${req.method} ${req.path}`, {
       query: req.query,
       ip: req.ip
     });
@@ -1077,7 +1674,7 @@ function createWorldApp(world) {
           error: "agentUrl is required"
         });
       }
-      logger5.info(`Agent join request from: ${agentUrl}`, {
+      logger10.info(`Agent join request from: ${agentUrl}`, {
         wallet: walletAddress || "none"
       });
       const cardFetcher = new (await import("./CardFetcher-3QKJ2I5P.js")).CardFetcher();
@@ -1098,7 +1695,7 @@ function createWorldApp(world) {
         }
       });
     } catch (error) {
-      logger5.error("Failed to process join request:", error);
+      logger10.error("Failed to process join request:", error);
       res.status(400).json({
         success: false,
         error: error.message || "Failed to join world"
@@ -1152,6 +1749,60 @@ function createWorldApp(world) {
       });
     }
   });
+  app.post("/world/message", async (req, res) => {
+    try {
+      const { fromAgentUrl, toAgentUrl, message } = req.body;
+      if (!fromAgentUrl) {
+        return res.status(400).json({
+          success: false,
+          error: "fromAgentUrl is required"
+        });
+      }
+      if (!message) {
+        return res.status(400).json({
+          success: false,
+          error: "message is required"
+        });
+      }
+      const router = world.getMessageRouter();
+      if (toAgentUrl) {
+        const result = await router.route(fromAgentUrl, toAgentUrl, message);
+        res.json({
+          success: result.success,
+          reply: result.reply,
+          error: result.error
+        });
+      } else {
+        const results = await router.routeToAll(fromAgentUrl, message);
+        const responses = {};
+        for (const [url, result] of results) {
+          responses[url] = {
+            success: result.success,
+            reply: result.reply,
+            error: result.error
+          };
+        }
+        res.json({
+          success: true,
+          responses,
+          count: results.size
+        });
+      }
+    } catch (error) {
+      logger10.error("Failed to route message:", error);
+      res.status(500).json({
+        success: false,
+        error: error.message || "Failed to route message"
+      });
+    }
+  });
+  app.get("/world/actions", (req, res) => {
+    const registry = world.getActionsRegistry();
+    res.json({
+      actions: registry.toSummary(),
+      count: registry.getAll().length
+    });
+  });
   app.delete("/world/agents/:agentUrl", async (req, res) => {
     try {
       const agentUrlParam = req.params.agentUrl;
@@ -1175,7 +1826,7 @@ function createWorldApp(world) {
     });
   });
   app.use((err, req, res, next) => {
-    logger5.error("Server error:", err);
+    logger10.error("Server error:", err);
     res.status(500).json({
       error: "Internal server error",
       message: err.message
@@ -1187,27 +1838,29 @@ async function startWorldServer(world) {
   const app = createWorldApp(world);
   const server = app.listen(world.config.server.port, world.config.server.host, () => {
     const { host, port } = world.config.server;
-    logger5.info(`World "${world.config.name}" server started`);
-    logger5.info(`  http://${host}:${port}`);
-    logger5.info("");
-    logger5.info("Endpoints:");
-    logger5.info(`  GET    /                    - World info`);
-    logger5.info(`  POST   /world/join          - Agent join request`);
-    logger5.info(`  GET    /world/agents        - List agents`);
-    logger5.info(`  GET    /world/state         - World state`);
-    logger5.info(`  POST   /world/start         - Start simulation`);
-    logger5.info(`  POST   /world/stop          - Stop simulation`);
-    logger5.info(`  DELETE /world/agents/:url   - Remove agent`);
+    logger10.info(`World "${world.config.name}" server started`);
+    logger10.info(`  http://${host}:${port}`);
+    logger10.info("");
+    logger10.info("Endpoints:");
+    logger10.info(`  GET    /                    - World info`);
+    logger10.info(`  POST   /world/join          - Agent join request`);
+    logger10.info(`  GET    /world/agents        - List agents`);
+    logger10.info(`  GET    /world/state         - World state`);
+    logger10.info(`  GET    /world/actions       - List world actions`);
+    logger10.info(`  POST   /world/message       - Route agent messages`);
+    logger10.info(`  POST   /world/start         - Start simulation`);
+    logger10.info(`  POST   /world/stop          - Stop simulation`);
+    logger10.info(`  DELETE /world/agents/:url   - Remove agent`);
   });
   process.on("SIGTERM", async () => {
-    logger5.info("SIGTERM received, shutting down gracefully...");
+    logger10.info("SIGTERM received, shutting down gracefully...");
     server.close(async () => {
       await world.stop();
       process.exit(0);
     });
   });
   process.on("SIGINT", async () => {
-    logger5.info("SIGINT received, shutting down gracefully...");
+    logger10.info("SIGINT received, shutting down gracefully...");
     server.close(async () => {
       await world.stop();
       process.exit(0);
@@ -1215,15 +1868,20 @@ async function startWorldServer(world) {
   });
 }
 export {
+  ActionProcessor,
   AdmissionRulesSchema,
   AgentEvaluator,
   BlockchainClient,
   BlockchainConfigSchema,
   CardFetcher,
   InMemoryAdapter,
+  MessageRouter,
   PersistenceConfigSchema,
+  TickOrchestrator,
   TokenConfigSchema,
   World,
+  WorldA2AClient,
+  WorldActionsRegistry,
   WorldConfigSchema,
   createLogger,
   createPersistence,