@m4trix/core 0.8.0 → 0.9.0

package/README.md

@@ -1,5 +1,8 @@
 
-[![CircleCI](https://dl.circleci.com/status-badge/img/gh/Pascal-Lohscheidt/build-ai/tree/main.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/Pascal-Lohscheidt/build-ai/tree/main)
+[![CircleCI](https://dl.circleci.com/status-badge/img/gh/Pascal-Lohscheidt/m4trix/tree/main.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/Pascal-Lohscheidt/m4trix/tree/main)
+[![npm version](https://img.shields.io/npm/v/@m4trix%2Fcore)](https://www.npmjs.com/package/@m4trix/core)
+[![npm downloads](https://img.shields.io/npm/dm/@m4trix%2Fcore)](https://www.npmjs.com/package/@m4trix/core)
+[![license](https://img.shields.io/npm/l/@m4trix%2Fcore)](https://www.npmjs.com/package/@m4trix/core)
 
 # @m4trix/core
 

package/dist/index.cjs

@@ -2749,8 +2749,66 @@ var Channel = {
     };
   }
 };
+
+// src/helper/types/noop.ts
+var asyncNoop = async () => {
+};
+
+// src/matrix/agent-network/stores/inmemory-network-store.ts
+var createInMemoryNetworkStore = () => {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    storeEvent: (contextId, runId, event) => {
+      let byRun = store.get(contextId);
+      if (!byRun) {
+        byRun = /* @__PURE__ */ new Map();
+        store.set(contextId, byRun);
+      }
+      let events = byRun.get(runId);
+      if (!events) {
+        events = [];
+        byRun.set(runId, events);
+      }
+      events.push(event);
+    },
+    getEvents: (contextId, runId) => {
+      const events = store.get(contextId)?.get(runId);
+      return events ? [...events] : [];
+    },
+    getContextEvents: (contextId) => {
+      const byRun = store.get(contextId);
+      const result = /* @__PURE__ */ new Map();
+      if (byRun) {
+        for (const [runId, events] of byRun) {
+          result.set(runId, [...events]);
+        }
+      }
+      return result;
+    },
+    getFullStore: () => {
+      const result = /* @__PURE__ */ new Map();
+      for (const [contextId, byRun] of store) {
+        const contextMap = /* @__PURE__ */ new Map();
+        for (const [runId, events] of byRun) {
+          contextMap.set(runId, [...events]);
+        }
+        result.set(contextId, contextMap);
+      }
+      return result;
+    },
+    persist: () => asyncNoop(),
+    load: () => asyncNoop()
+  };
+};
+
+// src/matrix/agent-network/event-plane.ts
 var DEFAULT_CAPACITY = 16;
-var createEventPlane = (network, capacity = DEFAULT_CAPACITY) => effect.Effect.gen(function* () {
+var createEventPlane = (options) => effect.Effect.gen(function* () {
+  const {
+    network,
+    capacity = DEFAULT_CAPACITY,
+    store = createInMemoryNetworkStore()
+  } = options;
   const channels = network.getChannels();
   const pubsubs = /* @__PURE__ */ new Map();
   for (const channel of channels.values()) {
@@ -2763,12 +2821,42 @@ var createEventPlane = (network, capacity = DEFAULT_CAPACITY) => effect.Effect.g
       throw new Error(`Channel not found: ${channel}`);
     return p;
   };
-  const publish = (channel, envelope) => effect.PubSub.publish(getPubsub(channel), envelope);
-  const publishToChannels = (targetChannels, envelope) => effect.Effect.all(
-    targetChannels.map((c) => publish(c.name, envelope)),
-    { concurrency: "unbounded" }
-  ).pipe(effect.Effect.map((results) => results.every(Boolean)));
+  const recordEvent = (envelope) => {
+    const { contextId, runId } = envelope.meta;
+    store.storeEvent(contextId, runId, envelope);
+  };
+  const publishToPubSub = (channel, envelope) => effect.PubSub.publish(getPubsub(channel), envelope);
+  const publish = (channel, envelope) => effect.Effect.sync(() => recordEvent(envelope)).pipe(
+    effect.Effect.flatMap(() => publishToPubSub(channel, envelope))
+  );
+  const publishToChannels = (targetChannels, envelope) => effect.Effect.sync(() => recordEvent(envelope)).pipe(
+    effect.Effect.flatMap(
+      () => effect.Effect.all(
+        targetChannels.map((c) => publishToPubSub(c.name, envelope)),
+        { concurrency: "unbounded" }
+      )
+    ),
+    effect.Effect.map((results) => results.every(Boolean))
+  );
   const subscribe = (channel) => effect.PubSub.subscribe(getPubsub(channel));
+  const getRunEvents = (runId, contextId) => {
+    return store.getEvents(contextId, runId).slice();
+  };
+  const getContextEvents = (contextId) => {
+    const byRun = store.getContextEvents(contextId);
+    const map = /* @__PURE__ */ new Map();
+    const all = [];
+    for (const [runId, events] of byRun) {
+      const readonlyEvents = events.slice();
+      map.set(runId, readonlyEvents);
+      all.push(...readonlyEvents);
+    }
+    return {
+      all,
+      byRun: (runId) => map.get(runId) ?? [],
+      map
+    };
+  };
   const shutdown = effect.Effect.all([...pubsubs.values()].map(effect.PubSub.shutdown), {
     concurrency: "unbounded"
   }).pipe(effect.Effect.asVoid);
@@ -2776,6 +2864,8 @@ var createEventPlane = (network, capacity = DEFAULT_CAPACITY) => effect.Effect.g
     publish,
     publishToChannels,
     subscribe,
+    getRunEvents,
+    getContextEvents,
     shutdown
   };
 });
@@ -2786,6 +2876,11 @@ var runSubscriber = (agent, publishesTo, dequeue, plane, emitQueue) => effect.Ef
     if (listensTo.length > 0 && !listensTo.includes(envelope.name)) {
       return;
     }
+    const runEvents = plane.getRunEvents(
+      envelope.meta.runId,
+      envelope.meta.contextId
+    );
+    const contextEvents = plane.getContextEvents(envelope.meta.contextId);
     yield* effect.Effect.tryPromise({
       try: () => agent.invoke({
         triggerEvent: envelope,
@@ -2808,7 +2903,9 @@ var runSubscriber = (agent, publishesTo, dequeue, plane, emitQueue) => effect.Ef
               plane.publishToChannels(publishesTo, fullEnvelope)
             );
           }
-        }
+        },
+        runEvents,
+        contextEvents
       }),
       catch: (e) => e
     });
@@ -2902,7 +2999,15 @@ function streamFromDequeue(take, signal, eventFilter) {
   };
 }
 function expose(network, options) {
-  const { auth, select, plane: providedPlane, onRequest, startEventName = "request" } = options;
+  const {
+    auth,
+    select,
+    plane: providedPlane,
+    onRequest,
+    triggerEvents
+  } = options;
+  const triggerEventDef = triggerEvents?.[0];
+  const triggerEventName = triggerEventDef?.name ?? "request";
   const channels = resolveChannels(network, select);
   const eventFilter = select?.events;
   const mainChannel = network.getMainChannel();
@@ -2913,7 +3018,7 @@ function expose(network, options) {
     const payload = await extractPayload(req);
     const signal = req.request?.signal;
     const program = effect.Effect.gen(function* () {
-      const plane = providedPlane ?? (yield* createEventPlane(network));
+      const plane = providedPlane ?? (yield* createEventPlane({ network }));
       if (!providedPlane) {
         const emitQueue = yield* effect.Queue.unbounded();
         yield* effect.Effect.fork(
@@ -2929,25 +3034,46 @@ function expose(network, options) {
         yield* effect.Effect.sleep("10 millis");
       }
       const targetChannel = mainChannel?.name ?? channels[0];
-      const emitStartEvent = (p) => {
-        const pld = p ?? payload;
+      let runId = req.runId ?? crypto.randomUUID();
+      let contextId = req.contextId ?? crypto.randomUUID();
+      const setRunId = (id) => {
+        runId = id;
+      };
+      const setContextId = (id) => {
+        contextId = id;
+      };
+      const emitStartEvent = (opts) => {
+        const meta = {
+          runId: opts.runId,
+          contextId: opts.contextId
+        };
         const envelope = {
-          name: startEventName,
-          meta: { runId: crypto.randomUUID() },
-          payload: pld
+          name: opts.event.name,
+          meta,
+          payload: opts.event.payload
         };
-        effect.Effect.runPromise(plane.publish(targetChannel, envelope)).catch(() => {
-        });
+        effect.Effect.runPromise(plane.publish(targetChannel, envelope)).catch(
+          () => {
+          }
+        );
       };
       const dequeue = yield* plane.subscribe(channels[0]);
       if (onRequest) {
         yield* effect.Effect.tryPromise(
-          () => Promise.resolve(onRequest({ emitStartEvent, req, payload }))
+          () => Promise.resolve(
+            onRequest({
+              setRunId,
+              setContextId,
+              emitStartEvent,
+              req,
+              payload
+            })
+          )
         );
       } else if (!providedPlane) {
         const envelope = {
-          name: startEventName,
-          meta: { runId: crypto.randomUUID() },
+          name: triggerEventName,
+          meta: { runId, contextId },
           payload
         };
         yield* plane.publish(targetChannel, envelope);
@@ -3086,7 +3212,7 @@ var AgentNetwork = class _AgentNetwork {
    *
    * @example
    * const api = network.expose({ protocol: "sse", auth, select });
-   * export const GET = NextEndpoint.from(api).handler();
+   * export const GET = NextEndpoint.from(api, { requestToContextId, requestToRunId }).handler();
    */
   expose(options) {
     return expose(this, options);
@@ -3104,7 +3230,7 @@ var AgentNetwork = class _AgentNetwork {
   }
   runScoped(network, capacity) {
     return effect.Effect.gen(function* () {
-      const plane = yield* createEventPlane(network, capacity);
+      const plane = yield* createEventPlane({ network, capacity });
       yield* effect.Effect.fork(run(network, plane));
       return plane;
     });
@@ -3112,7 +3238,7 @@ var AgentNetwork = class _AgentNetwork {
 };
 var EventMetaSchema = effect.Schema.Struct({
   runId: effect.Schema.String,
-  contextId: effect.Schema.optional(effect.Schema.String),
+  contextId: effect.Schema.String,
   correlationId: effect.Schema.optional(effect.Schema.String),
   causationId: effect.Schema.optional(effect.Schema.String),
   ts: effect.Schema.optional(effect.Schema.Number)
@@ -3135,9 +3261,7 @@ var AgentNetworkEvent = {
     const makeBound = (meta, payload2) => effect.Effect.runSync(
       decodeEnvelope({ name, meta, payload: payload2 })
     );
-    const makeEffect = (payload2) => decodePayload(payload2).pipe(
-      effect.Effect.map((p) => ({ name, payload: p }))
-    );
+    const makeEffect = (payload2) => decodePayload(payload2).pipe(effect.Effect.map((p) => ({ name, payload: p })));
     const makeBoundEffect = (meta, payload2) => decodeEnvelope({ name, meta, payload: payload2 });
     const is = effect.Schema.is(envelopeSchema);
     return {
@@ -3170,13 +3294,19 @@ var Agent = class {
     return __privateGet(this, _listensTo);
   }
   async invoke(options) {
-    const { triggerEvent, emit } = options ?? {};
+    const { triggerEvent, emit, runEvents, contextEvents } = options ?? {};
     const emitFn = emit ?? ((_event) => {
     });
     await __privateGet(this, _logic).call(this, {
       params: __privateGet(this, _params),
       triggerEvent: triggerEvent ?? void 0,
-      emit: emitFn
+      emit: emitFn,
+      runEvents: runEvents ?? [],
+      contextEvents: contextEvents ?? {
+        all: [],
+        byRun: () => [],
+        map: /* @__PURE__ */ new Map()
+      }
     });
   }
   getId() {
@@ -3289,14 +3419,19 @@ function toSSEStream(source, signal) {
 
 // src/matrix/io/adapters/next-endpoint.ts
 var NextEndpoint = {
-  from(api) {
+  from(api, options) {
     if (api.protocol !== "sse") {
       throw new Error(`NextEndpoint: unsupported protocol "${api.protocol}"`);
     }
+    const { requestToContextId, requestToRunId } = options;
     return {
       handler() {
         return async (request) => {
-          const req = { request };
+          const req = {
+            request,
+            contextId: requestToContextId(request),
+            runId: requestToRunId(request)
+          };
           try {
             const encoder = new TextEncoder();
             const { readable, writable } = new TransformStream();
@@ -3341,12 +3476,13 @@ var NextEndpoint = {
 
 // src/matrix/io/adapters/express-endpoint.ts
 var ExpressEndpoint = {
-  from(api) {
+  from(api, options) {
     if (api.protocol !== "sse") {
       throw new Error(
         `ExpressEndpoint: unsupported protocol "${api.protocol}"`
       );
     }
+    const { requestToContextId, requestToRunId } = options;
     return {
       handler() {
         return async (req, res) => {
@@ -3355,7 +3491,9 @@ var ExpressEndpoint = {
           const exposeReq = {
             request: { signal: controller.signal },
             req,
-            res
+            res,
+            contextId: requestToContextId(req),
+            runId: requestToRunId(req)
           };
           try {
             const encoder = new TextEncoder();