@cubicecho/agent-core 2.0.6 → 2.0.8

package/dist/retry.js

@@ -61,10 +61,16 @@ function messageChars(message) {
 /**
  * The tools half, cached against the array.
  *
- * Tool definitions are stable objects handed out by a pool, and `sanitizeTools` already caches on
- * that same identity — so the array a turn sends is the array the last turn sent unless something
- * reconnected. Serialising two dozen JSON schemas to measure them, on every turn, to get the same
- * number every time, was the more expensive half of this function.
+ * Serialising two dozen JSON schemas to measure them, on every turn, to get the same number every
+ * time, was the more expensive half of this function.
+ *
+ * The array is the key, so this pays only a caller that hands the same one back. That is not what
+ * a turn built through `sanitizeTools` or `relaxTools` does — both are a `map`, so each build
+ * allocates a fresh array however stable the tools inside it are, and those builds miss here every
+ * time. It is not free to change: keying on the tools instead would hit for them, at the cost of
+ * the array-level memoisation `tests/retry.test.ts` pins, which deliberately holds a mutated array
+ * to its first reading. Sizing happens once per turn either way, so the miss costs one walk of the
+ * schemas rather than a walk per attempt.
  */
 const toolTokens = new WeakMap();
 function toolsCost(tools) {

package/dist/schema-compat.js

@@ -99,55 +99,76 @@ function collapseNullableUnion(node) {
 const TOP_LEVEL_COMBINATORS = ["allOf", "anyOf", "oneOf", "enum", "not"];
 /** `#/definitions/Args` or `#/$defs/Args` — a pointer into this schema's own definitions. */
 const LOCAL_POINTER = /^#\/(definitions|\$defs)\/([^/]+)$/;
-/**
- * Replaces a root-level `$ref` with what it points at.
- *
- * Dropping the siblings of a `$ref` is right at a nested position and wrong at this one: the
- * siblings here are the `definitions` the pointer needs, so the reference is left dangling and
- * `properties` is then backfilled empty below. The tool goes out advertising no arguments at
- * all — which the model cannot detect and the server has no reason to refuse. A schema
- * generator emits this shape whenever the argument object is a named type.
- */
-function inlineRootRef(parameters) {
+/** The `definitions` and `$defs` that a local pointer in this schema resolves against. */
+function poolsOf(parameters) {
     const defs = {};
     for (const key of ["definitions", "$defs"])
         if (isObject(parameters[key]))
             defs[key] = parameters[key];
+    return defs;
+}
+/**
+ * Follows a chain of local references to the schema it arrives at, or `undefined` where it
+ * arrives at none — a pointer into another document, one that comes back around to itself, or a
+ * name the pools do not hold. A node that is not a reference resolves to itself, so a caller can
+ * hand this a branch without first asking which spelling it is.
+ *
+ * @param node The schema position to resolve, reference or not.
+ * @param defs The pools to resolve against, as `poolsOf` collects them from the root.
+ */
+function resolveRef(node, defs) {
     const seen = new Set();
-    let node = parameters;
-    while (typeof node.$ref === "string") {
-        const pointer = node.$ref;
+    let current = node;
+    while (isObject(current) && typeof current.$ref === "string") {
+        const pointer = current.$ref;
         const target = LOCAL_POINTER.exec(pointer);
-        // A pointer at another document, or one that comes back to itself, has nothing here to
-        // resolve against. An object with no properties is at least honest about taking none.
         if (!target || seen.has(pointer))
-            return EMPTY_OBJECT();
+            return undefined;
         seen.add(pointer);
         const pool = defs[target[1]];
-        const resolved = isObject(pool) ? pool[target[2]] : undefined;
-        if (!isObject(resolved))
-            return EMPTY_OBJECT();
-        node = resolved;
+        current = isObject(pool) ? pool[target[2]] : undefined;
     }
-    // The definitions travel with it: whatever the target refers to still lives in them.
-    return node === parameters ? parameters : { ...node, ...defs };
+    return isObject(current) ? current : undefined;
+}
+/**
+ * Replaces a root-level `$ref` with what it points at.
+ *
+ * Dropping the siblings of a `$ref` is right at a nested position and wrong at this one: the
+ * siblings here are the `definitions` the pointer needs, so the reference is left dangling and
+ * `properties` is then backfilled empty below. The tool goes out advertising no arguments at
+ * all — which the model cannot detect and the server has no reason to refuse. A schema
+ * generator emits this shape whenever the argument object is a named type.
+ */
+function inlineRootRef(parameters) {
+    if (typeof parameters.$ref !== "string")
+        return parameters;
+    const defs = poolsOf(parameters);
+    const resolved = resolveRef(parameters, defs);
+    // A pointer that lands nowhere has nothing here to resolve against. An object with no
+    // properties is at least honest about taking none.
+    // The definitions travel with what it did land on: whatever that refers to still lives in them.
+    return resolved ? { ...resolved, ...defs } : EMPTY_OBJECT();
 }
 /**
  * Folds a root `allOf` into the root itself.
  *
  * It is the other way a generated schema spells "the arguments are this named type", and
  * deleting it outright below threw the arguments away while leaving the `required` that named
- * them. Branches that are references are not something to guess at — those fall through to
- * `pruneRequired`, which at least keeps the result self-consistent.
+ * them. A branch is far more often a reference than an inline object — a named type is exactly
+ * what a generator puts in `$defs` — so each is resolved against this schema's own pools first.
+ * One that resolves nowhere is not something to guess at, and falls through to `pruneRequired`,
+ * which at least keeps the result self-consistent.
  */
 function mergeRootAllOf(out) {
     const branches = out.allOf;
     if (!Array.isArray(branches))
         return;
+    const defs = poolsOf(out);
     const properties = isObject(out.properties) ? { ...out.properties } : {};
     const required = new Set(Array.isArray(out.required) ? out.required.filter((name) => typeof name === "string") : []);
-    for (const branch of branches) {
-        if (!isObject(branch) || "$ref" in branch)
+    for (const raw of branches) {
+        const branch = resolveRef(raw, defs);
+        if (!branch)
             continue;
         if (isObject(branch.properties))
             Object.assign(properties, branch.properties);
@@ -170,10 +191,14 @@ function mergeRootAllOf(out) {
  * `collapseNullableUnion` to take apart, so it reached the delete below intact and every
  * argument went with it. Properties are unioned because a caller satisfies any one branch;
  * `required` keeps only the names every branch asks for, since one that a branch does without
- * is one the model has to be free to omit. A branch that is a reference is not something to
- * guess at — it cannot vouch for a name, so its presence alone empties `required`.
+ * is one the model has to be free to omit. The branches of a discriminated union arrive as
+ * references rather than inline — Pydantic, zod-to-json-schema and the MCP TypeScript SDK all
+ * emit the shapes into `$defs` and point at them from the root — so each is resolved against
+ * this schema's own pools first. One that resolves nowhere still cannot vouch for a name, so its
+ * presence alone empties `required`.
  */
 function mergeRootUnion(out) {
+    const defs = poolsOf(out);
     for (const key of ["anyOf", "oneOf"]) {
         const branches = out[key];
         if (!Array.isArray(branches))
@@ -182,9 +207,10 @@ function mergeRootUnion(out) {
         // `null` until a branch has been read, which is what tells "no branches yet" apart from
         // "the branches agreed on nothing".
         let shared = null;
-        for (const branch of branches) {
+        for (const raw of branches) {
             const previous = shared;
-            if (!isObject(branch) || "$ref" in branch) {
+            const branch = resolveRef(raw, defs);
+            if (!branch) {
                 shared = new Set();
                 continue;
             }
@@ -206,6 +232,84 @@ function mergeRootUnion(out) {
         }
     }
 }
+/**
+ * Every `$ref` string anywhere under a node, walked as arbitrary JSON rather than as a schema.
+ *
+ * The keyword-aware walk `strip` does is the wrong way round for this one. Missing a pointer
+ * here means deleting a definition that something still refers to, which breaks the schema;
+ * finding one that was really a string sitting in a `default` or an `enum` costs a definition
+ * that outlives its last real reference. So this errs the cheap way and reads every position.
+ */
+function collectRefs(node, into) {
+    if (Array.isArray(node)) {
+        for (const item of node)
+            collectRefs(item, into);
+        return;
+    }
+    if (!isObject(node))
+        return;
+    for (const [key, value] of Object.entries(node)) {
+        if (key === "$ref" && typeof value === "string")
+            into.add(value);
+        else
+            collectRefs(value, into);
+    }
+}
+/**
+ * Drops the `definitions` and `$defs` entries that nothing points at any more.
+ *
+ * The rewrites above delete whole subtrees — a root combinator once its branches are folded in,
+ * every sibling of a `$ref`, the branch of a union that was only ever `null` — and the pointers
+ * go with them while the pools they named stay behind. On a real Gmail or filesystem schema
+ * those pools are most of the parameter bytes, re-sent for every tool on every turn of every
+ * run, describing shapes the request no longer mentions anywhere.
+ *
+ * Reachability rather than a single pass, because a definition that is still pointed at can
+ * name another; a cycle among them terminates on the `has` check, whether or not anything
+ * outside it still refers in.
+ */
+function pruneDefs(out) {
+    const pools = ["definitions", "$defs"].filter((key) => isObject(out[key]));
+    if (!pools.length)
+        return;
+    const live = {};
+    const visit = (node) => {
+        const pointers = new Set();
+        collectRefs(node, pointers);
+        for (const pointer of pointers) {
+            const target = LOCAL_POINTER.exec(pointer);
+            if (!target)
+                continue;
+            const [, poolKey, name] = target;
+            const pool = out[poolKey];
+            if (!isObject(pool) || !(name in pool))
+                continue;
+            live[poolKey] ??= new Set();
+            const names = live[poolKey];
+            if (names.has(name))
+                continue;
+            names.add(name);
+            visit(pool[name]);
+        }
+    };
+    // The pools themselves are not roots: a definition is reached from the schema body, or by
+    // another definition that was, or not at all.
+    const body = { ...out };
+    for (const key of pools)
+        delete body[key];
+    visit(body);
+    for (const key of pools) {
+        const names = live[key];
+        if (!names?.size) {
+            delete out[key];
+            continue;
+        }
+        const pool = out[key];
+        if (names.size === Object.keys(pool).length)
+            continue;
+        out[key] = Object.fromEntries(Object.entries(pool).filter(([name]) => names.has(name)));
+    }
+}
 /**
  * A required argument that is not in `properties` is one no caller can supply and no strict
  * validator will accept. Anything the rewrites above removed, `required` may still name.
@@ -233,6 +337,7 @@ function sanitizeParameters(parameters) {
     if (!isObject(out.properties))
         out.properties = {};
     pruneRequired(out);
+    pruneDefs(out);
     return out;
 }
 /** Rewrites one tool's parameters, leaving a non-function tool alone. */

package/package.json

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