@m4trix/core 0.8.1 → 0.10.0

package/dist/matrix/index.js

@@ -1,4 +1,4 @@
-import { Brand, Schema, Effect, PubSub, Queue, Cause } from 'effect';
+import { Brand, Schema, Tracer, Layer, Effect, Exit, PubSub, Queue, Cause } from 'effect';
 export { Schema as S } from 'effect';
 import { randomUUID } from 'crypto';
 
@@ -72,8 +72,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.gen(function* () {
+var createEventPlane = (options) => 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()) {
@@ -86,12 +144,59 @@ var createEventPlane = (network, capacity = DEFAULT_CAPACITY) => Effect.gen(func
       throw new Error(`Channel not found: ${channel}`);
     return p;
   };
-  const publish = (channel, envelope) => PubSub.publish(getPubsub(channel), envelope);
-  const publishToChannels = (targetChannels, envelope) => Effect.all(
-    targetChannels.map((c) => publish(c.name, envelope)),
-    { concurrency: "unbounded" }
-  ).pipe(Effect.map((results) => results.every(Boolean)));
+  const recordEvent = (envelope) => {
+    const { contextId, runId } = envelope.meta;
+    store.storeEvent(contextId, runId, envelope);
+  };
+  const publishToPubSub = (channel, envelope) => PubSub.publish(getPubsub(channel), envelope);
+  const publish = (channel, envelope) => Effect.sync(() => recordEvent(envelope)).pipe(
+    Effect.flatMap(() => publishToPubSub(channel, envelope)),
+    Effect.withSpan("event.publish", {
+      attributes: {
+        "event.name": envelope.name,
+        "event.payload": payloadForSpan(envelope.payload),
+        channel,
+        runId: envelope.meta.runId,
+        contextId: envelope.meta.contextId
+      }
+    })
+  );
+  const publishToChannels = (targetChannels, envelope) => Effect.sync(() => recordEvent(envelope)).pipe(
+    Effect.flatMap(
+      () => Effect.all(
+        targetChannels.map((c) => publishToPubSub(c.name, envelope)),
+        { concurrency: "unbounded" }
+      )
+    ),
+    Effect.map((results) => results.every(Boolean)),
+    Effect.withSpan("event.publish", {
+      attributes: {
+        "event.name": envelope.name,
+        "event.payload": payloadForSpan(envelope.payload),
+        runId: envelope.meta.runId,
+        contextId: envelope.meta.contextId
+      }
+    })
+  );
   const subscribe = (channel) => 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.all([...pubsubs.values()].map(PubSub.shutdown), {
     concurrency: "unbounded"
   }).pipe(Effect.asVoid);
@@ -99,42 +204,77 @@ var createEventPlane = (network, capacity = DEFAULT_CAPACITY) => Effect.gen(func
     publish,
     publishToChannels,
     subscribe,
+    getRunEvents,
+    getContextEvents,
     shutdown
   };
 });
-var runSubscriber = (agent, publishesTo, dequeue, plane, emitQueue) => Effect.gen(function* () {
+function payloadForSpan(payload, maxLen = 500) {
+  try {
+    const s = JSON.stringify(payload);
+    return s.length > maxLen ? `${s.slice(0, maxLen)}...` : s;
+  } catch {
+    return String(payload);
+  }
+}
+var runSubscriber = (agent, publishesTo, dequeue, plane, emitQueue, channelName) => Effect.gen(function* () {
   const listensTo = agent.getListensTo?.() ?? [];
+  const agentId = agent.getId();
   const processOne = () => Effect.gen(function* () {
     const envelope = yield* Queue.take(dequeue);
     if (listensTo.length > 0 && !listensTo.includes(envelope.name)) {
       return;
     }
-    yield* Effect.tryPromise({
-      try: () => agent.invoke({
-        triggerEvent: envelope,
-        emit: (userEvent) => {
-          const fullEnvelope = {
-            name: userEvent.name,
-            meta: envelope.meta,
-            payload: userEvent.payload
-          };
-          if (emitQueue) {
-            Effect.runPromise(
-              Queue.offer(emitQueue, {
-                channels: publishesTo,
-                envelope: fullEnvelope
-              })
-            ).catch(() => {
-            });
-          } else {
-            Effect.runFork(
-              plane.publishToChannels(publishesTo, fullEnvelope)
-            );
-          }
+    const runEvents = plane.getRunEvents(
+      envelope.meta.runId,
+      envelope.meta.contextId
+    );
+    const contextEvents = plane.getContextEvents(envelope.meta.contextId);
+    yield* Effect.withSpan("agent.listen", {
+      attributes: {
+        agentId,
+        "event.name": envelope.name,
+        "event.payload": payloadForSpan(envelope.payload),
+        ...channelName !== void 0 && { channel: channelName }
+      }
+    })(
+      Effect.withSpan("agent.invoke", {
+        attributes: {
+          agentId,
+          "event.name": envelope.name,
+          "event.payload": payloadForSpan(envelope.payload)
         }
-      }),
-      catch: (e) => e
-    });
+      })(
+        Effect.tryPromise({
+          try: () => agent.invoke({
+            triggerEvent: envelope,
+            emit: (userEvent) => {
+              const fullEnvelope = {
+                name: userEvent.name,
+                meta: envelope.meta,
+                payload: userEvent.payload
+              };
+              if (emitQueue) {
+                Effect.runPromise(
+                  Queue.offer(emitQueue, {
+                    channels: publishesTo,
+                    envelope: fullEnvelope
+                  })
+                ).catch(() => {
+                });
+              } else {
+                Effect.runFork(
+                  plane.publishToChannels(publishesTo, fullEnvelope)
+                );
+              }
+            },
+            runEvents,
+            contextEvents
+          }),
+          catch: (e) => e
+        })
+      )
+    );
   }).pipe(
     Effect.catchAllCause(
       (cause) => Cause.isInterrupted(cause) ? Effect.void : Effect.sync(() => {
@@ -156,7 +296,8 @@ var run = (network, plane, options) => Effect.gen(function* () {
         reg.publishesTo,
         dequeue,
         plane,
-        emitQueue
+        emitQueue,
+        channel.name
       );
     }
   }
@@ -225,7 +366,16 @@ 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,
+    tracingLayer
+  } = options;
+  const triggerEventDef = triggerEvents?.[0];
+  const triggerEventName = triggerEventDef?.name ?? "request";
   const channels = resolveChannels(network, select);
   const eventFilter = select?.events;
   const mainChannel = network.getMainChannel();
@@ -236,7 +386,7 @@ function expose(network, options) {
     const payload = await extractPayload(req);
     const signal = req.request?.signal;
     const program = Effect.gen(function* () {
-      const plane = providedPlane ?? (yield* createEventPlane(network));
+      const plane = providedPlane ?? (yield* createEventPlane({ network, store: network.getStore() }));
       if (!providedPlane) {
         const emitQueue = yield* Queue.unbounded();
         yield* Effect.fork(
@@ -252,25 +402,46 @@ function expose(network, options) {
         yield* 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.runPromise(plane.publish(targetChannel, envelope)).catch(() => {
-        });
+        Effect.runPromise(plane.publish(targetChannel, envelope)).catch(
+          () => {
+          }
+        );
       };
       const dequeue = yield* plane.subscribe(channels[0]);
       if (onRequest) {
         yield* 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);
@@ -283,7 +454,8 @@ function expose(network, options) {
       }
       return stream;
     });
-    return Effect.runPromise(program.pipe(Effect.scoped));
+    const runnable = tracingLayer ? program.pipe(Effect.provide(tracingLayer), Effect.scoped) : program.pipe(Effect.scoped);
+    return Effect.runPromise(runnable);
   };
   return {
     protocol: "sse",
@@ -315,6 +487,7 @@ var AgentNetwork = class _AgentNetwork {
     this.channels = /* @__PURE__ */ new Map();
     this.agentRegistrations = /* @__PURE__ */ new Map();
     this.spawnerRegistrations = [];
+    this._store = createInMemoryNetworkStore();
   }
   /* ─── Public Static Factory ─── */
   static setup(callback) {
@@ -402,6 +575,10 @@ var AgentNetwork = class _AgentNetwork {
   getSpawnerRegistrations() {
     return this.spawnerRegistrations;
   }
+  /** Store defined at network setup time. Shared across all event planes created for this network. */
+  getStore() {
+    return this._store;
+  }
   /**
    * Expose the network as a streamable API (e.g. SSE). Returns an ExposedAPI
    * that adapters (NextEndpoint, ExpressEndpoint) consume to produce streamed
@@ -409,7 +586,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);
@@ -427,7 +604,11 @@ var AgentNetwork = class _AgentNetwork {
   }
   runScoped(network, capacity) {
     return Effect.gen(function* () {
-      const plane = yield* createEventPlane(network, capacity);
+      const plane = yield* createEventPlane({
+        network,
+        capacity,
+        store: network.getStore()
+      });
       yield* Effect.fork(run(network, plane));
       return plane;
     });
@@ -435,7 +616,7 @@ var AgentNetwork = class _AgentNetwork {
 };
 var EventMetaSchema = Schema.Struct({
   runId: Schema.String,
-  contextId: Schema.optional(Schema.String),
+  contextId: Schema.String,
   correlationId: Schema.optional(Schema.String),
   causationId: Schema.optional(Schema.String),
   ts: Schema.optional(Schema.Number)
@@ -458,9 +639,7 @@ var AgentNetworkEvent = {
     const makeBound = (meta, payload2) => Effect.runSync(
       decodeEnvelope({ name, meta, payload: payload2 })
     );
-    const makeEffect = (payload2) => decodePayload(payload2).pipe(
-      Effect.map((p) => ({ name, payload: p }))
-    );
+    const makeEffect = (payload2) => decodePayload(payload2).pipe(Effect.map((p) => ({ name, payload: p })));
     const makeBoundEffect = (meta, payload2) => decodeEnvelope({ name, meta, payload: payload2 });
     const is = Schema.is(envelopeSchema);
     return {
@@ -493,13 +672,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() {
@@ -612,14 +797,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();
@@ -664,12 +854,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) => {
@@ -678,7 +869,9 @@ var ExpressEndpoint = {
           const exposeReq = {
             request: { signal: controller.signal },
             req,
-            res
+            res,
+            contextId: requestToContextId(req),
+            runId: requestToRunId(req)
           };
           try {
             const encoder = new TextEncoder();
@@ -710,7 +903,79 @@ var ExpressEndpoint = {
     };
   }
 };
+var randomHexString = (length) => {
+  const chars = "abcdef0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+};
+var ConsoleSpan = class {
+  constructor(name, parent, context, links, startTime, kind, depth) {
+    this.name = name;
+    this.parent = parent;
+    this.context = context;
+    this.startTime = startTime;
+    this.kind = kind;
+    this.depth = depth;
+    this._tag = "Span";
+    this.sampled = true;
+    this.attributes = /* @__PURE__ */ new Map();
+    this.links = [];
+    this.traceId = parent._tag === "Some" ? parent.value.traceId : randomHexString(32);
+    this.spanId = randomHexString(16);
+    this.links = Array.from(links);
+    this.status = { _tag: "Started", startTime };
+  }
+  end(endTime, exit) {
+    if (this.status._tag === "Ended")
+      return;
+    const startTime = this.status.startTime;
+    const durationNs = endTime - startTime;
+    const durationMs = Number(durationNs) / 1e6;
+    const indent = "  ".repeat(this.depth);
+    const attrs = Object.fromEntries(this.attributes);
+    const status = Exit.isSuccess(exit) ? "ok" : "error";
+    console.log(
+      `${indent}[trace] ${this.name} ${durationMs.toFixed(2)}ms (${status})`,
+      Object.keys(attrs).length > 0 ? attrs : ""
+    );
+    this.status = { _tag: "Ended", startTime, endTime, exit };
+  }
+  attribute(key, value) {
+    this.attributes.set(key, value);
+  }
+  event(_name, _startTime, _attributes) {
+  }
+  addLinks(links) {
+    this.links.push(...links);
+  }
+};
+function getDepth(parent) {
+  if (parent._tag === "None")
+    return 0;
+  const p = parent.value;
+  if (p._tag === "ExternalSpan")
+    return 0;
+  return 1 + getDepth(p.parent);
+}
+var consoleTracer = Tracer.make({
+  span: (name, parent, context, links, startTime, kind) => new ConsoleSpan(
+    name,
+    parent,
+    context,
+    links,
+    startTime,
+    kind,
+    getDepth(parent)
+  ),
+  context: (f) => f()
+});
+var consoleTracerLayer = Layer.setTracer(
+  consoleTracer
+);
 
-export { Agent, AgentFactory, AgentNetwork, AgentNetworkEvent, Channel, ChannelName, ConfiguredChannel, EventMetaSchema, ExposeAuthError, ExpressEndpoint, NextEndpoint, Sink, formatSSE, isHttpStreamSink, toSSEStream };
+export { Agent, AgentFactory, AgentNetwork, AgentNetworkEvent, Channel, ChannelName, ConfiguredChannel, EventMetaSchema, ExposeAuthError, ExpressEndpoint, NextEndpoint, Sink, consoleTracer, consoleTracerLayer, formatSSE, isHttpStreamSink, toSSEStream };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map