@m4trix/core 0.13.0 → 0.15.0

package/dist/matrix/index.d.ts

@@ -106,15 +106,15 @@ declare class Agent<TParams, TTriggerEvent = never, TEmitEvent = never> {
 
 type BaseSchemaDefintion = Schema.Schema.Any;
 
-type EventDef$2 = AgentNetworkEventDef<string, Schema.Schema.Any>;
+type EventDef$3 = AgentNetworkEventDef<string, Schema.Schema.Any>;
 /** Extracts the envelope type (name, meta, payload) from an event definition */
-type EventEnvelope<E extends EventDef$2> = E extends AgentNetworkEventDef<infer N, infer PS> ? {
+type EventEnvelope$1<E extends EventDef$3> = E extends AgentNetworkEventDef<infer N, infer PS> ? {
     name: N;
     meta: EventMeta;
     payload: Schema.Schema.Type<PS>;
 } : never;
 /** What the user passes to emit() – no meta required */
-type EmitPayload<E extends EventDef$2> = E extends AgentNetworkEventDef<infer N, infer PS> ? {
+type EmitPayload$1<E extends EventDef$3> = E extends AgentNetworkEventDef<infer N, infer PS> ? {
     name: N;
     payload: Schema.Schema.Type<PS>;
 } : never;
@@ -126,7 +126,7 @@ type LogicFn<TParams, TTriggerEvent, TEmitEvent> = (ctx: {
     runEvents: RunEvents;
     contextEvents: ContextEvents;
 }) => Promise<void>;
-declare class AgentFactory<TParams = unknown, TListensTo extends EventDef$2 = never, TEmits extends EventDef$2 = never> {
+declare class AgentFactory<TParams = unknown, TListensTo extends EventDef$3 = never, TEmits extends EventDef$3 = never> {
     private _listensTo;
     private _emits;
     private _logic;
@@ -137,13 +137,13 @@ declare class AgentFactory<TParams = unknown, TListensTo extends EventDef$2 = ne
     getListensTo(): ReadonlyArray<TListensTo>;
     /** Union of all event definitions this agent can emit */
     getEmits(): ReadonlyArray<TEmits>;
-    getLogic(): LogicFn<TParams, EventEnvelope<TListensTo>, EmitPayload<TEmits>> | undefined;
+    getLogic(): LogicFn<TParams, EventEnvelope$1<TListensTo>, EmitPayload$1<TEmits>> | undefined;
     static run(): AgentFactory<unknown, never, never>;
     params<TSchema extends BaseSchemaDefintion>(params: TSchema): AgentFactory<TSchema['Type'], TListensTo, TEmits>;
-    listensTo<E extends EventDef$2>(events: Array<E>): AgentFactory<TParams, TListensTo | E, TEmits>;
-    emits<E extends EventDef$2>(events: Array<E>): AgentFactory<TParams, TListensTo, TEmits | E>;
-    logic(fn: LogicFn<TParams, EventEnvelope<TListensTo>, EmitPayload<TEmits>>): AgentFactory<TParams, TListensTo, TEmits>;
-    produce(params: TParams): Agent<TParams, EventEnvelope<TListensTo>, EmitPayload<TEmits>>;
+    listensTo<E extends EventDef$3>(events: Array<E>): AgentFactory<TParams, TListensTo | E, TEmits>;
+    emits<E extends EventDef$3>(events: Array<E>): AgentFactory<TParams, TListensTo, TEmits | E>;
+    logic(fn: LogicFn<TParams, EventEnvelope$1<TListensTo>, EmitPayload$1<TEmits>>): AgentFactory<TParams, TListensTo, TEmits>;
+    produce(params: TParams): Agent<TParams, EventEnvelope$1<TListensTo>, EmitPayload$1<TEmits>>;
 }
 
 /**
@@ -171,7 +171,7 @@ declare const Sink: {
     httpStream(): SinkDef;
 };
 declare function isHttpStreamSink(sink: SinkDef): boolean;
-type EventDef$1 = AgentNetworkEventDef<string, Schema.Schema.Any>;
+type EventDef$2 = AgentNetworkEventDef<string, Schema.Schema.Any>;
 type ChannelDef = {
     readonly _tag: 'ChannelDef';
     readonly name: ChannelName;
@@ -186,10 +186,10 @@ declare class ConfiguredChannel {
     private _events;
     private _sinks;
     constructor(name: ChannelName);
-    events(events: ReadonlyArray<EventDef$1>): this;
+    events(events: ReadonlyArray<EventDef$2>): this;
     sink(sink: SinkDef): this;
     sinks(sinks: ReadonlyArray<SinkDef>): this;
-    getEvents(): ReadonlyArray<EventDef$1>;
+    getEvents(): ReadonlyArray<EventDef$2>;
     getSinks(): ReadonlyArray<SinkDef>;
 }
 declare const Channel: {
@@ -298,7 +298,7 @@ type ExposedAPI = {
     createStream: StreamFactory;
 };
 
-type EventDef = AgentNetworkEventDef<string, Schema.Schema.Any>;
+type EventDef$1 = AgentNetworkEventDef<string, Schema.Schema.Any>;
 /** Structural interface for any Agent – avoids variance issues with private fields. */
 interface AnyAgent {
     getId(): string;
@@ -326,7 +326,7 @@ type SpawnCallbackContext<TRegistry extends Record<string, AgentFactory> = Recor
     spawn: SpawnFn;
 };
 type SpawnerBuilder<TRegistry extends Record<string, AgentFactory> = Record<string, AgentFactory>> = {
-    listen(channel: ConfiguredChannel, event: EventDef): SpawnerBuilder<TRegistry>;
+    listen(channel: ConfiguredChannel, event: EventDef$1): SpawnerBuilder<TRegistry>;
     registry<R extends Record<string, AgentFactory>>(reg: R): SpawnerBuilder<R>;
     defaultBinding(fn: (ctx: {
         kind: string;
@@ -341,6 +341,7 @@ type SetupContext = {
     createChannel: (name: string) => ConfiguredChannel;
     sink: typeof Sink;
     registerAgent: (agent: AnyAgent) => AgentBinding;
+    registerAggregator: (aggregator: AnyAgent) => AgentBinding;
     spawner: (factory: typeof AgentFactory) => SpawnerBuilder;
 };
 type AgentRegistration = {
@@ -351,7 +352,7 @@ type AgentRegistration = {
 type SpawnerRegistration = {
     factoryClass: typeof AgentFactory;
     listenChannel?: ConfiguredChannel;
-    listenEvent?: EventDef;
+    listenEvent?: EventDef$1;
     registry: Record<string, AgentFactory>;
     defaultBindingFn?: (ctx: {
         kind: string;
@@ -372,6 +373,7 @@ declare class AgentNetwork {
     private addChannel;
     private setMainChannel;
     private registerAgentInternal;
+    private registerAggregatorInternal;
     private createSpawnerInternal;
     getChannels(): Map<string, ConfiguredChannel>;
     getMainChannel(): ConfiguredChannel | undefined;
@@ -401,12 +403,63 @@ declare class AgentNetwork {
     private runScoped;
 }
 
+type EventDef = AgentNetworkEventDef<string, Schema.Schema.Any>;
+type EventEnvelope<E extends EventDef> = E extends AgentNetworkEventDef<infer N, infer PS> ? {
+    name: N;
+    meta: EventMeta;
+    payload: Schema.Schema.Type<PS>;
+} : never;
+type EmitPayload<E extends EventDef> = E extends AgentNetworkEventDef<infer N, infer PS> ? {
+    name: N;
+    payload: Schema.Schema.Type<PS>;
+} : never;
+type EmitWhenFn<TTriggerEvent> = (ctx: {
+    triggerEvent: TTriggerEvent;
+    runEvents: RunEvents;
+    contextEvents: ContextEvents;
+}) => boolean | Promise<boolean>;
+type MapToEmitFn<TTriggerEvent, TEmitEvent> = (ctx: {
+    triggerEvent: TTriggerEvent;
+    emit: (event: TEmitEvent) => void;
+    runEvents: RunEvents;
+    contextEvents: ContextEvents;
+}) => void | Promise<void>;
+declare class EventAggregator<TListensTo extends EventDef = never, TEmits extends EventDef = never> {
+    private _listensTo;
+    private _emits;
+    private _emitWhen;
+    private constructor();
+    static listensTo<E extends EventDef>(events: Array<E>): EventAggregator<E, never>;
+    emits<E extends EventDef>(events: Array<E>): EventAggregator<TListensTo, TEmits | E>;
+    emitWhen(fn: EmitWhenFn<EventEnvelope<TListensTo>>): EventAggregator<TListensTo, TEmits>;
+    mapToEmit(fn: MapToEmitFn<EventEnvelope<TListensTo>, EmitPayload<TEmits>>): EventAggregatorInstance<EventEnvelope<TListensTo>, EmitPayload<TEmits>>;
+}
+type EventAggregatorInstanceCtor<TTriggerEvent, TEmitEvent> = {
+    listensTo: ReadonlyArray<string>;
+    emitWhen: EmitWhenFn<TTriggerEvent>;
+    mapToEmit: MapToEmitFn<TTriggerEvent, TEmitEvent>;
+};
+declare class EventAggregatorInstance<TTriggerEvent, TEmitEvent> {
+    #private;
+    constructor({ listensTo, emitWhen, mapToEmit, }: EventAggregatorInstanceCtor<TTriggerEvent, TEmitEvent>);
+    getId(): string;
+    getListensTo(): readonly string[];
+    invoke(options?: {
+        triggerEvent?: TTriggerEvent;
+        emit?: (event: TEmitEvent) => void;
+        runEvents?: RunEvents;
+        contextEvents?: ContextEvents;
+    }): Promise<void>;
+}
+
 /**
  * Branded type for layer/dependency names. Enforces camelCase at runtime via refinement.
  * Used internally for parsing, validation, and uniqueness enforcement across layers.
  */
 type LayerName = string & Brand.Brand<'LayerName'>;
 declare const LayerName: Brand.Brand.Constructor<LayerName>;
+/** Error type when DepType contains reserved 'config' - produces explicit type error */
+type ReservedConfigError = "DepType must not contain 'config' - it is reserved by the layer";
 /** Definition of a single skill dependency with a branded name and config schema */
 type DepedencyLayerDef<N extends string, _DepType, ConfigSchema extends Schema.Schema.Any> = {
     readonly _tag: 'SkillDependencyDef';
@@ -426,13 +479,26 @@ type DependenciesToLayers<T> = T extends DepedencyLayerDef<infer N, infer DepTyp
 type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 /** Build layers object from union of dependency types */
 type LayersFromDeps<T extends DepedencyLayerDef<string, unknown, Schema.Schema.Any>> = [T] extends [never] ? Record<string, never> : UnionToIntersection<DependenciesToLayers<T>>;
+type DepedencyLayerBuilder<N extends string, ConfigSchema extends Schema.Schema.Any> = DepedencyLayerDef<N, object, ConfigSchema> & {
+    define<_DepType>(): 'config' extends keyof _DepType ? ReservedConfigError : DepedencyLayerDef<N, _DepType, ConfigSchema>;
+};
 declare const DepedencyLayer: {
     of<const N extends string, ConfigSchema extends Schema.Schema.Any>(def: {
         name: N;
         config: ConfigSchema;
-    }): DepedencyLayerDef<N, object, ConfigSchema> & {
-        define<_DepType>(): "config" extends keyof _DepType ? "DepType must not contain 'config' - it is reserved by the layer" : DepedencyLayerDef<N, _DepType, ConfigSchema>;
-    };
+    }): DepedencyLayerBuilder<N, ConfigSchema>;
+};
+/** Unique brand symbol for Done, following Effect's branded-type pattern */
+declare const DoneTypeId: unique symbol;
+type DoneTypeId = typeof DoneTypeId;
+interface Done<A> {
+    readonly [DoneTypeId]: DoneTypeId;
+    readonly _tag: 'Done';
+    readonly done: A;
+}
+declare const Done: {
+    of<A>(value: A): Done<A>;
+    is(u: unknown): u is Done<unknown>;
 };
 /** Minimal runtime options placeholder (logger, trace, etc. can be extended later) */
 type SkillRuntimeOptions = Record<string, unknown>;
@@ -448,10 +514,7 @@ type DefineFn<TIn, TChunk, TDone, TLayers> = (ctx: SkillDefineContext<TIn, TChun
 type SkillInstance<TInput, TChunk, TDone, TLayers> = {
     invokeStream: (input: TInput, runtime?: {
         layers: TLayers;
-    } & SkillRuntimeOptions) => AsyncIterable<TChunk | {
-        _tag: 'Done';
-        done: TDone;
-    }>;
+    } & SkillRuntimeOptions) => AsyncIterable<TChunk | Done<TDone>>;
     /** Input is decoded to TInput before being passed to the skill logic */
     invoke: (input: TInput, runtime?: {
         layers: TLayers;
@@ -578,4 +641,4 @@ declare const consoleTracer: Tracer.Tracer;
  */
 declare const consoleTracerLayer: Layer.Layer<never>;
 
-export { Agent, AgentBinding, AgentFactory, AgentNetwork, AgentNetworkEvent, AgentNetworkEventDef, AnyAgent, AuthResult, Channel, ChannelDef, ChannelName, ConfiguredChannel, ContextEvents, DepedencyLayer, DepedencyLayerDef, EmitPayload, EnvelopeLike, EventEnvelope, EventMeta, EventMetaSchema, EventPlane, ExposeAuthError, ExposeOptions, ExposeRequest, ExposeSelect, ExposedAPI, ExposedStream, ExpressEndpoint, ExpressEndpointOptions, ExpressHandler, ExpressRequest, ExpressResponse, LayerName, LayersFromDeps, NextEndpoint, NextEndpointOptions, NextGetHandler, OnRequestContext, RunEvents, SetupContext, Sink, SinkDef, Skill, SkillDefineContext, SkillInstance, SkillRuntimeOptions, SpawnCallbackContext, SpawnFn, SpawnerBuilder, StreamFactory, UnboundEvent, consoleTracer, consoleTracerLayer, formatSSE, isHttpStreamSink, toSSEStream };
+export { Agent, AgentBinding, AgentFactory, AgentNetwork, AgentNetworkEvent, AgentNetworkEventDef, AnyAgent, AuthResult, Channel, ChannelDef, ChannelName, ConfiguredChannel, ContextEvents, DepedencyLayer, DepedencyLayerDef, Done, EmitPayload$1 as EmitPayload, EnvelopeLike, EventAggregator, EventAggregatorInstance, EventEnvelope$1 as EventEnvelope, EventMeta, EventMetaSchema, EventPlane, ExposeAuthError, ExposeOptions, ExposeRequest, ExposeSelect, ExposedAPI, ExposedStream, ExpressEndpoint, ExpressEndpointOptions, ExpressHandler, ExpressRequest, ExpressResponse, LayerName, LayersFromDeps, NextEndpoint, NextEndpointOptions, NextGetHandler, OnRequestContext, RunEvents, SetupContext, Sink, SinkDef, Skill, SkillDefineContext, SkillInstance, SkillRuntimeOptions, SpawnCallbackContext, SpawnFn, SpawnerBuilder, StreamFactory, UnboundEvent, consoleTracer, consoleTracerLayer, formatSSE, isHttpStreamSink, toSSEStream };

package/dist/matrix/index.js

@@ -501,6 +501,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);
@@ -535,6 +536,9 @@ var AgentNetwork = class _AgentNetwork {
     };
     return binding;
   }
+  registerAggregatorInternal(aggregator) {
+    return this.registerAgentInternal(aggregator);
+  }
   createSpawnerInternal(factoryClass) {
     const reg = {
       factoryClass,
@@ -656,20 +660,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-${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-${randomUUID()}`);
-    __privateSet(this, _listensTo, listensTo ?? []);
+    __privateSet(this, _id2, `agent-${randomUUID()}`);
+    __privateSet(this, _listensTo2, listensTo ?? []);
   }
   getListensTo() {
-    return __privateGet(this, _listensTo);
+    return __privateGet(this, _listensTo2);
   }
   async invoke(options) {
     const { triggerEvent, emit, runEvents, contextEvents } = options ?? {};
@@ -688,13 +782,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 {
@@ -780,12 +874,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) {
@@ -804,6 +897,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;
@@ -910,7 +1012,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.runSync(
@@ -1131,6 +1233,6 @@ var consoleTracerLayer = Layer.setTracer(
   consoleTracer
 );
 
-export { Agent, AgentFactory, AgentNetwork, AgentNetworkEvent, Channel, ChannelName, ConfiguredChannel, DepedencyLayer, EventMetaSchema, ExposeAuthError, ExpressEndpoint, LayerName, NextEndpoint, Sink, Skill, consoleTracer, consoleTracerLayer, formatSSE, isHttpStreamSink, toSSEStream };
+export { Agent, AgentFactory, AgentNetwork, AgentNetworkEvent, Channel, ChannelName, ConfiguredChannel, DepedencyLayer, Done, EventAggregator, EventAggregatorInstance, EventMetaSchema, ExposeAuthError, ExpressEndpoint, LayerName, NextEndpoint, Sink, Skill, consoleTracer, consoleTracerLayer, formatSSE, isHttpStreamSink, toSSEStream };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map