@cubicecho/agent-core 2.0.5 → 2.0.7

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;
             }

package/dist/side-task.js

@@ -61,7 +61,16 @@ function rejectedTheRequest(error) {
  * model that spends it deliberating is cut off mid-scratchpad and the closing tag never
  * arrives — and the whole deliberation was then returned to the caller as the answer.
  */
-const stripThinking = (text) => text.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/<think>[\s\S]*$/i, "");
+const stripThinking = (text) => text
+    .replace(/<think>[\s\S]*?<\/think>/gi, "")
+    .replace(/<think>[\s\S]*$/i, "")
+    // And the fence that never opens. Several chat templates put the opening tag at the end of
+    // the prompt rather than leaving the model to write it, so what comes back is deliberation
+    // first and only the closing tag to mark where it stops. Neither pattern above matches that,
+    // and the whole scratchpad went to the caller as the answer — a session title, a tool
+    // preselection, a suggestion list. Every real `<think>` is gone by this point, so a `</think>`
+    // still here opened in the prompt; the first one is taken, which keeps the most text.
+    .replace(/^[\s\S]*?<\/think>/i, "");
 /**
  * Runs a side task and returns the reply text, thinking stripped. Throws like any request.
  *

package/package.json

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