@nylorun/agents 0.29.1-beta → 0.31.0-beta

package/dist/index.js

@@ -23,3 +23,5 @@ export { RuntimeError, IncompatibleRuntimeError } from "./http.js";
 export { loadMcpServers, loadPlugin, PluginError } from "./plugins/load.js";
 export { hashFolder, loadSkillsFromDirectory, resolveSkillsRoot, parseSkill, SkillsError, } from "./skills/index.js";
 export { McpError } from "./mcp/index.js";
+// The A2A client (`@nylorun/agents/a2a` also has the gateway handler).
+export * from "./a2a/client-api.js";

package/dist/session-client.d.ts

@@ -439,10 +439,15 @@ export declare class SessionClient {
         agent?: string;
         signal?: AbortSignal;
     }): Promise<SessionItemsResponse>;
+    /**
+     * The session's events from `cursor` on, reconnecting from the last one when the connection
+     * drops or sends nothing, keepalives included, for `idleTimeoutMs` (default 45 s; `0` never).
+     */
     observe(options?: {
         cursor?: string;
         signal?: AbortSignal;
         follow?: boolean;
+        idleTimeoutMs?: number;
     }): AsyncGenerator<{
         schema: "nylorun.event/2";
         eventId: string;

package/dist/session-client.js

@@ -279,6 +279,10 @@ export class SessionClient {
             ...("tail" in page ? { tail: page.tail } : {}),
         };
     }
+    /**
+     * The session's events from `cursor` on, reconnecting from the last one when the connection
+     * drops or sends nothing, keepalives included, for `idleTimeoutMs` (default 45 s; `0` never).
+     */
     async *observe(options = {}) {
         if (!options.follow) {
             yield* this.observeOne(this.id, options);
@@ -318,7 +322,11 @@ export class SessionClient {
         };
         const pump = async (sessionId, cursor) => {
             try {
-                for await (const event of this.observeOne(sessionId, { cursor, signal })) {
+                for await (const event of this.observeOne(sessionId, {
+                    cursor,
+                    signal,
+                    ...(options.idleTimeoutMs !== undefined ? { idleTimeoutMs: options.idleTimeoutMs } : {}),
+                })) {
                     push(event);
                     const link = linkedSessionId(event);
                     if (link && link !== this.id && !linked.has(link)) {

package/dist/sse.d.ts

@@ -4,9 +4,26 @@ export interface SSEEvent {
     data: string;
     id?: string;
 }
-/** Fetch-based SSE supports Authorization headers and works in browsers and Node. */
-export declare function readSSE(response: Response, signal: AbortSignal): AsyncGenerator<SSEEvent>;
+/**
+ * How long a stream may send nothing before the client takes it for dead: the Runtime sends a
+ * `: keepalive` comment every 15 s, so three missed ones.
+ */
+export declare const SSE_IDLE_TIMEOUT_MS = 45000;
+/** A stream sent no byte, not even a keepalive, for `idleTimeoutMs`. */
+export declare class SSEIdleTimeoutError extends Error {
+    readonly idleTimeoutMs: number;
+    constructor(idleTimeoutMs: number);
+}
+/**
+ * Fetch-based SSE supports Authorization headers and works in browsers and Node. Any byte,
+ * keepalive comments included, counts as liveness; after `idleTimeoutMs` without one the read
+ * stops with `SSEIdleTimeoutError` (`0` waits forever).
+ */
+export declare function readSSE(response: Response, signal: AbortSignal, options?: {
+    idleTimeoutMs?: number;
+}): AsyncGenerator<SSEEvent>;
 export declare function observeSSE(transport: Transport, path: string, options?: {
     signal?: AbortSignal;
     cursor?: string;
+    idleTimeoutMs?: number;
 }): AsyncGenerator<SSEEvent>;

package/dist/sse.js

@@ -1,6 +1,24 @@
 import { delay, RuntimeError } from "./http.js";
-/** Fetch-based SSE supports Authorization headers and works in browsers and Node. */
-export async function* readSSE(response, signal) {
+/**
+ * How long a stream may send nothing before the client takes it for dead: the Runtime sends a
+ * `: keepalive` comment every 15 s, so three missed ones.
+ */
+export const SSE_IDLE_TIMEOUT_MS = 45_000;
+/** A stream sent no byte, not even a keepalive, for `idleTimeoutMs`. */
+export class SSEIdleTimeoutError extends Error {
+    idleTimeoutMs;
+    constructor(idleTimeoutMs) {
+        super(`The event stream sent nothing for ${idleTimeoutMs} ms`);
+        this.idleTimeoutMs = idleTimeoutMs;
+        this.name = "SSEIdleTimeoutError";
+    }
+}
+/**
+ * Fetch-based SSE supports Authorization headers and works in browsers and Node. Any byte,
+ * keepalive comments included, counts as liveness; after `idleTimeoutMs` without one the read
+ * stops with `SSEIdleTimeoutError` (`0` waits forever).
+ */
+export async function* readSSE(response, signal, options = {}) {
     if (!response.headers.get("content-type")?.includes("text/event-stream"))
         throw new Error("Expected an SSE response");
     if (!response.body)
@@ -15,9 +33,22 @@ export async function* readSSE(response, signal) {
         void reader.cancel().catch(() => { });
     };
     signal.addEventListener("abort", abort, { once: true });
+    const idleTimeoutMs = options.idleTimeoutMs ?? SSE_IDLE_TIMEOUT_MS;
+    let idle = false;
+    let timer;
     try {
         while (!signal.aborted) {
+            // Only the wait for bytes counts, never the time the consumer holds an event. Cancelling
+            // the reader ends the pending read, as an abort does.
+            if (idleTimeoutMs > 0)
+                timer = setTimeout(() => {
+                    idle = true;
+                    abort();
+                }, idleTimeoutMs);
             const result = await reader.read();
+            clearTimeout(timer);
+            if (idle)
+                throw new SSEIdleTimeoutError(idleTimeoutMs);
             if (result.done)
                 break;
             buffer += decoder.decode(result.value, { stream: true });
@@ -55,6 +86,7 @@ export async function* readSSE(response, signal) {
         }
     }
     finally {
+        clearTimeout(timer);
         signal.removeEventListener("abort", abort);
         await reader.cancel().catch(() => { });
         reader.releaseLock();
@@ -78,7 +110,10 @@ export async function* observeSSE(transport, path, options = {}) {
                     ...(cursor ? { "Last-Event-ID": cursor } : {}),
                 },
             });
-            for await (const event of readSSE(response, signal)) {
+            const read = readSSE(response, signal, {
+                ...(options.idleTimeoutMs !== undefined ? { idleTimeoutMs: options.idleTimeoutMs } : {}),
+            });
+            for await (const event of read) {
                 if (event.event === "nylorun.closed") {
                     closedByRuntime += 1;
                     reconnectNow = closedByRuntime === 1;
@@ -94,6 +129,9 @@ export async function* observeSSE(transport, path, options = {}) {
         catch (error) {
             if (signal.aborted)
                 return;
+            // A silent stream is a dead connection: open a new one from the last event at once.
+            if (error instanceof SSEIdleTimeoutError)
+                continue;
             if (error instanceof RuntimeError &&
                 error.status >= 400 &&
                 error.status < 500 &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/agents",
-  "version": "0.29.1-beta",
+  "version": "0.31.0-beta",
   "description": "Nylorun agent definitions and session client",
   "type": "module",
   "license": "Apache-2.0",
@@ -43,7 +43,7 @@
     "test": "vitest run --passWithNoTests"
   },
   "dependencies": {
-    "@nylorun/core": "0.30.0-beta",
+    "@nylorun/core": "0.32.0-beta",
     "gray-matter": "^4.0.3"
   },
   "peerDependencies": {