@m4trix/core 0.15.1 → 0.16.0

package/dist/matrix/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var effect = require('effect');
 var crypto$1 = require('crypto');
+var effect = require('effect');
 
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
@@ -21,56 +21,114 @@ var __privateSet = (obj, member, value, setter) => {
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
-var KEBAB_CASE_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
-var ChannelName = effect.Brand.refined(
-  (s) => typeof s === "string" && KEBAB_CASE_REGEX.test(s),
-  (s) => effect.Brand.error(`Expected kebab-case (e.g. my-channel-name), got: ${s}`)
-);
-
-// src/matrix/agent-network/channel.ts
-var Sink = {
-  kafka(config) {
-    return { _tag: "SinkDef", type: "kafka", config };
-  },
-  httpStream() {
-    return { _tag: "SinkDef", type: "http-stream", config: {} };
+var _params, _logic, _id, _listensTo;
+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);
+    __privateSet(this, _logic, logic);
+    __privateSet(this, _params, params);
+    __privateSet(this, _id, `agent-${crypto$1.randomUUID()}`);
+    __privateSet(this, _listensTo, listensTo ?? []);
+  }
+  getListensTo() {
+    return __privateGet(this, _listensTo);
+  }
+  async invoke(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,
+      runEvents: runEvents ?? [],
+      contextEvents: contextEvents ?? {
+        all: [],
+        byRun: () => [],
+        map: /* @__PURE__ */ new Map()
+      }
+    });
+  }
+  getId() {
+    return __privateGet(this, _id);
   }
 };
-function isHttpStreamSink(sink) {
-  return sink.type === "http-stream";
-}
-var ConfiguredChannel = class {
-  constructor(name) {
-    this._tag = "ConfiguredChannel";
-    this._events = [];
-    this._sinks = [];
-    this.name = name;
+_params = new WeakMap();
+_logic = new WeakMap();
+_id = new WeakMap();
+_listensTo = new WeakMap();
+
+// src/matrix/agent-factory.ts
+var AgentFactory = class _AgentFactory {
+  constructor({
+    logic,
+    paramsSchema,
+    listensTo = [],
+    emits = []
+  }) {
+    this._logic = logic;
+    this._paramsSchema = paramsSchema;
+    this._listensTo = listensTo;
+    this._emits = emits;
   }
-  events(events) {
-    this._events = [...events];
-    return this;
+  getConstructorState() {
+    return {
+      logic: this._logic,
+      paramsSchema: this._paramsSchema,
+      listensTo: this._listensTo,
+      emits: this._emits
+    };
   }
-  sink(sink) {
-    this._sinks = [...this._sinks, sink];
-    return this;
+  /** Union of all event definitions this agent listens to */
+  getListensTo() {
+    return this._listensTo;
   }
-  sinks(sinks) {
-    this._sinks = [...sinks];
-    return this;
+  /** Union of all event definitions this agent can emit */
+  getEmits() {
+    return this._emits;
   }
-  getEvents() {
-    return this._events;
+  getLogic() {
+    return this._logic;
   }
-  getSinks() {
-    return this._sinks;
+  static run() {
+    return new _AgentFactory({});
   }
-};
-var Channel = {
-  of(name) {
-    return {
-      _tag: "ChannelDef",
-      name
-    };
+  params(params) {
+    const { logic, ...rest } = this.getConstructorState();
+    return new _AgentFactory({
+      ...rest,
+      logic,
+      paramsSchema: params
+    });
+  }
+  listensTo(events) {
+    return new _AgentFactory({
+      ...this.getConstructorState(),
+      listensTo: [...this._listensTo, ...events]
+    });
+  }
+  emits(events) {
+    return new _AgentFactory({
+      ...this.getConstructorState(),
+      emits: [...this._emits, ...events]
+    });
+  }
+  logic(fn) {
+    return new _AgentFactory({
+      ...this.getConstructorState(),
+      logic: fn
+    });
+  }
+  produce(params) {
+    const listensTo = this._listensTo.map((e) => e.name);
+    return new Agent(
+      this._logic,
+      params,
+      listensTo
+    );
   }
 };
 
@@ -292,6 +350,60 @@ var run = (network, plane, options) => effect.Effect.gen(function* () {
   }
   yield* effect.Effect.never;
 });
+var KEBAB_CASE_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var ChannelName = effect.Brand.refined(
+  (s) => typeof s === "string" && KEBAB_CASE_REGEX.test(s),
+  (s) => effect.Brand.error(`Expected kebab-case (e.g. my-channel-name), got: ${s}`)
+);
+
+// src/matrix/agent-network/channel.ts
+var Sink = {
+  kafka(config) {
+    return { _tag: "SinkDef", type: "kafka", config };
+  },
+  httpStream() {
+    return { _tag: "SinkDef", type: "http-stream", config: {} };
+  }
+};
+function isHttpStreamSink(sink) {
+  return sink.type === "http-stream";
+}
+var ConfiguredChannel = class {
+  constructor(name) {
+    this._tag = "ConfiguredChannel";
+    this._events = [];
+    this._sinks = [];
+    this.name = name;
+  }
+  events(events) {
+    this._events = [...events];
+    return this;
+  }
+  sink(sink) {
+    this._sinks = [...this._sinks, sink];
+    return this;
+  }
+  sinks(sinks) {
+    this._sinks = [...sinks];
+    return this;
+  }
+  getEvents() {
+    return this._events;
+  }
+  getSinks() {
+    return this._sinks;
+  }
+};
+var Channel = {
+  of(name) {
+    return {
+      _tag: "ChannelDef",
+      name
+    };
+  }
+};
+
+// src/matrix/io/expose.ts
 async function extractPayload(req) {
   const webRequest = req.request;
   if (webRequest?.method === "POST") {
@@ -469,12 +581,10 @@ var AgentNetwork = class _AgentNetwork {
   /* ─── Public Static Factory ─── */
   static setup(callback) {
     const network = new _AgentNetwork();
+    const mainChannel = network.addChannel("main");
+    network.setMainChannel(mainChannel);
     const ctx = {
-      mainChannel: (name) => {
-        const channel = network.addChannel(name);
-        network.setMainChannel(channel);
-        return channel;
-      },
+      mainChannel,
       createChannel: (name) => network.addChannel(name),
       sink: Sink,
       registerAgent: (agent) => network.registerAgentInternal(agent),
@@ -487,6 +597,10 @@ var AgentNetwork = class _AgentNetwork {
   /* ─── Internal Builders ─── */
   addChannel(name) {
     const channelName = ChannelName(name);
+    const existing = this.channels.get(channelName);
+    if (existing) {
+      return existing;
+    }
     const channel = new ConfiguredChannel(channelName);
     this.channels.set(channelName, channel);
     return channel;
@@ -674,27 +788,27 @@ var EventAggregator = class _EventAggregator {
     });
   }
 };
-var _id, _listensTo, _emitWhen, _mapToEmit;
+var _id2, _listensTo2, _emitWhen, _mapToEmit;
 var EventAggregatorInstance = class {
   constructor({
     listensTo,
     emitWhen,
     mapToEmit
   }) {
-    __privateAdd(this, _id, void 0);
-    __privateAdd(this, _listensTo, void 0);
+    __privateAdd(this, _id2, void 0);
+    __privateAdd(this, _listensTo2, 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, _id2, `event-aggregator-${crypto$1.randomUUID()}`);
+    __privateSet(this, _listensTo2, listensTo);
     __privateSet(this, _emitWhen, emitWhen);
     __privateSet(this, _mapToEmit, mapToEmit);
   }
   getId() {
-    return __privateGet(this, _id);
+    return __privateGet(this, _id2);
   }
   getListensTo() {
-    return __privateGet(this, _listensTo);
+    return __privateGet(this, _listensTo2);
   }
   async invoke(options) {
     const { triggerEvent, emit, runEvents, contextEvents } = options ?? {};
@@ -725,118 +839,205 @@ var EventAggregatorInstance = class {
     });
   }
 };
-_id = new WeakMap();
-_listensTo = new WeakMap();
+_id2 = new WeakMap();
+_listensTo2 = 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, _id2, void 0);
-    __privateAdd(this, _listensTo2, void 0);
-    __privateSet(this, _logic, logic);
-    __privateSet(this, _params, params);
-    __privateSet(this, _id2, `agent-${crypto$1.randomUUID()}`);
-    __privateSet(this, _listensTo2, listensTo ?? []);
-  }
-  getListensTo() {
-    return __privateGet(this, _listensTo2);
-  }
-  async invoke(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,
-      runEvents: runEvents ?? [],
-      contextEvents: contextEvents ?? {
-        all: [],
-        byRun: () => [],
-        map: /* @__PURE__ */ new Map()
-      }
-    });
-  }
-  getId() {
-    return __privateGet(this, _id2);
+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;
 };
-_params = new WeakMap();
-_logic = new WeakMap();
-_id2 = new WeakMap();
-_listensTo2 = new WeakMap();
-
-// src/matrix/agent-factory.ts
-var AgentFactory = class _AgentFactory {
-  constructor({
-    logic,
-    paramsSchema,
-    listensTo = [],
-    emits = []
-  }) {
-    this._logic = logic;
-    this._paramsSchema = paramsSchema;
-    this._listensTo = listensTo;
-    this._emits = emits;
-  }
-  getConstructorState() {
-    return {
-      logic: this._logic,
-      paramsSchema: this._paramsSchema,
-      listensTo: this._listensTo,
-      emits: this._emits
-    };
-  }
-  /** Union of all event definitions this agent listens to */
-  getListensTo() {
-    return this._listensTo;
-  }
-  /** Union of all event definitions this agent can emit */
-  getEmits() {
-    return this._emits;
-  }
-  getLogic() {
-    return this._logic;
+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 };
   }
-  static run() {
-    return new _AgentFactory({});
+  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 = effect.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 };
   }
-  params(params) {
-    const { logic, ...rest } = this.getConstructorState();
-    return new _AgentFactory({
-      ...rest,
-      logic,
-      paramsSchema: params
-    });
+  attribute(key, value) {
+    this.attributes.set(key, value);
   }
-  listensTo(events) {
-    return new _AgentFactory({
-      ...this.getConstructorState(),
-      listensTo: [...this._listensTo, ...events]
-    });
+  event(_name, _startTime, _attributes) {
   }
-  emits(events) {
-    return new _AgentFactory({
-      ...this.getConstructorState(),
-      emits: [...this._emits, ...events]
-    });
+  addLinks(links) {
+    this.links.push(...links);
   }
-  logic(fn) {
-    return new _AgentFactory({
-      ...this.getConstructorState(),
-      logic: fn
-    });
+};
+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 = effect.Tracer.make({
+  span: (name, parent, context, links, startTime, kind) => new ConsoleSpan(name, parent, context, links, startTime, kind, getDepth(parent)),
+  context: (f) => f()
+});
+var consoleTracerLayer = effect.Layer.setTracer(consoleTracer);
+
+// src/matrix/io/protocols/sse.ts
+function formatSSE(envelope) {
+  const data = JSON.stringify(envelope);
+  return `event: ${envelope.name}
+data: ${data}
+
+`;
+}
+function toSSEStream(source, signal) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      const onAbort = () => controller.close();
+      signal?.addEventListener("abort", onAbort, { once: true });
+      try {
+        for await (const envelope of source) {
+          if (signal?.aborted)
+            break;
+          controller.enqueue(encoder.encode(formatSSE(envelope)));
+        }
+      } finally {
+        signal?.removeEventListener("abort", onAbort);
+        controller.close();
+      }
+    }
+  });
+}
+
+// src/matrix/io/adapters/next-endpoint.ts
+var NextEndpoint = {
+  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,
+            contextId: requestToContextId(request),
+            runId: requestToRunId(request)
+          };
+          try {
+            const encoder = new TextEncoder();
+            const { readable, writable } = new TransformStream();
+            let consumerStarted;
+            const started = new Promise((resolve) => {
+              consumerStarted = resolve;
+            });
+            const streamDone = api.createStream(req, async (stream) => {
+              consumerStarted();
+              const writer = writable.getWriter();
+              try {
+                for await (const envelope of stream) {
+                  if (request.signal?.aborted)
+                    break;
+                  await writer.write(encoder.encode(formatSSE(envelope)));
+                }
+              } finally {
+                await writer.close();
+              }
+            });
+            await Promise.race([started, streamDone]);
+            streamDone.catch(() => {
+            });
+            return new Response(readable, {
+              headers: {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive"
+              }
+            });
+          } catch (e) {
+            if (e instanceof ExposeAuthError) {
+              return new Response(e.message, { status: e.status });
+            }
+            throw e;
+          }
+        };
+      }
+    };
   }
-  produce(params) {
-    const listensTo = this._listensTo.map((e) => e.name);
-    return new Agent(
-      this._logic,
-      params,
-      listensTo
-    );
+};
+
+// src/matrix/io/adapters/express-endpoint.ts
+var ExpressEndpoint = {
+  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) => {
+          const controller = new AbortController();
+          req.on("close", () => controller.abort());
+          const exposeReq = {
+            request: { signal: controller.signal },
+            req,
+            res,
+            contextId: requestToContextId(req),
+            runId: requestToRunId(req)
+          };
+          try {
+            const encoder = new TextEncoder();
+            await api.createStream(exposeReq, async (stream) => {
+              res.setHeader("Content-Type", "text/event-stream");
+              res.setHeader("Cache-Control", "no-cache");
+              res.setHeader("Connection", "keep-alive");
+              res.flushHeaders?.();
+              try {
+                for await (const envelope of stream) {
+                  if (controller.signal.aborted)
+                    break;
+                  res.write(encoder.encode(formatSSE(envelope)));
+                  res.flush?.();
+                }
+              } finally {
+                res.end();
+              }
+            });
+          } catch (e) {
+            if (e instanceof ExposeAuthError) {
+              res.status(e.status).send(e.message);
+              return;
+            }
+            throw e;
+          }
+        };
+      }
+    };
   }
 };
 var CAMEL_CASE_REGEX = /^[a-z][a-zA-Z0-9]*$/;
@@ -995,203 +1196,6 @@ var Skill = class _Skill {
   }
 };
 
-// src/matrix/io/protocols/sse.ts
-function formatSSE(envelope) {
-  const data = JSON.stringify(envelope);
-  return `event: ${envelope.name}
-data: ${data}
-
-`;
-}
-function toSSEStream(source, signal) {
-  const encoder = new TextEncoder();
-  return new ReadableStream({
-    async start(controller) {
-      const onAbort = () => controller.close();
-      signal?.addEventListener("abort", onAbort, { once: true });
-      try {
-        for await (const envelope of source) {
-          if (signal?.aborted)
-            break;
-          controller.enqueue(encoder.encode(formatSSE(envelope)));
-        }
-      } finally {
-        signal?.removeEventListener("abort", onAbort);
-        controller.close();
-      }
-    }
-  });
-}
-
-// src/matrix/io/adapters/next-endpoint.ts
-var NextEndpoint = {
-  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,
-            contextId: requestToContextId(request),
-            runId: requestToRunId(request)
-          };
-          try {
-            const encoder = new TextEncoder();
-            const { readable, writable } = new TransformStream();
-            let consumerStarted;
-            const started = new Promise((resolve) => {
-              consumerStarted = resolve;
-            });
-            const streamDone = api.createStream(req, async (stream) => {
-              consumerStarted();
-              const writer = writable.getWriter();
-              try {
-                for await (const envelope of stream) {
-                  if (request.signal?.aborted)
-                    break;
-                  await writer.write(encoder.encode(formatSSE(envelope)));
-                }
-              } finally {
-                await writer.close();
-              }
-            });
-            await Promise.race([started, streamDone]);
-            streamDone.catch(() => {
-            });
-            return new Response(readable, {
-              headers: {
-                "Content-Type": "text/event-stream",
-                "Cache-Control": "no-cache",
-                Connection: "keep-alive"
-              }
-            });
-          } catch (e) {
-            if (e instanceof ExposeAuthError) {
-              return new Response(e.message, { status: e.status });
-            }
-            throw e;
-          }
-        };
-      }
-    };
-  }
-};
-
-// src/matrix/io/adapters/express-endpoint.ts
-var ExpressEndpoint = {
-  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) => {
-          const controller = new AbortController();
-          req.on("close", () => controller.abort());
-          const exposeReq = {
-            request: { signal: controller.signal },
-            req,
-            res,
-            contextId: requestToContextId(req),
-            runId: requestToRunId(req)
-          };
-          try {
-            const encoder = new TextEncoder();
-            await api.createStream(exposeReq, async (stream) => {
-              res.setHeader("Content-Type", "text/event-stream");
-              res.setHeader("Cache-Control", "no-cache");
-              res.setHeader("Connection", "keep-alive");
-              res.flushHeaders?.();
-              try {
-                for await (const envelope of stream) {
-                  if (controller.signal.aborted)
-                    break;
-                  res.write(encoder.encode(formatSSE(envelope)));
-                  res.flush?.();
-                }
-              } finally {
-                res.end();
-              }
-            });
-          } catch (e) {
-            if (e instanceof ExposeAuthError) {
-              res.status(e.status).send(e.message);
-              return;
-            }
-            throw e;
-          }
-        };
-      }
-    };
-  }
-};
-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 = effect.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 = effect.Tracer.make({
-  span: (name, parent, context, links, startTime, kind) => new ConsoleSpan(name, parent, context, links, startTime, kind, getDepth(parent)),
-  context: (f) => f()
-});
-var consoleTracerLayer = effect.Layer.setTracer(consoleTracer);
-
 Object.defineProperty(exports, 'S', {
   enumerable: true,
   get: function () { return effect.Schema; }