@m4trix/core 0.13.0 → 0.15.0

package/dist/matrix/index.cjs

@@ -502,6 +502,7 @@ var AgentNetwork = class _AgentNetwork {
       createChannel: (name) => network.addChannel(name),
       sink: Sink,
       registerAgent: (agent) => network.registerAgentInternal(agent),
+      registerAggregator: (aggregator) => network.registerAggregatorInternal(aggregator),
       spawner: (factory) => network.createSpawnerInternal(factory)
     };
     callback(ctx);
@@ -536,6 +537,9 @@ var AgentNetwork = class _AgentNetwork {
     };
     return binding;
   }
+  registerAggregatorInternal(aggregator) {
+    return this.registerAgentInternal(aggregator);
+  }
   createSpawnerInternal(factoryClass) {
     const reg = {
       factoryClass,
@@ -657,20 +661,110 @@ var AgentNetworkEvent = {
     };
   }
 };
-var _params, _logic, _id, _listensTo;
+var EventAggregator = class _EventAggregator {
+  constructor({
+    listensTo = [],
+    emits = [],
+    emitWhen
+  }) {
+    this._listensTo = listensTo;
+    this._emits = emits;
+    this._emitWhen = emitWhen;
+  }
+  static listensTo(events) {
+    return new _EventAggregator({ listensTo: [...events] });
+  }
+  emits(events) {
+    return new _EventAggregator({
+      listensTo: this._listensTo,
+      emits: [...this._emits, ...events],
+      emitWhen: this._emitWhen
+    });
+  }
+  emitWhen(fn) {
+    return new _EventAggregator({
+      listensTo: this._listensTo,
+      emits: this._emits,
+      emitWhen: fn
+    });
+  }
+  mapToEmit(fn) {
+    return new EventAggregatorInstance({
+      listensTo: this._listensTo.map((eventDef) => eventDef.name),
+      emitWhen: this._emitWhen ?? (() => true),
+      mapToEmit: fn
+    });
+  }
+};
+var _id, _listensTo, _emitWhen, _mapToEmit;
+var EventAggregatorInstance = class {
+  constructor({
+    listensTo,
+    emitWhen,
+    mapToEmit
+  }) {
+    __privateAdd(this, _id, void 0);
+    __privateAdd(this, _listensTo, void 0);
+    __privateAdd(this, _emitWhen, void 0);
+    __privateAdd(this, _mapToEmit, void 0);
+    __privateSet(this, _id, `event-aggregator-${crypto$1.randomUUID()}`);
+    __privateSet(this, _listensTo, listensTo);
+    __privateSet(this, _emitWhen, emitWhen);
+    __privateSet(this, _mapToEmit, mapToEmit);
+  }
+  getId() {
+    return __privateGet(this, _id);
+  }
+  getListensTo() {
+    return __privateGet(this, _listensTo);
+  }
+  async invoke(options) {
+    const { triggerEvent, emit, runEvents, contextEvents } = options ?? {};
+    if (triggerEvent == null) {
+      return;
+    }
+    const emitFn = emit ?? ((_event) => {
+    });
+    const runEventsValue = runEvents ?? [];
+    const contextEventsValue = contextEvents ?? {
+      all: [],
+      byRun: () => [],
+      map: /* @__PURE__ */ new Map()
+    };
+    const shouldEmit = await __privateGet(this, _emitWhen).call(this, {
+      triggerEvent,
+      runEvents: runEventsValue,
+      contextEvents: contextEventsValue
+    });
+    if (!shouldEmit) {
+      return;
+    }
+    await __privateGet(this, _mapToEmit).call(this, {
+      triggerEvent,
+      emit: emitFn,
+      runEvents: runEventsValue,
+      contextEvents: contextEventsValue
+    });
+  }
+};
+_id = new WeakMap();
+_listensTo = new WeakMap();
+_emitWhen = new WeakMap();
+_mapToEmit = new WeakMap();
+var _params, _logic, _id2, _listensTo2;
 var Agent = class {
   constructor(logic, params, listensTo) {
     __privateAdd(this, _params, void 0);
     __privateAdd(this, _logic, void 0);
-    __privateAdd(this, _id, void 0);
-    __privateAdd(this, _listensTo, void 0);
+    __privateAdd(this, _id2, void 0);
+    __privateAdd(this, _listensTo2, void 0);
     __privateSet(this, _logic, logic);
     __privateSet(this, _params, params);
-    __privateSet(this, _id, `agent-${crypto$1.randomUUID()}`);
-    __privateSet(this, _listensTo, listensTo ?? []);
+    __privateSet(this, _id2, `agent-${crypto$1.randomUUID()}`);
+    __privateSet(this, _listensTo2, listensTo ?? []);
   }
   getListensTo() {
-    return __privateGet(this, _listensTo);
+    return __privateGet(this, _listensTo2);
   }
   async invoke(options) {
     const { triggerEvent, emit, runEvents, contextEvents } = options ?? {};
@@ -689,13 +783,13 @@ var Agent = class {
     });
   }
   getId() {
-    return __privateGet(this, _id);
+    return __privateGet(this, _id2);
   }
 };
 _params = new WeakMap();
 _logic = new WeakMap();
-_id = new WeakMap();
-_listensTo = new WeakMap();
+_id2 = new WeakMap();
+_listensTo2 = new WeakMap();
 
 // src/matrix/agent-factory.ts
 var AgentFactory = class _AgentFactory {
@@ -781,12 +875,11 @@ var DepedencyLayer = {
       name,
       _name: def.name,
       config: def.config,
-      decodeConfig,
-      define() {
-        return dep;
-      }
+      decodeConfig
     };
-    return dep;
+    return Object.assign(dep, {
+      define: () => dep
+    });
   }
 };
 function toLayerArray(layers) {
@@ -805,6 +898,15 @@ function assertUniqueLayerNames(layers) {
     seen.add(key);
   }
 }
+var DoneTypeId = Symbol.for("sunken-trove/Done");
+var Done = {
+  of(value) {
+    return { [DoneTypeId]: DoneTypeId, _tag: "Done", done: value };
+  },
+  is(u) {
+    return typeof u === "object" && u !== null && DoneTypeId in u && u[DoneTypeId] === DoneTypeId;
+  }
+};
 var Skill = class _Skill {
   constructor(params) {
     this._inputSchema = params.inputSchema;
@@ -911,7 +1013,7 @@ var Skill = class _Skill {
         for (const c of chunks) {
           yield c;
         }
-        yield { _tag: "Done", done: decodedDone };
+        yield Done.of(decodedDone);
       },
       invoke: async (input, runtime) => {
         const decodedInput = effect.Effect.runSync(
@@ -1144,6 +1246,9 @@ exports.Channel = Channel;
 exports.ChannelName = ChannelName;
 exports.ConfiguredChannel = ConfiguredChannel;
 exports.DepedencyLayer = DepedencyLayer;
+exports.Done = Done;
+exports.EventAggregator = EventAggregator;
+exports.EventAggregatorInstance = EventAggregatorInstance;
 exports.EventMetaSchema = EventMetaSchema;
 exports.ExposeAuthError = ExposeAuthError;
 exports.ExpressEndpoint = ExpressEndpoint;