@m4trix/core 0.9.0 → 0.11.0

package/dist/matrix/index.cjs

@@ -151,7 +151,16 @@ var createEventPlane = (options) => effect.Effect.gen(function* () {
   };
   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))
+    effect.Effect.flatMap(() => publishToPubSub(channel, envelope)),
+    effect.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.Effect.sync(() => recordEvent(envelope)).pipe(
     effect.Effect.flatMap(
@@ -160,7 +169,15 @@ var createEventPlane = (options) => effect.Effect.gen(function* () {
         { concurrency: "unbounded" }
       )
     ),
-    effect.Effect.map((results) => results.every(Boolean))
+    effect.Effect.map((results) => results.every(Boolean)),
+    effect.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) => effect.PubSub.subscribe(getPubsub(channel));
   const getRunEvents = (runId, contextId) => {
@@ -193,8 +210,17 @@ var createEventPlane = (options) => effect.Effect.gen(function* () {
     shutdown
   };
 });
-var runSubscriber = (agent, publishesTo, dequeue, plane, emitQueue) => effect.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.Effect.gen(function* () {
   const listensTo = agent.getListensTo?.() ?? [];
+  const agentId = agent.getId();
   const processOne = () => effect.Effect.gen(function* () {
     const envelope = yield* effect.Queue.take(dequeue);
     if (listensTo.length > 0 && !listensTo.includes(envelope.name)) {
@@ -205,34 +231,51 @@ var runSubscriber = (agent, publishesTo, dequeue, plane, emitQueue) => effect.Ef
       envelope.meta.contextId
     );
     const contextEvents = plane.getContextEvents(envelope.meta.contextId);
-    yield* effect.Effect.tryPromise({
-      try: () => agent.invoke({
-        triggerEvent: envelope,
-        emit: (userEvent) => {
-          const fullEnvelope = {
-            name: userEvent.name,
-            meta: envelope.meta,
-            payload: userEvent.payload
-          };
-          if (emitQueue) {
-            effect.Effect.runPromise(
-              effect.Queue.offer(emitQueue, {
-                channels: publishesTo,
-                envelope: fullEnvelope
-              })
-            ).catch(() => {
-            });
-          } else {
-            effect.Effect.runFork(
-              plane.publishToChannels(publishesTo, fullEnvelope)
-            );
-          }
-        },
-        runEvents,
-        contextEvents
-      }),
-      catch: (e) => e
-    });
+    yield* effect.Effect.withSpan("agent.listen", {
+      attributes: {
+        agentId,
+        "event.name": envelope.name,
+        "event.payload": payloadForSpan(envelope.payload),
+        ...channelName !== void 0 && { channel: channelName }
+      }
+    })(
+      effect.Effect.withSpan("agent.invoke", {
+        attributes: {
+          agentId,
+          "event.name": envelope.name,
+          "event.payload": payloadForSpan(envelope.payload)
+        }
+      })(
+        effect.Effect.tryPromise({
+          try: () => agent.invoke({
+            triggerEvent: envelope,
+            emit: (userEvent) => {
+              const fullEnvelope = {
+                name: userEvent.name,
+                meta: envelope.meta,
+                payload: userEvent.payload
+              };
+              if (emitQueue) {
+                effect.Effect.runPromise(
+                  effect.Queue.offer(emitQueue, {
+                    channels: publishesTo,
+                    envelope: fullEnvelope
+                  })
+                ).catch(() => {
+                });
+              } else {
+                effect.Effect.runFork(
+                  plane.publishToChannels(publishesTo, fullEnvelope)
+                );
+              }
+            },
+            runEvents,
+            contextEvents
+          }),
+          catch: (e) => e
+        })
+      )
+    );
   }).pipe(
     effect.Effect.catchAllCause(
       (cause) => effect.Cause.isInterrupted(cause) ? effect.Effect.void : effect.Effect.sync(() => {
@@ -254,7 +297,8 @@ var run = (network, plane, options) => effect.Effect.gen(function* () {
         reg.publishesTo,
         dequeue,
         plane,
-        emitQueue
+        emitQueue,
+        channel.name
       );
     }
   }
@@ -328,7 +372,8 @@ function expose(network, options) {
     select,
     plane: providedPlane,
     onRequest,
-    triggerEvents
+    triggerEvents,
+    tracingLayer
   } = options;
   const triggerEventDef = triggerEvents?.[0];
   const triggerEventName = triggerEventDef?.name ?? "request";
@@ -342,7 +387,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, store: network.getStore() }));
       if (!providedPlane) {
         const emitQueue = yield* effect.Queue.unbounded();
         yield* effect.Effect.fork(
@@ -410,7 +455,8 @@ function expose(network, options) {
       }
       return stream;
     });
-    return effect.Effect.runPromise(program.pipe(effect.Effect.scoped));
+    const runnable = tracingLayer ? program.pipe(effect.Effect.provide(tracingLayer), effect.Effect.scoped) : program.pipe(effect.Effect.scoped);
+    return effect.Effect.runPromise(runnable);
   };
   return {
     protocol: "sse",
@@ -442,6 +488,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) {
@@ -529,6 +576,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
@@ -554,7 +605,11 @@ var AgentNetwork = class _AgentNetwork {
   }
   runScoped(network, capacity) {
     return effect.Effect.gen(function* () {
-      const plane = yield* createEventPlane({ network, capacity });
+      const plane = yield* createEventPlane({
+        network,
+        capacity,
+        store: network.getStore()
+      });
       yield* effect.Effect.fork(run(network, plane));
       return plane;
     });
@@ -712,6 +767,157 @@ var AgentFactory = class _AgentFactory {
     );
   }
 };
+var CAMEL_CASE_REGEX = /^[a-z][a-zA-Z0-9]*$/;
+var LayerName = effect.Brand.refined(
+  (s) => typeof s === "string" && CAMEL_CASE_REGEX.test(s),
+  (s) => effect.Brand.error(`Expected camelCase (e.g. myLayerFoo), got: ${s}`)
+);
+var SkillDependency = {
+  of(config) {
+    const name = LayerName(config.name);
+    const decode = effect.Schema.decodeUnknown(config.shape);
+    return {
+      _tag: "SkillDependencyDef",
+      name,
+      _name: config.name,
+      shape: config.shape,
+      decode
+    };
+  }
+};
+function toLayerArray(layers) {
+  if (layers.length === 1 && Array.isArray(layers[0])) {
+    return layers[0];
+  }
+  return [...layers];
+}
+function assertUniqueLayerNames(layers) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const dep of layers) {
+    const key = dep.name;
+    if (seen.has(key)) {
+      throw new Error(`Duplicate layer name: ${key}`);
+    }
+    seen.add(key);
+  }
+}
+var Skill = class _Skill {
+  constructor(params) {
+    this._inputSchema = params.inputSchema;
+    this._chunkSchema = params.chunkSchema;
+    this._doneSchema = params.doneSchema;
+    this._layers = params.layers;
+    this._defineFn = params.defineFn;
+  }
+  getState() {
+    return {
+      inputSchema: this._inputSchema,
+      chunkSchema: this._chunkSchema,
+      doneSchema: this._doneSchema,
+      layers: this._layers,
+      defineFn: this._defineFn
+    };
+  }
+  static of(_options) {
+    return new _Skill({
+      layers: []
+    });
+  }
+  input(schema) {
+    return new _Skill({
+      ...this.getState(),
+      inputSchema: schema
+    });
+  }
+  chunk(schema) {
+    return new _Skill({
+      ...this.getState(),
+      chunkSchema: schema
+    });
+  }
+  done(schema) {
+    return new _Skill({
+      ...this.getState(),
+      doneSchema: schema
+    });
+  }
+  use(...layers) {
+    const normalized = toLayerArray(layers);
+    const allLayers = [...this._layers, ...normalized];
+    assertUniqueLayerNames(allLayers);
+    return new _Skill({
+      ...this.getState(),
+      layers: allLayers
+    });
+  }
+  define(fn) {
+    const state = this.getState();
+    const inputSchema = state.inputSchema;
+    const chunkSchema = state.chunkSchema;
+    const doneSchema = state.doneSchema;
+    const defineFn = fn;
+    if (!inputSchema || !chunkSchema || !doneSchema || !defineFn) {
+      throw new Error(
+        "Skill.define requires input(), chunk(), and done() to be called before define()"
+      );
+    }
+    const decodeInput = effect.Schema.decodeUnknown(inputSchema);
+    const decodeChunk = effect.Schema.decodeUnknown(chunkSchema);
+    const decodeDone = effect.Schema.decodeUnknown(doneSchema);
+    const runDefine = async (input, runtime) => {
+      const layersObj = runtime?.layers ?? {};
+      const chunks = [];
+      const emit = (chunk) => {
+        const decoded = effect.Effect.runSync(
+          decodeChunk(chunk)
+        );
+        chunks.push(decoded);
+      };
+      const done = await defineFn({
+        input,
+        emit,
+        layers: layersObj
+      });
+      const decodedDone = effect.Effect.runSync(
+        decodeDone(done)
+      );
+      return { chunks, done: decodedDone };
+    };
+    return {
+      invokeStream: async function* (input, runtime) {
+        const decodedInput = effect.Effect.runSync(
+          decodeInput(input)
+        );
+        const layersObj = runtime?.layers ?? {};
+        const chunks = [];
+        const emit = (chunk) => {
+          const decoded = effect.Effect.runSync(
+            decodeChunk(chunk)
+          );
+          chunks.push(decoded);
+        };
+        const done = await defineFn({
+          input: decodedInput,
+          emit,
+          layers: layersObj
+        });
+        const decodedDone = effect.Effect.runSync(
+          decodeDone(done)
+        );
+        for (const c of chunks) {
+          yield c;
+        }
+        yield { _tag: "Done", done: decodedDone };
+      },
+      invoke: async (input, runtime) => {
+        const decodedInput = effect.Effect.runSync(
+          decodeInput(input)
+        );
+        return runDefine(decodedInput, runtime);
+      }
+    };
+  }
+};
 
 // src/matrix/io/protocols/sse.ts
 function formatSSE(envelope) {
@@ -849,6 +1055,78 @@ 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 = 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,
@@ -864,8 +1142,13 @@ exports.ConfiguredChannel = ConfiguredChannel;
 exports.EventMetaSchema = EventMetaSchema;
 exports.ExposeAuthError = ExposeAuthError;
 exports.ExpressEndpoint = ExpressEndpoint;
+exports.LayerName = LayerName;
 exports.NextEndpoint = NextEndpoint;
 exports.Sink = Sink;
+exports.Skill = Skill;
+exports.SkillDependency = SkillDependency;
+exports.consoleTracer = consoleTracer;
+exports.consoleTracerLayer = consoleTracerLayer;
 exports.formatSSE = formatSSE;
 exports.isHttpStreamSink = isHttpStreamSink;
 exports.toSSEStream = toSSEStream;