@cubicecho/agent-core 2.0.7 → 2.1.0

package/README.md

@@ -23,7 +23,7 @@ only, Node >=22.
 | `schema-compat` | Makes an MCP tool schema something a strict or grammar-constrained server will accept. `sanitizeTools`, `relaxTools`, `isGrammarError`. |
 | `tool-loading` | On-demand tool discovery: a name-only catalogue plus a `load_tools` meta-tool, so a run pays for the schemas it asks for instead of all of them. |
 | `stream` | Reads one streamed turn back into a message: token callbacks, tool-call reassembly, and the idle watchdog that turns a silent endpoint into `EndpointSilent`. |
-| `capabilities` | What an endpoint turned out not to support, per endpoint, and the loop that answers it when it says so. `capabilitiesFor`, `negotiate`. |
+| `capabilities` | What an endpoint turned out not to support — and, under it, what one model on that endpoint did not — plus the loop that answers either when it says so. `capabilitiesFor`, `modelCapabilitiesFor`, `negotiate`. |
 | `side-task` | One-shot calls that support a run without being one — small prompt, short answer, no tools, never worth failing the run over. |
 | `events` | The in-memory bus a watcher reads while a run happens: `emit`, `watch`, `history`, `fold`. A watcher's backlog is capped and reports its own gaps. |
 | `client` | A pooled `OpenAI` client per endpoint, plus the context-window listing and its cache. |
@@ -70,6 +70,41 @@ const turn = await negotiate(supports, (supports, produced) =>
 );
 ```
 
+## What the model refuses, rather than the server
+
+`strictSchemas` and `usageInStream` are facts about a server. Three more arrive through the same
+channel — an error string on a chat completion — and are facts about a *model*: a
+`reasoning_effort` it does not take, a ceiling it spells `max_completion_tokens`, a temperature
+that is not ours to pick. They cannot latch on the endpoint, because one API key reaches every
+model a provider offers: the first turn on `gpt-4o` would stop `gpt-5` ever being asked to reason
+again, with the setting still reading `high` and nothing anywhere saying it had stopped.
+
+So they hang off the endpoint under the name the endpoint knows the model by. Pass `model` and
+the same loop answers both levels; leave it out and nothing changes.
+
+```ts
+const turn = await negotiate(supports, (supports, produced, model) =>
+  streamTurn(
+    getClient(config),
+    {
+      model: name, messages, stream: true,
+      // Each rebuilt per attempt from what this model has already refused.
+      ...(model?.reasoningEffort ? { reasoning_effort: effort } : {}),
+      ...(model?.legacyTokenLimit ? { max_tokens: limit } : { max_completion_tokens: limit }),
+      ...(model?.chosenTemperature ? { temperature } : {}),
+      tools: supports.strictSchemas ? declared : relaxTools(declared),
+    },
+    { produced, signal },
+  ),
+  { model: name },
+);
+```
+
+`runTurn` takes the same option and hands `request` the same second argument. Keying on
+`(endpoint, model)` rather than the model name alone is the part worth keeping: `gpt-4o` at
+OpenAI and `gpt-4o` behind a proxy need not be the same weights, and one that refused a reasoning
+effort must not speak for the other.
+
 `send` takes a callback rather than a body because the body has to be rebuilt from the latched
 flags. `produced` is one box per attempt — `streamTurn` sets it as soon as the server says
 anything, and the re-send reads it — so a caller with its own retry budget passes one in

package/dist/capabilities.d.ts

@@ -8,7 +8,10 @@ import type { Produced } from "./stream.ts";
  * about the server on the other end rather than about this process, which is what makes them
  * this package's to hold.
  */
-/** What one endpoint turned out not to support. Both start optimistic and only ever latch off. */
+/**
+ * What one endpoint turned out not to support. Both flags start optimistic and only ever latch
+ * off; what is about the model rather than the server hangs off `models`.
+ */
 export interface Capabilities {
     /**
      * llama.cpp-backed servers compile every tool schema into one grammar and reject keywords
@@ -23,14 +26,63 @@ export interface Capabilities {
      * happens: the counts are worth one failed call to find out about, not one per run.
      */
     usageInStream: boolean;
+    /**
+     * What each model reached through this endpoint turned out not to support, by the name the
+     * endpoint knows it as. A second level rather than two more flags beside these, because one
+     * API key reaches every model a provider offers: a flag here would let the first turn on a
+     * model that cannot reason latch "no reasoning" for every later turn on one that can, which
+     * stops asking for it with the setting still reading `high` and nothing anywhere saying it
+     * stopped. Empty until `modelCapabilitiesFor` is asked about a model.
+     */
+    models: Map<string, ModelCapabilities>;
+}
+/**
+ * What one model on that endpoint turned out not to support. All start optimistic and only ever
+ * latch off, the same as the endpoint's own.
+ *
+ * These arrive through the same channel as the endpoint's — an error string on a chat
+ * completion — which is why they are negotiated by the same loop rather than a second one. What
+ * makes them the model's is that the answer differs between two models the same key reaches.
+ */
+export interface ModelCapabilities {
+    /**
+     * Takes a `reasoning_effort` at all. A model that cannot reason refuses the field rather than
+     * ignoring it, so the whole request fails over a setting that means nothing to it.
+     */
+    reasoningEffort: boolean;
+    /**
+     * Spells its ceiling `max_tokens`. The reasoning models want `max_completion_tokens` instead,
+     * and they are exactly the models anyone sets an effort on.
+     */
+    legacyTokenLimit: boolean;
+    /**
+     * Takes a temperature we picked, rather than only the one it was built with. A reasoning model
+     * refuses any other value, including the one a settings row has been showing all along.
+     */
+    chosenTemperature: boolean;
 }
 /**
  * What this endpoint is known not to support. The same object every time, so what `negotiate`
  * latches off stays off.
  *
- * @param baseUrl Identifies the endpoint. These are per-server, not per-model.
+ * @param baseUrl Identifies the endpoint. The two flags on it are per-server; what is
+ * per-model hangs off `models`, which `modelCapabilitiesFor` reads.
  */
 export declare function capabilitiesFor(baseUrl: string): Capabilities;
+/**
+ * What this model on this endpoint is known not to support. The same object every time, so what
+ * `negotiate` latches off stays off.
+ *
+ * Nested under the endpoint rather than keyed by name alone, because `gpt-4o` at OpenAI and
+ * `gpt-4o` behind a proxy need not be the same weights — and a proxy is free to answer to a name
+ * it does not really serve. One that refused a reasoning effort must not speak for the other.
+ * Bounded by the models actually asked for on that endpoint, which is what a dropdown holds.
+ *
+ * @param supports The endpoint's own, as `capabilitiesFor` hands it over.
+ * @param model The name the endpoint knows the model as — whatever goes in the request body,
+ * since that is the only name the refusal is about.
+ */
+export declare function modelCapabilitiesFor(supports: Capabilities, model: string): ModelCapabilities;
 /** Forgets every endpoint's capabilities. For tests, and for a settings change under test. */
 export declare function resetCapabilities(): void;
 /** What `negotiate` takes besides the request. Both optional, both about telling someone. */
@@ -45,6 +97,15 @@ export interface NegotiateOptions {
     produced?: Produced;
     /** Told what was given up on, for a watcher who would otherwise see an unexplained pause. */
     onNotice?: (message: string) => void;
+    /**
+     * Which model this request is for, by the name the endpoint knows it as.
+     *
+     * Given one, the refusals that are about the model rather than the server are answered too,
+     * and `send` is handed what that model has already refused. Left out, nothing changes — which
+     * is the point of it being here rather than a third positional argument: a caller with one
+     * model per endpoint, or one that only ever meets the endpoint's own refusals, needs no edit.
+     */
+    model?: string;
 }
 /**
  * Sends a request, re-sending it each time the answer is this endpoint refusing something the
@@ -57,6 +118,11 @@ export interface NegotiateOptions {
  * what the second one starts knowing. It terminates in at most one pass per capability, since
  * each pass either latches one off for good or rethrows.
  *
+ * One loop over both levels, because a refusal arrives the same way whichever it is about and
+ * one request can meet both. An OpenAI reasoning model has two waiting on its own — the ceiling
+ * is spelled the other way, and then the temperature is not ours to pick — so a loop that
+ * stopped after the first answer would hand the caller the second.
+ *
  * `send` is a thunk rather than a request body because the body has to be rebuilt from the
  * latched flags: `relaxTools` applies to the tools that were just sanitised, and
  * `stream_options` is present or absent rather than adjusted. It is generic over what it
@@ -70,7 +136,9 @@ export interface NegotiateOptions {
  *
  * @param supports What this endpoint has already refused. Latched off further as it refuses more.
  * @param send Builds and sends the request. Called again per downgrade, never once tokens
- * have arrived.
- * @param options `produced` for a caller with its own retry budget, `onNotice` for a watcher.
+ * have arrived. Its third argument is what the named model has refused, absent when no model
+ * was named.
+ * @param options `produced` for a caller with its own retry budget, `onNotice` for a watcher,
+ * `model` to negotiate the model's refusals alongside the endpoint's.
  */
-export declare function negotiate<T>(supports: Capabilities, send: (supports: Capabilities, produced: Produced) => Promise<T>, { produced, onNotice }?: NegotiateOptions): Promise<T>;
+export declare function negotiate<T>(supports: Capabilities, send: (supports: Capabilities, produced: Produced, model: ModelCapabilities | undefined) => Promise<T>, { produced, onNotice, model: name }?: NegotiateOptions): Promise<T>;

package/dist/capabilities.js

@@ -16,24 +16,74 @@ const capabilities = new Map();
  * What this endpoint is known not to support. The same object every time, so what `negotiate`
  * latches off stays off.
  *
- * @param baseUrl Identifies the endpoint. These are per-server, not per-model.
+ * @param baseUrl Identifies the endpoint. The two flags on it are per-server; what is
+ * per-model hangs off `models`, which `modelCapabilitiesFor` reads.
  */
 export function capabilitiesFor(baseUrl) {
     let known = capabilities.get(baseUrl);
     if (!known) {
-        known = { strictSchemas: true, usageInStream: true };
+        known = { strictSchemas: true, usageInStream: true, models: new Map() };
         capabilities.set(baseUrl, known);
     }
     return known;
 }
+/**
+ * What this model on this endpoint is known not to support. The same object every time, so what
+ * `negotiate` latches off stays off.
+ *
+ * Nested under the endpoint rather than keyed by name alone, because `gpt-4o` at OpenAI and
+ * `gpt-4o` behind a proxy need not be the same weights — and a proxy is free to answer to a name
+ * it does not really serve. One that refused a reasoning effort must not speak for the other.
+ * Bounded by the models actually asked for on that endpoint, which is what a dropdown holds.
+ *
+ * @param supports The endpoint's own, as `capabilitiesFor` hands it over.
+ * @param model The name the endpoint knows the model as — whatever goes in the request body,
+ * since that is the only name the refusal is about.
+ */
+export function modelCapabilitiesFor(supports, model) {
+    let known = supports.models.get(model);
+    if (!known) {
+        known = { reasoningEffort: true, legacyTokenLimit: true, chosenTemperature: true };
+        supports.models.set(model, known);
+    }
+    return known;
+}
 /** Forgets every endpoint's capabilities. For tests, and for a settings change under test. */
 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);
+/**
+ * Every latching flag in play on one attempt, endpoint and model together, in a stable order.
+ * Read positionally and only against another reading of the same two objects: what it answers is
+ * whether anything moved while the request was out, and a flag added to either interface later is
+ * compared without an edit here. `models` is not one of them — it is the second level, not a
+ * flag, and the map is the same object throughout.
+ */
+const flagsOf = (supports, model) => [
+    ...Object.values(supports).filter((value) => typeof value === "boolean"),
+    ...(model ? Object.values(model) : []),
+];
 /** `stream_options` is named in the refusal by every server that has not heard of it. */
 const REJECTS_USAGE = /stream_options/i;
+/** A model that cannot reason refuses the field by name. */
+const rejectsEffort = (detail) => /reasoning_effort/i.test(detail);
+/**
+ * Read only alongside the name it is asking for: `'max_tokens' is not supported with this model.
+ * Use 'max_completion_tokens' instead.`
+ *
+ * A bare `max_tokens` complaint is also how a server says the *number* was too large —
+ * `max_tokens is too large: 200000. This model supports at most 16384.` — and the answer to that
+ * is not to send the same number under a different name. It is to let the error out, where
+ * whoever typed the number can see it.
+ */
+const wantsCompletionLimit = (detail) => /max_tokens/i.test(detail) && /max_completion_tokens/i.test(detail);
+/**
+ * `'temperature' does not support 0.7 with this model. Only the default (1) is supported.`
+ *
+ * The qualifier is load-bearing. A temperature out of range is the caller's mistake to see
+ * rather than ours to work around, and dropping the field would hide it.
+ */
+const refusesChosenTemperature = (detail) => /temperature/i.test(detail) && /only the default|does not support/i.test(detail);
 /**
  * Sends a request, re-sending it each time the answer is this endpoint refusing something the
  * request can do without. Returns once the endpoint has answered, or throws if the refusal is
@@ -45,6 +95,11 @@ const REJECTS_USAGE = /stream_options/i;
  * what the second one starts knowing. It terminates in at most one pass per capability, since
  * each pass either latches one off for good or rethrows.
  *
+ * One loop over both levels, because a refusal arrives the same way whichever it is about and
+ * one request can meet both. An OpenAI reasoning model has two waiting on its own — the ceiling
+ * is spelled the other way, and then the temperature is not ours to pick — so a loop that
+ * stopped after the first answer would hand the caller the second.
+ *
  * `send` is a thunk rather than a request body because the body has to be rebuilt from the
  * latched flags: `relaxTools` applies to the tools that were just sanitised, and
  * `stream_options` is present or absent rather than adjusted. It is generic over what it
@@ -58,17 +113,21 @@ const REJECTS_USAGE = /stream_options/i;
  *
  * @param supports What this endpoint has already refused. Latched off further as it refuses more.
  * @param send Builds and sends the request. Called again per downgrade, never once tokens
- * have arrived.
- * @param options `produced` for a caller with its own retry budget, `onNotice` for a watcher.
+ * have arrived. Its third argument is what the named model has refused, absent when no model
+ * was named.
+ * @param options `produced` for a caller with its own retry budget, `onNotice` for a watcher,
+ * `model` to negotiate the model's refusals alongside the endpoint's.
  */
-export async function negotiate(supports, send, { produced = { any: false }, onNotice } = {}) {
+export async function negotiate(supports, send, { produced = { any: false }, onNotice, model: name } = {}) {
+    const model = name === undefined ? undefined : modelCapabilitiesFor(supports, name);
     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 };
+        // What this attempt was built with. `capabilitiesFor` and `modelCapabilitiesFor` hand one
+        // object per endpoint and per model to everyone on them, 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 = flagsOf(supports, model);
         try {
-            return await send(supports, produced);
+            return await send(supports, produced, model);
         }
         catch (error) {
             if (produced.any)
@@ -82,7 +141,19 @@ export async function negotiate(supports, send, { produced = { any: false }, onN
                 supports.usageInStream = false;
                 onNotice?.("server rejected stream_options; token counts unavailable");
             }
-            else if (keys(sent).every((flag) => sent[flag] === supports[flag])) {
+            else if (model?.reasoningEffort && rejectsEffort(detail)) {
+                model.reasoningEffort = false;
+                onNotice?.("model does not take a reasoning effort; retrying without one");
+            }
+            else if (model?.legacyTokenLimit && wantsCompletionLimit(detail)) {
+                model.legacyTokenLimit = false;
+                onNotice?.("model wants max_completion_tokens; retrying with the limit spelled that way");
+            }
+            else if (model?.chosenTemperature && refusesChosenTemperature(detail)) {
+                model.chosenTemperature = false;
+                onNotice?.("model takes only its own temperature; retrying without ours");
+            }
+            else if (flagsOf(supports, model).every((flag, index) => flag === sent[index])) {
                 throw error;
             }
             // Otherwise the refusal was answered by whoever got there first, and this attempt was

package/dist/index.d.ts

@@ -9,7 +9,7 @@
  * prompts, and whatever the run is about — because that is the caller's, and it is the part
  * that differs between one server and the next.
  */
-export { type Capabilities, capabilitiesFor, type NegotiateOptions, negotiate, resetCapabilities, } from "./capabilities.ts";
+export { type Capabilities, capabilitiesFor, type ModelCapabilities, modelCapabilitiesFor, type NegotiateOptions, negotiate, resetCapabilities, } from "./capabilities.ts";
 export type { CatalogServer } from "./catalog.ts";
 export { contextLimitFor, getClient, listModels, type ModelInfo, NO_KEY, resetClients, timeoutMs, } from "./client.ts";
 export type { AgentConfig, Endpoint, ModelParams, RetryPolicy, ToolPolicy, } from "./config.ts";

package/dist/index.js

@@ -9,7 +9,7 @@
  * prompts, and whatever the run is about — because that is the caller's, and it is the part
  * that differs between one server and the next.
  */
-export { capabilitiesFor, negotiate, resetCapabilities, } from "./capabilities.js";
+export { capabilitiesFor, modelCapabilitiesFor, negotiate, resetCapabilities, } from "./capabilities.js";
 export { contextLimitFor, getClient, listModels, NO_KEY, resetClients, timeoutMs, } from "./client.js";
 export { errorMessage } from "./errors.js";
 export { emit, endRun, fold, history, resetEvents, watch, } from "./events.js";

package/dist/run-turn.d.ts

@@ -1,13 +1,14 @@
 import type OpenAI from "openai";
-import { type Capabilities } from "./capabilities.ts";
+import { type Capabilities, type ModelCapabilities } from "./capabilities.ts";
 import { type StreamTurnOptions, type Turn } from "./stream.ts";
 /**
  * One turn, given as many attempts as the caller allows.
  *
  * Two different things are being recovered from here, and they nest. The inner one is a
- * capability the endpoint turns out not to have — `stream_options`, a grammar keyword — which
- * is a refusal: it is answered by sending a lesser request, and it latches against that
- * endpoint for the life of the process, so it costs one failed call rather than one a run.
+ * capability the endpoint turns out not to have — `stream_options`, a grammar keyword — or that
+ * the model does not, given `model` below. Either is a refusal: it is answered by sending a
+ * lesser request, and it latches for the life of the process against the endpoint or against
+ * that one model on it, so it costs one failed call rather than one a run.
  * The outer one is the endpoint being unreachable, busy or silent, which is not about this
  * request at all and is worth simply waiting out.
  *
@@ -40,6 +41,15 @@ export interface RunTurnOptions extends Omit<StreamTurnOptions, "produced"> {
      * run over one would be the guard failing exactly the callers it was meant to help.
      */
     contextLimit?: number;
+    /**
+     * Which model the body names, so the refusals that are about the model rather than the server
+     * are negotiated too — a reasoning effort it does not take, a token ceiling it spells the
+     * other way, a temperature that is not ours to pick. Left out, only the endpoint's own are.
+     *
+     * It is given here rather than read off the body because the body is built from the answer:
+     * `request` has to know what this model refused before it can build one that avoids it.
+     */
+    model?: string;
 }
 /**
  * `request` is a callback rather than a body because the body has to be rebuilt from whatever
@@ -49,7 +59,9 @@ export interface RunTurnOptions extends Omit<StreamTurnOptions, "produced"> {
  *
  * @param client The pooled client for this endpoint.
  * @param supports What the endpoint has already refused, threaded through the negotiation.
- * @param request Builds the body. Called again per attempt, since a downgrade changes it.
- * @param options Retry budget, context limit, notices, and the stream's own callbacks.
+ * @param request Builds the body. Called again per attempt, since a downgrade changes it. Its
+ * second argument is what the model named in `options.model` has refused, absent when none was.
+ * @param options Retry budget, context limit, the model to negotiate for, notices, and the
+ * stream's own callbacks.
  */
-export declare function runTurn(client: OpenAI, supports: Capabilities, request: (supports: Capabilities) => OpenAI.ChatCompletionCreateParamsStreaming, { maxRetries, onNotice, contextLimit, ...stream }?: RunTurnOptions): Promise<Turn>;
+export declare function runTurn(client: OpenAI, supports: Capabilities, request: (supports: Capabilities, model: ModelCapabilities | undefined) => OpenAI.ChatCompletionCreateParamsStreaming, { maxRetries, onNotice, contextLimit, model, ...stream }?: RunTurnOptions): Promise<Turn>;

package/dist/run-turn.js

@@ -10,17 +10,19 @@ import { streamTurn } from "./stream.js";
  *
  * @param client The pooled client for this endpoint.
  * @param supports What the endpoint has already refused, threaded through the negotiation.
- * @param request Builds the body. Called again per attempt, since a downgrade changes it.
- * @param options Retry budget, context limit, notices, and the stream's own callbacks.
+ * @param request Builds the body. Called again per attempt, since a downgrade changes it. Its
+ * second argument is what the model named in `options.model` has refused, absent when none was.
+ * @param options Retry budget, context limit, the model to negotiate for, notices, and the
+ * stream's own callbacks.
  */
-export async function runTurn(client, supports, request, { maxRetries = 0, onNotice, contextLimit = 0, ...stream } = {}) {
+export async function runTurn(client, supports, request, { maxRetries = 0, onNotice, contextLimit = 0, model, ...stream } = {}) {
     // Sized once rather than per build. `request` is called again for every downgrade and every
     // retry, but a downgraded body is strictly smaller than the one before it and the transcript
     // does not change between attempts — so the first body is the one worth measuring, and
     // measuring the rest would only spend the walk again to reach the same answer.
     let sized = false;
-    const measured = (capabilities) => {
-        const body = request(capabilities);
+    const measured = (capabilities, forModel) => {
+        const body = request(capabilities, forModel);
         if (!sized && contextLimit >= SMALLEST_LIKELY_WINDOW) {
             sized = true;
             const needed = requestTokens(body);
@@ -36,7 +38,7 @@ export async function runTurn(client, supports, request, { maxRetries = 0, onNot
     for (let attempt = 0;; attempt++) {
         const produced = { any: false };
         try {
-            return await negotiate(supports, (capabilities, box) => streamTurn(client, measured(capabilities), { ...stream, produced: box }), { produced, onNotice });
+            return await negotiate(supports, (capabilities, box, forModel) => streamTurn(client, measured(capabilities, forModel), { ...stream, produced: box }), { produced, onNotice, model });
         }
         catch (error) {
             // The abort is read before the classification, not after. A run stopped by its operator

package/dist/schema-compat.js

@@ -232,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.
@@ -259,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/llms.txt

@@ -15,6 +15,8 @@ What an endpoint turned out not to support, and answering it when it says so.
 
 - `Capabilities` (type) — What one endpoint turned out not to support.
 - `capabilitiesFor` — What this endpoint is known not to support.
+- `ModelCapabilities` (type) — What one model on that endpoint turned out not to support.
+- `modelCapabilitiesFor` — What this model on this endpoint is known not to support.
 - `NegotiateOptions` (type) — What `negotiate` takes besides the request.
 - `negotiate` — Sends a request, re-sending it each time the answer is this endpoint refusing something the request can do without.
 - `resetCapabilities` — Forgets every endpoint's capabilities.

package/package.json

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