@cubicecho/agent-core 2.0.2 → 2.0.4

package/dist/capabilities.js

@@ -30,6 +30,8 @@ export function capabilitiesFor(baseUrl) {
 export function resetCapabilities() {
     capabilities.clear();
 }
+/** Every flag on a `Capabilities`, typed, so a third one is compared without an edit here. */
+const keys = (of) => Object.keys(of);
 /** `stream_options` is named in the refusal by every server that has not heard of it. */
 const REJECTS_USAGE = /stream_options/i;
 /**
@@ -61,6 +63,10 @@ const REJECTS_USAGE = /stream_options/i;
  */
 export async function negotiate(supports, send, { produced = { any: false }, onNotice } = {}) {
     for (;;) {
+        // What this attempt was built with. `capabilitiesFor` hands one object per endpoint to
+        // everyone on it, so a run starting alongside this one may latch a flag off while this call
+        // is in flight — and the branches below are guarded on the flag still being set.
+        const sent = { ...supports };
         try {
             return await send(supports, produced);
         }
@@ -76,9 +82,16 @@ export async function negotiate(supports, send, { produced = { any: false }, onN
                 supports.usageInStream = false;
                 onNotice?.("server rejected stream_options; token counts unavailable");
             }
-            else {
+            else if (keys(sent).every((flag) => sent[flag] === supports[flag])) {
                 throw error;
             }
+            // Otherwise the refusal was answered by whoever got there first, and this attempt was
+            // built before the answer existed. Two runs opening on a fresh llama.cpp box both get the
+            // grammar error; the first latches it off and re-sends, and the second used to find the
+            // flag already clear, fall through to the throw and die on an error the process had just
+            // learned to fix — `isTransient` refuses a 400, so `runTurn` would not send it again
+            // either. Sending it again is the whole of the fix: flags only ever latch off, so this
+            // gives up after one pass per flag.
         }
     }
 }

package/dist/events.js

@@ -22,6 +22,22 @@ const MAX_EVENTS = 1000;
 const TRIM_SLACK = 256;
 /** How long a finished run stays readable, for a watcher that arrives just after the end. */
 const RETAIN_MS = 60_000;
+/**
+ * The same for a run that has not said `done`, which is a far more dangerous thing to drop.
+ *
+ * A finished run has nothing more to say, so forgetting it a minute later costs a late watcher
+ * a backlog and nothing else. An unfinished one is still writing: `touched` only moves on
+ * `emit`, so a live run that spends a minute inside one slow tool call looked exactly like an
+ * abandoned one and was reaped out from under itself. What made that more than a lost backlog
+ * is that the next `emit` builds a fresh stream with `seq` back at zero — and `seq` is the
+ * field `RunEvent` documents for ordering and de-duplication, so a client that reconnects
+ * across the gap discards the new events as ones it has already seen.
+ *
+ * The sweep still has to reap them, because a run killed by a signal or simply forgotten
+ * reaches no `done` either. This is the backstop for a caller that never says so; `endRun` is
+ * for one that knows.
+ */
+const RETAIN_UNENDED_MS = 30 * 60_000;
 const streams = new Map();
 const streamFor = (runId) => {
     const existing = streams.get(runId);
@@ -52,9 +68,11 @@ const streamFor = (runId) => {
 let sweeping = null;
 function sweep() {
     sweeping = null;
-    const deadline = Date.now() - RETAIN_MS;
+    const now = Date.now();
     for (const [runId, stream] of streams) {
-        if (stream.listeners.size === 0 && stream.touched <= deadline)
+        if (stream.listeners.size)
+            continue;
+        if (stream.touched <= now - (stream.ended ? RETAIN_MS : RETAIN_UNENDED_MS))
             streams.delete(runId);
     }
     scheduleSweep();
@@ -73,6 +91,17 @@ function scheduleSweep() {
  * @param runId The run to forget. An id nothing was emitted under is ignored.
  */
 export function endRun(runId) {
+    const stream = streams.get(runId);
+    if (!stream)
+        return;
+    // Watchers are parked on a promise that only an `emit` to *this* stream can resolve, and the
+    // delete below puts it beyond the reach of every later one — the next `emit` builds a fresh
+    // stream and wakes nobody. So they are told the run is over first: a watcher that is handed
+    // `done` completes, runs its `finally` and lets its consumer go, where one left parked holds
+    // an open subscription that can never say anything again. An SSE client on the other end of
+    // that is a connection that never closes.
+    if (stream.listeners.size)
+        emit(runId, { kind: "done", ok: false, text: "run ended" });
     streams.delete(runId);
 }
 /**
@@ -209,7 +238,12 @@ export async function* watch(runId) {
         // A watcher can name a run that has not started, or will never start. Nothing was recorded
         // under it, so nothing is left behind either — and a run that has ended has nothing more to
         // say to anyone, so the last watcher leaving takes the backlog with it.
-        if (stream.listeners.size === 0 && (stream.ended || stream.events.length === 0)) {
+        // Against `stream` rather than the id: this generator may have outlived its own entry — a
+        // sweep or an `endRun` drops it and a later `emit` files the same run under a new one — and
+        // the last watcher of the old stream has no business deleting the new one.
+        if (streams.get(runId) === stream &&
+            stream.listeners.size === 0 &&
+            (stream.ended || stream.events.length === 0)) {
             streams.delete(runId);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubicecho/agent-core",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "The endpoint-agnostic half of an OpenAI-compatible agent loop: tool-schema compatibility, on-demand tool loading, one-shot side tasks, run events, and a pooled client.",
   "keywords": [
     "openai",