toolnexus 0.12.0 → 0.14.0

package/dist/a2a.js

@@ -234,6 +234,14 @@ function skillTool(agentName, endpoint, skill, ag) {
                 };
             }
             catch (e) {
+                // An abort that lands WHILE an RPC is in flight surfaces as a transport error
+                // (AbortError), not through the two checks in the poll loop. Report it as the
+                // cancel it is, so a cancelled call is `canceled` regardless of whether the
+                // signal fired between polls or mid-request.
+                if (ctx?.signal?.aborted) {
+                    state = "canceled";
+                    return { output: `A2A task ${taskId} canceled`, isError: true, metadata: meta() };
+                }
                 return { output: e instanceof Error ? e.message : String(e), isError: true, metadata: meta() };
             }
         },

package/dist/agents/compaction.js

@@ -71,25 +71,41 @@ export function compactor(opts) {
     };
 }
 /**
- * Locate the index where the retained tail begins. Tool-pair safety requires the tail
- * to start at a `user` turn: the largest user-boundary tail that still fits `keepTail`.
- * If no user boundary fits within `keepTail`, fall back to the most recent user turn
+ * Does this message carry a tool result? Under the anthropic dialect a tool result is a
+ * `user` message whose content holds `tool_result` blocks, so such a message is a member
+ * of a tool group rather than a conversational boundary.
+ */
+function carriesToolResult(m) {
+    const content = m.content;
+    if (!Array.isArray(content))
+        return false;
+    return content.some((b) => typeof b === "object" && b !== null && b.type === "tool_result");
+}
+/** A valid tail boundary: a `user` turn that is not carrying a tool result. */
+function isBoundary(m) {
+    return m.role === "user" && !carriesToolResult(m);
+}
+/**
+ * Locate the index where the retained tail begins. Tool-pair safety requires the tail to
+ * start at a `user` turn that is not a tool-result carrier: the largest such tail that
+ * still fits `keepTail`. If none fits, fall back to the most recent valid boundary
  * (favoring safety over size). Returns `msgs.length` (no tail) only when there is no
- * user turn after the head at all.
+ * valid boundary after the head at all — the whole body is then summarized, which is
+ * bounded and cannot orphan anything since nothing is retained.
  */
 function findTailStart(msgs, headEnd, keepTail, count) {
     let split = msgs.length;
     for (let i = msgs.length - 1; i > headEnd; i--) {
         if (count(msgs.slice(i)) > keepTail)
             break;
-        if (msgs[i].role === "user")
+        if (isBoundary(msgs[i]))
             split = i;
     }
     if (split !== msgs.length)
         return split;
-    // No user boundary fit within keepTail — extend back to the most recent user turn.
+    // No boundary fit within keepTail — extend back to the most recent valid one.
     for (let i = msgs.length - 1; i > headEnd; i--) {
-        if (msgs[i].role === "user")
+        if (isBoundary(msgs[i]))
             return i;
     }
     return msgs.length;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolnexus",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Dynamic MCP servers + agent skills as uniform tools for any LLM (opencode-style).",
   "type": "module",
   "main": "./dist/index.js",

package/src/a2a.ts

@@ -344,6 +344,14 @@ function skillTool(agentName: string, endpoint: string, skill: A2ASkill, ag: Age
           metadata: meta(),
         }
       } catch (e) {
+        // An abort that lands WHILE an RPC is in flight surfaces as a transport error
+        // (AbortError), not through the two checks in the poll loop. Report it as the
+        // cancel it is, so a cancelled call is `canceled` regardless of whether the
+        // signal fired between polls or mid-request.
+        if (ctx?.signal?.aborted) {
+          state = "canceled"
+          return { output: `A2A task ${taskId} canceled`, isError: true, metadata: meta() }
+        }
         return { output: e instanceof Error ? e.message : String(e), isError: true, metadata: meta() }
       }
     },

package/src/agents/compaction.ts

@@ -121,11 +121,30 @@ export function compactor(
 }
 
 /**
- * Locate the index where the retained tail begins. Tool-pair safety requires the tail
- * to start at a `user` turn: the largest user-boundary tail that still fits `keepTail`.
- * If no user boundary fits within `keepTail`, fall back to the most recent user turn
+ * Does this message carry a tool result? Under the anthropic dialect a tool result is a
+ * `user` message whose content holds `tool_result` blocks, so such a message is a member
+ * of a tool group rather than a conversational boundary.
+ */
+function carriesToolResult(m: Message): boolean {
+  const content = (m as { content?: unknown }).content
+  if (!Array.isArray(content)) return false
+  return content.some(
+    (b) => typeof b === "object" && b !== null && (b as { type?: unknown }).type === "tool_result",
+  )
+}
+
+/** A valid tail boundary: a `user` turn that is not carrying a tool result. */
+function isBoundary(m: Message): boolean {
+  return m.role === "user" && !carriesToolResult(m)
+}
+
+/**
+ * Locate the index where the retained tail begins. Tool-pair safety requires the tail to
+ * start at a `user` turn that is not a tool-result carrier: the largest such tail that
+ * still fits `keepTail`. If none fits, fall back to the most recent valid boundary
  * (favoring safety over size). Returns `msgs.length` (no tail) only when there is no
- * user turn after the head at all.
+ * valid boundary after the head at all — the whole body is then summarized, which is
+ * bounded and cannot orphan anything since nothing is retained.
  */
 function findTailStart(
   msgs: Message[],
@@ -136,13 +155,13 @@ function findTailStart(
   let split = msgs.length
   for (let i = msgs.length - 1; i > headEnd; i--) {
     if (count(msgs.slice(i)) > keepTail) break
-    if (msgs[i].role === "user") split = i
+    if (isBoundary(msgs[i])) split = i
   }
   if (split !== msgs.length) return split
 
-  // No user boundary fit within keepTail — extend back to the most recent user turn.
+  // No boundary fit within keepTail — extend back to the most recent valid one.
   for (let i = msgs.length - 1; i > headEnd; i--) {
-    if (msgs[i].role === "user") return i
+    if (isBoundary(msgs[i])) return i
   }
   return msgs.length
 }