@agent-glue/glue 0.1.8 → 0.2.0

package/src/effects.ts

@@ -5,55 +5,178 @@ function defaultDiscriminator<T extends Message>(m: Message): m is T {
   return m === m;
 }
 
+export interface EffectOptions {
+  /** Timeout in ms. Rejects with TimeoutError (take) or idle timeout (generators). */
+  timeout?: number;
+  /** AbortSignal. Rejects with AbortError when aborted. */
+  signal?: AbortSignal;
+}
+
+export class TimeoutError extends Error {
+  constructor(message = "Operation timed out") {
+    super(message);
+    this.name = "TimeoutError";
+  }
+}
+
+export class AbortError extends Error {
+  constructor(message = "Operation aborted") {
+    super(message);
+    this.name = "AbortError";
+  }
+}
+
+function wrapAbortReason(reason: unknown): string {
+  return typeof reason === "string" ? reason : "Operation aborted";
+}
+
 export function take<T extends Events, Events extends Message>(
   actor: ActorInterface<Message, Events>,
-  discriminator: MessageDiscriminator<T> = defaultDiscriminator<T>
+  discriminator: MessageDiscriminator<T> = defaultDiscriminator<T>,
+  options?: EffectOptions,
 ): Promise<T> {
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    const cleanup = () => {
+      settled = true;
+      actor.disconnect(handler);
+      if (timer) clearTimeout(timer);
+    };
+
     const handler = (message: Message) => {
+      if (settled) return;
       if (discriminator(message)) {
-        actor.disconnect(handler);
+        cleanup();
         resolve(message);
       }
     };
+
+    // AbortSignal - check before connecting
+    if (options?.signal) {
+      if (options.signal.aborted) {
+        reject(new AbortError(wrapAbortReason(options.signal.reason)));
+        return;
+      }
+      options.signal.addEventListener(
+        "abort",
+        () => {
+          if (!settled) {
+            cleanup();
+            reject(new AbortError(wrapAbortReason(options.signal!.reason)));
+          }
+        },
+        { once: true },
+      );
+    }
+
+    // Timeout
+    if (options?.timeout != null) {
+      timer = setTimeout(() => {
+        if (!settled) {
+          cleanup();
+          reject(new TimeoutError());
+        }
+      }, options.timeout);
+      timer.unref();
+    }
+
     actor.connect(handler);
   });
 }
 
 export async function* takeEvery<Events extends Message>(
-  actor: ActorInterface<Message, Events>
+  actor: ActorInterface<Message, Events>,
+  options?: EffectOptions,
 ): AsyncGenerator<Events> {
   const eventQueue: Events[] = [];
   let resolve: ((value: Events) => void) | null = null;
+  let reject: ((reason: Error) => void) | null = null;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+
+  const clearTimer = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = undefined;
+    }
+  };
+
+  const resetTimer = () => {
+    clearTimer();
+    if (options?.timeout != null) {
+      timer = setTimeout(() => {
+        if (reject) {
+          const rej = reject;
+          reject = null;
+          resolve = null;
+          rej(new TimeoutError());
+        }
+      }, options.timeout);
+      timer.unref();
+    }
+  };
 
   const disconnect = actor.connect((message: Events) => {
     if (resolve) {
-      resolve(message);
+      const res = resolve;
       resolve = null;
+      reject = null;
+      res(message);
     } else {
       eventQueue.push(message);
     }
   });
+
+  // AbortSignal
+  const onAbort = () => {
+    if (reject) {
+      const rej = reject;
+      reject = null;
+      resolve = null;
+      rej(new AbortError(wrapAbortReason(options?.signal?.reason)));
+    }
+  };
+
+  if (options?.signal) {
+    if (options.signal.aborted) {
+      disconnect();
+      return;
+    }
+    options.signal.addEventListener("abort", onAbort, { once: true });
+  }
+
   try {
     while (true) {
+      if (options?.signal?.aborted) break;
+
       if (eventQueue.length > 0) {
-        yield eventQueue.shift()!;
+        const event = eventQueue.shift()!;
+        resetTimer(); // reset idle timer on event
+        yield event;
       } else {
-        yield new Promise<Events>((res) => {
+        resetTimer(); // start idle timer while waiting
+        const event = await new Promise<Events>((res, rej) => {
           resolve = res;
+          reject = rej;
         });
+        clearTimer(); // event arrived, clear timer
+        yield event;
       }
     }
   } finally {
+    clearTimer();
+    options?.signal?.removeEventListener("abort", onAbort);
     disconnect();
   }
 }
 
 export async function* takeIf<T extends Events, Events extends Message>(
   actor: ActorInterface<Message, Events>,
-  discriminator: MessageDiscriminator<T>
+  discriminator: MessageDiscriminator<T>,
+  options?: EffectOptions,
 ): AsyncGenerator<T> {
-  for await (const event of takeEvery(actor)) {
+  for await (const event of takeEvery(actor, options)) {
     if (discriminator(event)) {
       yield event;
     }
@@ -63,9 +186,10 @@ export async function* takeIf<T extends Events, Events extends Message>(
 export async function* takeUntil<T extends Events, Events extends Message>(
   actor: ActorInterface<Message, Events>,
   discriminator: MessageDiscriminator<T>,
-  endCondition: (message: Events) => boolean = () => true
+  endCondition: (message: Events) => boolean = () => true,
+  options?: EffectOptions,
 ): AsyncGenerator<T> {
-  for await (const event of takeEvery(actor)) {
+  for await (const event of takeEvery(actor, options)) {
     if (endCondition(event)) {
       break;
     }
@@ -78,11 +202,28 @@ export async function* takeUntil<T extends Events, Events extends Message>(
 export function on<T extends Events, Events extends Message>(
   actor: ActorInterface<Message, Events>,
   discriminator: MessageDiscriminator<T>,
-  handler: (message: T) => void
+  handler: (message: T) => void,
+  options?: { signal?: AbortSignal },
 ): () => void {
-  return actor.connect((message) => {
+  if (options?.signal?.aborted) {
+    return () => {};
+  }
+
+  const disconnect = actor.connect((message) => {
     if (discriminator(message)) {
       handler(message);
     }
   });
+
+  if (options?.signal) {
+    options.signal.addEventListener(
+      "abort",
+      () => {
+        disconnect();
+      },
+      { once: true },
+    );
+  }
+
+  return disconnect;
 }