@m4trix/core 0.5.0 → 0.7.0

package/dist/index.cjs

@@ -8,6 +8,7 @@ var ref_js = require('lit/directives/ref.js');
 var animejs = require('animejs');
 var messages = require('@langchain/core/messages');
 var effect = require('effect');
+var crypto$1 = require('crypto');
 
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -20,6 +21,24 @@ var __decorateClass = (decorators, target, key, kind) => {
     __defProp(target, key, result);
   return result;
 };
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
 
 // src/utility/Logger.ts
 var _Logger = class _Logger {
@@ -2615,55 +2634,790 @@ var TransformMessages = class _TransformMessages {
    * Format messages according to the specified format type
    */
   format(formatType) {
-    return effect.pipe(
-      this.effect,
-      effect.Effect.map((messages) => {
-        if (formatType === "json" /* JSON */) {
-          return JSON.stringify(messages, null, 2);
-        }
-        const formatter = typeOnFormatter[formatType];
-        return formatter(messages);
-      })
+    const result = effect.Effect.runSync(
+      effect.pipe(
+        this.effect,
+        effect.Effect.map((messages) => {
+          if (formatType === "json" /* JSON */) {
+            return JSON.stringify(messages, null, 2);
+          }
+          const formatter = typeOnFormatter[formatType];
+          return formatter(messages);
+        })
+      )
     );
+    return result;
   }
   // Sink methods
   /**
-   * Convert to array - runs the effect and returns the result
-   */
+     * Convert to array - runs the effect and returns the result
+      return pipe(
+        this.effect,
+        Effect.map((messages) => {
+          if (formatType === FormatType.JSON) {
+            return JSON.stringify(messages, null, 2);
+          }
+  
+          const formatter = typeOnFormatter[formatType];
+          return formatter(messages);
+        })
+      );
+    }
+  
+    // Sink methods
+  
+    /**
+     * Convert to array - runs the effect and returns the result
+     */
   toArray() {
-    return this.effect;
+    return effect.Effect.runSync(this.effect);
   }
   /**
    * Convert to string - runs the effect and returns JSON string
    */
   toString() {
-    return effect.pipe(
-      this.effect,
-      effect.Effect.map((messages) => JSON.stringify(messages, null, 2))
+    const result = effect.Effect.runSync(
+      effect.pipe(
+        this.effect,
+        effect.Effect.map((messages) => JSON.stringify(messages, null, 2))
+      )
     );
+    return result;
   }
   /**
    * Get the count of messages
    */
   count() {
-    return effect.pipe(
-      this.effect,
-      effect.Effect.map((messages) => messages.length)
+    const result = effect.Effect.runSync(
+      effect.pipe(
+        this.effect,
+        effect.Effect.map((messages) => messages.length)
+      )
     );
+    return result;
+  }
+};
+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
+    };
+  }
+};
+var DEFAULT_CAPACITY = 16;
+var createEventPlane = (network, capacity = DEFAULT_CAPACITY) => effect.Effect.gen(function* () {
+  const channels = network.getChannels();
+  const pubsubs = /* @__PURE__ */ new Map();
+  for (const channel of channels.values()) {
+    const pubsub = yield* effect.PubSub.bounded(capacity);
+    pubsubs.set(channel.name, pubsub);
+  }
+  const getPubsub = (channel) => {
+    const p = pubsubs.get(channel);
+    if (!p)
+      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 subscribe = (channel) => effect.PubSub.subscribe(getPubsub(channel));
+  const shutdown = effect.Effect.all([...pubsubs.values()].map(effect.PubSub.shutdown), {
+    concurrency: "unbounded"
+  }).pipe(effect.Effect.asVoid);
+  return {
+    publish,
+    publishToChannels,
+    subscribe,
+    shutdown
+  };
+});
+var runSubscriber = (agent, publishesTo, dequeue, plane, emitQueue) => effect.Effect.gen(function* () {
+  const listensTo = agent.getListensTo?.() ?? [];
+  const processOne = () => effect.Effect.gen(function* () {
+    const envelope = yield* effect.Queue.take(dequeue);
+    if (listensTo.length > 0 && !listensTo.includes(envelope.name)) {
+      return;
+    }
+    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)
+            );
+          }
+        }
+      }),
+      catch: (e) => e
+    });
+  }).pipe(
+    effect.Effect.catchAllCause(
+      (cause) => effect.Cause.isInterrupted(cause) ? effect.Effect.void : effect.Effect.sync(() => {
+        console.error(`Agent ${agent.getId()} failed:`, cause);
+      }).pipe(effect.Effect.asVoid)
+    )
+  );
+  const loop = () => processOne().pipe(effect.Effect.flatMap(() => loop()));
+  return yield* effect.Effect.fork(loop());
+});
+var run = (network, plane, options) => effect.Effect.gen(function* () {
+  const registrations = network.getAgentRegistrations();
+  const emitQueue = options?.emitQueue;
+  for (const reg of registrations.values()) {
+    for (const channel of reg.subscribedTo) {
+      const dequeue = yield* plane.subscribe(channel.name);
+      yield* runSubscriber(
+        reg.agent,
+        reg.publishesTo,
+        dequeue,
+        plane,
+        emitQueue
+      );
+    }
+  }
+  yield* effect.Effect.never;
+});
+async function extractPayload(req) {
+  const webRequest = req.request;
+  if (webRequest?.method === "POST") {
+    const ct = webRequest.headers?.get?.("content-type") ?? "";
+    if (ct.includes("application/json")) {
+      try {
+        return await webRequest.json();
+      } catch {
+        return {};
+      }
+    }
+  }
+  const expressReq = req.req;
+  if (expressReq?.body != null) {
+    return expressReq.body;
+  }
+  return {};
+}
+function resolveChannels(network, select) {
+  const channels = network.getChannels();
+  if (select?.channels) {
+    const ch = select.channels;
+    const arr = Array.isArray(ch) ? ch : [ch];
+    return arr.map((c) => ChannelName(c));
+  }
+  const httpStreamChannels = [...channels.values()].filter((ch) => ch.getSinks().some(isHttpStreamSink)).map((ch) => ch.name);
+  if (httpStreamChannels.length > 0)
+    return httpStreamChannels;
+  const client = channels.get("client");
+  if (client)
+    return [client.name];
+  const first = channels.values().next().value;
+  return first ? [first.name] : [];
+}
+function streamFromDequeue(take, signal, eventFilter) {
+  const shouldInclude = (e) => !eventFilter?.length || eventFilter.includes(e.name);
+  return {
+    async *[Symbol.asyncIterator]() {
+      while (!signal?.aborted) {
+        const takePromise = take();
+        const abortPromise = signal ? new Promise((_, reject) => {
+          signal.addEventListener(
+            "abort",
+            () => reject(new DOMException("Aborted", "AbortError")),
+            { once: true }
+          );
+        }) : new Promise(() => {
+        });
+        let envelope;
+        try {
+          envelope = await Promise.race([takePromise, abortPromise]);
+        } catch (e) {
+          if (e instanceof DOMException && e.name === "AbortError")
+            break;
+          throw e;
+        }
+        if (shouldInclude(envelope))
+          yield envelope;
+      }
+    }
+  };
+}
+function expose(network, options) {
+  const { auth, select, plane: providedPlane, onRequest, startEventName = "request" } = options;
+  const channels = resolveChannels(network, select);
+  const eventFilter = select?.events;
+  const mainChannel = network.getMainChannel();
+  if (channels.length === 0) {
+    throw new Error("expose: no channels to subscribe to");
+  }
+  const createStream = async (req, consumer) => {
+    const payload = await extractPayload(req);
+    const signal = req.request?.signal;
+    const program = effect.Effect.gen(function* () {
+      const plane = providedPlane ?? (yield* createEventPlane(network));
+      if (!providedPlane) {
+        const emitQueue = yield* effect.Queue.unbounded();
+        yield* effect.Effect.fork(
+          effect.Effect.forever(
+            effect.Queue.take(emitQueue).pipe(
+              effect.Effect.flatMap(
+                ({ channels: chs, envelope }) => plane.publishToChannels(chs, envelope)
+              )
+            )
+          )
+        );
+        yield* effect.Effect.fork(run(network, plane, { emitQueue }));
+        yield* effect.Effect.sleep("10 millis");
+      }
+      const targetChannel = mainChannel?.name ?? channels[0];
+      const emitStartEvent = (p) => {
+        const pld = p ?? payload;
+        const envelope = {
+          name: startEventName,
+          meta: { runId: crypto.randomUUID() },
+          payload: pld
+        };
+        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 }))
+        );
+      } else if (!providedPlane) {
+        const envelope = {
+          name: startEventName,
+          meta: { runId: crypto.randomUUID() },
+          payload
+        };
+        yield* plane.publish(targetChannel, envelope);
+        yield* effect.Effect.sleep("10 millis");
+      }
+      const take = () => effect.Effect.runPromise(effect.Queue.take(dequeue));
+      const stream = streamFromDequeue(take, signal ?? void 0, eventFilter);
+      if (consumer) {
+        return yield* effect.Effect.tryPromise(() => consumer(stream));
+      }
+      return stream;
+    });
+    return effect.Effect.runPromise(program.pipe(effect.Effect.scoped));
+  };
+  return {
+    protocol: "sse",
+    createStream: async (req, consumer) => {
+      if (auth) {
+        const result = await auth(req);
+        if (!result.allowed) {
+          throw new ExposeAuthError(
+            result.message ?? "Unauthorized",
+            result.status ?? 401
+          );
+        }
+      }
+      return consumer ? createStream(req, consumer) : createStream(req);
+    }
+  };
+}
+var ExposeAuthError = class extends Error {
+  constructor(message, status = 401) {
+    super(message);
+    this.status = status;
+    this.name = "ExposeAuthError";
+  }
+};
+
+// src/matrix/agent-network/agent-network.ts
+var AgentNetwork = class _AgentNetwork {
+  constructor() {
+    this.channels = /* @__PURE__ */ new Map();
+    this.agentRegistrations = /* @__PURE__ */ new Map();
+    this.spawnerRegistrations = [];
+  }
+  /* ─── Public Static Factory ─── */
+  static setup(callback) {
+    const network = new _AgentNetwork();
+    const ctx = {
+      mainChannel: (name) => {
+        const channel = network.addChannel(name);
+        network.setMainChannel(channel);
+        return channel;
+      },
+      createChannel: (name) => network.addChannel(name),
+      sink: Sink,
+      registerAgent: (agent) => network.registerAgentInternal(agent),
+      spawner: (factory) => network.createSpawnerInternal(factory)
+    };
+    callback(ctx);
+    return network;
+  }
+  /* ─── Internal Builders ─── */
+  addChannel(name) {
+    const channelName = ChannelName(name);
+    const channel = new ConfiguredChannel(channelName);
+    this.channels.set(channelName, channel);
+    return channel;
+  }
+  setMainChannel(channel) {
+    this._mainChannel = channel;
+  }
+  registerAgentInternal(agent) {
+    const registration = {
+      agent,
+      subscribedTo: [],
+      publishesTo: []
+    };
+    this.agentRegistrations.set(agent.getId(), registration);
+    const binding = {
+      subscribe(channel) {
+        registration.subscribedTo.push(channel);
+        return binding;
+      },
+      publishTo(channel) {
+        registration.publishesTo.push(channel);
+        return binding;
+      }
+    };
+    return binding;
+  }
+  createSpawnerInternal(factoryClass) {
+    const reg = {
+      factoryClass,
+      registry: {}
+    };
+    this.spawnerRegistrations.push(reg);
+    const builder = {
+      listen(channel, event) {
+        reg.listenChannel = channel;
+        reg.listenEvent = event;
+        return builder;
+      },
+      registry(registry) {
+        reg.registry = registry;
+        return builder;
+      },
+      defaultBinding(fn) {
+        reg.defaultBindingFn = fn;
+        return builder;
+      },
+      onSpawn(fn) {
+        reg.onSpawnFn = fn;
+        return builder;
+      }
+    };
+    return builder;
+  }
+  /* ─── Accessors ─── */
+  getChannels() {
+    return this.channels;
+  }
+  getMainChannel() {
+    return this._mainChannel;
+  }
+  getAgentRegistrations() {
+    return this.agentRegistrations;
+  }
+  getSpawnerRegistrations() {
+    return this.spawnerRegistrations;
+  }
+  /**
+   * Expose the network as a streamable API (e.g. SSE). Returns an ExposedAPI
+   * that adapters (NextEndpoint, ExpressEndpoint) consume to produce streamed
+   * responses.
+   *
+   * @example
+   * const api = network.expose({ protocol: "sse", auth, select });
+   * export const GET = NextEndpoint.from(api).handler();
+   */
+  expose(options) {
+    return expose(this, options);
+  }
+  /**
+   * Starts the event plane: creates one PubSub per channel and runs subscriber
+   * loops for each (agent, channel) pair. Agents subscribed to a channel are
+   * invoked concurrently when events are published to that channel.
+   *
+   * Returns the EventPlane for publishing. Use `Effect.scoped` so the run is
+   * interrupted when the scope ends.
+   */
+  run(capacity) {
+    return this.runScoped(this, capacity);
+  }
+  runScoped(network, capacity) {
+    return effect.Effect.gen(function* () {
+      const plane = yield* createEventPlane(network, capacity);
+      yield* effect.Effect.fork(run(network, plane));
+      return plane;
+    });
+  }
+};
+var EventMetaSchema = effect.Schema.Struct({
+  runId: effect.Schema.String,
+  contextId: effect.Schema.optional(effect.Schema.String),
+  correlationId: effect.Schema.optional(effect.Schema.String),
+  causationId: effect.Schema.optional(effect.Schema.String),
+  ts: effect.Schema.optional(effect.Schema.Number)
+});
+var AgentNetworkEvent = {
+  of(name, payload) {
+    const decodePayload = effect.Schema.decodeUnknown(payload);
+    const envelopeSchema = effect.Schema.Struct({
+      name: effect.Schema.Literal(name),
+      meta: EventMetaSchema,
+      payload
+    });
+    const decodeEnvelope = effect.Schema.decodeUnknown(envelopeSchema);
+    const make = (payload2) => {
+      const decoded = effect.Effect.runSync(
+        decodePayload(payload2)
+      );
+      return { name, payload: decoded };
+    };
+    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 makeBoundEffect = (meta, payload2) => decodeEnvelope({ name, meta, payload: payload2 });
+    const is = effect.Schema.is(envelopeSchema);
+    return {
+      _tag: "AgentNetworkEventDef",
+      name,
+      payload,
+      decodePayload,
+      decode: decodeEnvelope,
+      make,
+      makeBound,
+      makeEffect,
+      makeBoundEffect,
+      is
+    };
+  }
+};
+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 } = options ?? {};
+    const emitFn = emit ?? ((_event) => {
+    });
+    await __privateGet(this, _logic).call(this, {
+      params: __privateGet(this, _params),
+      triggerEvent: triggerEvent ?? void 0,
+      emit: emitFn
+    });
+  }
+  getId() {
+    return __privateGet(this, _id);
+  }
+};
+_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;
+  }
+  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;
+  }
+  static run() {
+    return new _AgentFactory({});
+  }
+  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
+    );
+  }
+};
+
+// 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) {
+    if (api.protocol !== "sse") {
+      throw new Error(`NextEndpoint: unsupported protocol "${api.protocol}"`);
+    }
+    return {
+      handler() {
+        return async (request) => {
+          const req = { 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) {
+    if (api.protocol !== "sse") {
+      throw new Error(
+        `ExpressEndpoint: unsupported protocol "${api.protocol}"`
+      );
+    }
+    return {
+      handler() {
+        return async (req, res) => {
+          const controller = new AbortController();
+          req.on("close", () => controller.abort());
+          const exposeReq = {
+            request: { signal: controller.signal },
+            req,
+            res
+          };
+          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;
+          }
+        };
+      }
+    };
   }
 };
 
+Object.defineProperty(exports, 'S', {
+  enumerable: true,
+  get: function () { return effect.Schema; }
+});
+exports.Agent = Agent;
+exports.AgentFactory = AgentFactory;
+exports.AgentNetwork = AgentNetwork;
+exports.AgentNetworkEvent = AgentNetworkEvent;
 exports.AiCursor = AiCursor;
 exports.BaseVoiceEndpointAdapter = BaseVoiceEndpointAdapter;
+exports.Channel = Channel;
+exports.ChannelName = ChannelName;
+exports.ConfiguredChannel = ConfiguredChannel;
 exports.Emitter = Emitter;
+exports.EventMetaSchema = EventMetaSchema;
+exports.ExposeAuthError = ExposeAuthError;
+exports.ExpressEndpoint = ExpressEndpoint;
 exports.InputAudioController = InputAudioController;
+exports.NextEndpoint = NextEndpoint;
 exports.Pump = Pump;
+exports.Sink = Sink;
 exports.SocketIoFactory = SocketIoFactory;
 exports.TransformMessages = TransformMessages;
 exports.VoiceEndpointAdapter = VoiceEndpointAdapter;
 exports.VoiceSocketAdapter = VoiceSocketAdapter;
 exports.ensureFullWords = ensureFullWords;
+exports.formatSSE = formatSSE;
 exports.httpStreamResponse = httpStreamResponse;
+exports.isHttpStreamSink = isHttpStreamSink;
+exports.toSSEStream = toSSEStream;
 exports.useConversation = useConversation;
 exports.useSocketConversation = useSocketConversation;
 //# sourceMappingURL=out.js.map