@agent-glue/glue 0.1.8 → 0.2.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
 
-> @agent-glue/glue@0.1.7 build /home/gareth/Documents/Auto-Agent/repos/glue/main/packages/glue
+> @agent-glue/glue@0.2.0 build /home/gareth/Documents/Auto-Agent/repos/glue/main/packages/glue
 > tsc
 

package/.turbo/turbo-format.log

@@ -1,7 +1,5 @@
-
-
-> @agent-glue/glue@0.1.5 format /home/gareth/Documents/Auto-Agent/repos/glue/main/packages/agent-glue
-> prettier --check .
-
-Checking formatting...
-.turbo/turbo-format.log.turbo/turbo-lint.log.turbo/turbo-typecheck.logCHANGELOG.mddist/tsconfig.tsbuildinfoeslint.config.jsnodemon.jsonpackage.jsonsrc/actor.tssrc/effects.tssrc/emitter.tssrc/message.test.tssrc/message.tssrc/server.tssrc/server/memory.tssrc/server/protocol.tssrc/server/websocket.tssrc/transformers.tssrc/types.tssrc/utils/TypedEmitter.tstsconfig.jsonAll matched files use Prettier code style!
+
+> @agent-glue/glue@0.1.9 format /home/gareth/Documents/Auto-Agent/repos/glue/main/packages/glue
+> prettier --check .
+
+Checking formatting...

package/.turbo/turbo-lint.log

@@ -1,5 +1,5 @@
 
 
-> @agent-glue/glue@0.1.7 lint /home/gareth/Documents/Auto-Agent/repos/glue/main/packages/glue
+> @agent-glue/glue@0.2.0 lint /home/gareth/Documents/Auto-Agent/repos/glue/main/packages/glue
 > eslint .
 

package/.turbo/turbo-typecheck.log

@@ -1,5 +1,5 @@
 
 
-> @agent-glue/glue@0.1.7 typecheck /home/gareth/Documents/Auto-Agent/repos/glue/main/packages/glue
+> @agent-glue/glue@0.2.0 typecheck /home/gareth/Documents/Auto-Agent/repos/glue/main/packages/glue
 > tsc --noEmit
 

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @agent-glue/glue
 
+## 0.2.0
+
+### Minor Changes
+
+- 6f6c5a8: Add support for timeouts and abort signals to effects
+
+## 0.1.9
+
+### Patch Changes
+
+- Move @types/uuid from devDependencies to dependencies for type export compatibility
+
 ## 0.1.8
 
 ### Patch Changes

package/dist/effects.js

@@ -1,54 +1,152 @@
 function defaultDiscriminator(m) {
     return m === m;
 }
-export function take(actor, discriminator = (defaultDiscriminator)) {
-    return new Promise((resolve) => {
+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) {
+    return typeof reason === "string" ? reason : "Operation aborted";
+}
+export function take(actor, discriminator = (defaultDiscriminator), options) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let timer;
+        const cleanup = () => {
+            settled = true;
+            actor.disconnect(handler);
+            if (timer)
+                clearTimeout(timer);
+        };
         const handler = (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(actor) {
+export async function* takeEvery(actor, options) {
     const eventQueue = [];
     let resolve = null;
+    let reject = null;
+    let timer;
+    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) => {
         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((res) => {
+                resetTimer(); // start idle timer while waiting
+                const event = await new Promise((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(actor, discriminator) {
-    for await (const event of takeEvery(actor)) {
+export async function* takeIf(actor, discriminator, options) {
+    for await (const event of takeEvery(actor, options)) {
         if (discriminator(event)) {
             yield event;
         }
     }
 }
-export async function* takeUntil(actor, discriminator, endCondition = () => true) {
-    for await (const event of takeEvery(actor)) {
+export async function* takeUntil(actor, discriminator, endCondition = () => true, options) {
+    for await (const event of takeEvery(actor, options)) {
         if (endCondition(event)) {
             break;
         }
@@ -57,10 +155,19 @@ export async function* takeUntil(actor, discriminator, endCondition = () => true
         }
     }
 }
-export function on(actor, discriminator, handler) {
-    return actor.connect((message) => {
+export function on(actor, discriminator, handler, options) {
+    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;
 }