@cubicecho/agent-core 2.0.3 → 2.0.5

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/tool-loading.d.ts

@@ -88,6 +88,7 @@ export declare function expandNames(requested: string[], catalog: CatalogServer[
         name: string;
         hits: string[];
     }[];
+    deferred: string[];
 };
 /**
  * What `load_tools` reports back: the descriptions, now that they are worth their tokens.
@@ -95,7 +96,7 @@ export declare function expandNames(requested: string[], catalog: CatalogServer[
  * @param expanded What `expandNames` resolved: the matches, the misses, and the over-broad asks.
  * @param catalog The servers, read for the descriptions now worth their tokens.
  */
-export declare function loadResult({ matched, unknown, overBroad }: ReturnType<typeof expandNames>, catalog: CatalogServer[]): string;
+export declare function loadResult({ matched, unknown, overBroad, deferred }: ReturnType<typeof expandNames>, catalog: CatalogServer[]): string;
 /**
  * Whether the catalogue holds a tool by this name.
  *

package/dist/tool-loading.js

@@ -137,6 +137,7 @@ export function expandNames(requested, catalog) {
     const matched = new Set();
     const unknown = [];
     const overBroad = [];
+    const deferred = [];
     const known = new Set(all.map((tool) => tool.name));
     const resolve = (name) => {
         if (name.endsWith("*")) {
@@ -172,13 +173,21 @@ export function expandNames(requested, catalog) {
         // model that is meant to be choosing from twelve. Already-matched names are free, so a
         // name that only repeats an earlier one never spends budget.
         const fresh = hits.filter((hit) => !matched.has(hit));
-        if (matched.size + fresh.length > MAX_PER_LOAD)
+        // Two different refusals, and answering both with "narrow it down" made one of them
+        // impossible to act on. A name that would not fit an empty call is over-broad, and the
+        // names are what the model needs. A name that only does not fit *this* call is precise
+        // enough already — telling a model that asked for one exact tool that it matches one tool,
+        // "more than the twelve one call may load", and to choose from a list holding just that
+        // name, leaves it nothing to do but send the identical call again.
+        if (fresh.length > MAX_PER_LOAD)
             overBroad.push({ name, hits });
+        else if (matched.size + fresh.length > MAX_PER_LOAD)
+            deferred.push(name);
         else
             for (const hit of hits)
                 matched.add(hit);
     }
-    return { matched: [...matched], unknown, overBroad };
+    return { matched: [...matched], unknown, overBroad, deferred };
 }
 /**
  * What `load_tools` reports back: the descriptions, now that they are worth their tokens.
@@ -186,7 +195,7 @@ export function expandNames(requested, catalog) {
  * @param expanded What `expandNames` resolved: the matches, the misses, and the over-broad asks.
  * @param catalog The servers, read for the descriptions now worth their tokens.
  */
-export function loadResult({ matched, unknown, overBroad }, catalog) {
+export function loadResult({ matched, unknown, overBroad, deferred }, catalog) {
     const byName = new Map(flatten(catalog).map((tool) => [tool.name, tool.description]));
     const lines = [];
     if (matched.length) {
@@ -199,6 +208,11 @@ export function loadResult({ matched, unknown, overBroad }, catalog) {
             lines.push("");
         lines.push(`\`${name}\` matches ${hits.length} tools, more than the ${MAX_PER_LOAD} one call may load.`, "Name the ones you need from:", ...hits.map((hit) => `  ${hit}`));
     }
+    if (deferred.length) {
+        if (lines.length)
+            lines.push("");
+        lines.push(`This call is full at ${MAX_PER_LOAD} tools, so these were not loaded: ${deferred.join(", ")}.`, "Ask for them on your next step.");
+    }
     if (unknown.length) {
         if (lines.length)
             lines.push("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubicecho/agent-core",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "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",