@cubicecho/agent-core 2.25.0 → 3.0.0

package/README.md

@@ -316,7 +316,7 @@ and wrong for what a tool-using run is made of — JSON schemas and tool results
 three characters a token — so a request the guard let through was refused anyway. The divisor is
 learned instead. Every turn `runTurn` answers comes back with the endpoint's exact prompt count for a
 body whose characters were already counted, and `calibrate` keeps that ratio per endpoint and model;
-the next request to the same model is sized by `charsPerTokenFor`, which is `CHARS_PER_TOKEN` (4)
+the next request to the same model is sized by `charsPerTokenFor`, which is four
 until a turn has reported one. It is the highest of the model's last four readings, which is the
 lowest token count: a count that comes out high refuses a run that would have fit, and one that
 comes out low only costs the round trip the guard was saving. A reading from a request carrying an
@@ -349,7 +349,7 @@ large for gpt-4o ... on tokens per min"); that is ruled out and waited through a
 A server still loading the model is waited for on its own clock. llama.cpp answers 503 `Loading
 model` (type `unavailable_error`) until the weights are mapped, thirty to ninety seconds for a large
 model from a cold cache, and a router build says the same while it swaps models; `backoffMs` would
-give up inside fifteen. `isModelLoading` recognises it, and `runTurn` polls every `LOADING_POLL_MS`
+give up inside fifteen. `isModelLoading` recognises it, and `runTurn` polls every three seconds
 for up to `loadingTimeoutMs` (two minutes by default, zero to turn it off) without spending
 `maxRetries`, with one notice at the start. `runAgentLoop` reads it as `loadingTimeoutSeconds` off
 the config. A 503 that says nothing about loading stays on the ordinary backoff.
@@ -985,7 +985,7 @@ not turn the backlog off. `resetEvents` (and `resetAll`) puts the defaults back,
 is not the next one's.
 
 `expandNames`, `carryOver`, `preselection`, `preselectInput` and `preselectSystem` take their caps
-the same way — as a last argument defaulting to `MAX_PER_LOAD` or `MAX_CARRIED`. A resolution
+the same way — as a last argument, which is 12 tools a load and 16 carried unless given. A resolution
 carries the cap it was held to, so `loadResult` tells the model the number it was actually
 measured against rather than the module's own.
 

package/dist/agent-loop.js

@@ -204,7 +204,7 @@ function ownSummariser(options, notice) {
     const call = taskCall(compactor, { signal, onNotice: notice }, config);
     const write = summariser(call.endpoint, call.model, call.options);
     // A summary that fails folds nothing, and the step goes out as it was.
-    return async (text) => (await tryAsk('compaction', () => write(text), { onNotice: notice })) ?? '';
+    return async (text) => (await tryAsk('compaction', () => write(text), { onNotice: notice, signal })) ?? '';
 }
 /**
  * A step's transcript after the loop's own compaction: folded where a fold was due and its summary

package/dist/calibration.d.ts

@@ -1,13 +1,13 @@
 import type OpenAI from 'openai';
 import type { Capabilities } from './capabilities.ts';
 /**
- * The characters per token to size a request to this model with, `CHARS_PER_TOKEN` until a turn
+ * The characters per token to size a request to this model with, four until a turn
  * has reported one.
  *
  * @param supports - The endpoint, as `capabilitiesFor` hands it over.
  * @param model - The name the endpoint knows the model as, as it goes in the body.
  * @returns The highest of the readings held for the model in the current runtime, or
- * `CHARS_PER_TOKEN` where it holds none.
+ * four where it holds none.
  *
  * @remarks
  * The highest of the model's last few readings rather than their mean. The estimate guards a

package/dist/calibration.js

@@ -32,13 +32,13 @@ const PLAUSIBLE = { least: 1, most: 8 };
  */
 const readings = scoped(() => new WeakMap());
 /**
- * The characters per token to size a request to this model with, `CHARS_PER_TOKEN` until a turn
+ * The characters per token to size a request to this model with, four until a turn
  * has reported one.
  *
  * @param supports - The endpoint, as `capabilitiesFor` hands it over.
  * @param model - The name the endpoint knows the model as, as it goes in the body.
  * @returns The highest of the readings held for the model in the current runtime, or
- * `CHARS_PER_TOKEN` where it holds none.
+ * four where it holds none.
  *
  * @remarks
  * The highest of the model's last few readings rather than their mean. The estimate guards a

package/dist/client.d.ts

@@ -66,7 +66,7 @@ export declare const FIRST_TOKEN_FACTOR = 5;
  *
  * @param config - Read for `firstTokenSeconds`, and `requestTimeoutSeconds` where that is absent.
  * @returns Milliseconds. `firstTokenSeconds` where it is given, zero or less being no limit;
- * otherwise `FIRST_TOKEN_FACTOR` request timeouts, and no limit where the request has none.
+ * otherwise five request timeouts, and no limit where the request has none.
  */
 export declare const firstTokenMs: (config: Pick<Endpoint, 'requestTimeoutSeconds' | 'firstTokenSeconds'>) => number | undefined;
 /**

package/dist/client.js

@@ -1,6 +1,6 @@
 import OpenAI from 'openai';
 import { digestOf } from './digest.js';
-import { isPositive } from './guards.js';
+import { byCodeUnit, isPositive } from './guards.js';
 import { MS_PER_SECOND } from './platform.js';
 import { assignSettings, scoped } from './scope.js';
 import { HttpStatus } from './wire.js';
@@ -127,7 +127,7 @@ export const FIRST_TOKEN_FACTOR = 5;
  *
  * @param config - Read for `firstTokenSeconds`, and `requestTimeoutSeconds` where that is absent.
  * @returns Milliseconds. `firstTokenSeconds` where it is given, zero or less being no limit;
- * otherwise `FIRST_TOKEN_FACTOR` request timeouts, and no limit where the request has none.
+ * otherwise five request timeouts, and no limit where the request has none.
  */
 export const firstTokenMs = (config) => {
     if (config.firstTokenSeconds === undefined) {
@@ -466,7 +466,7 @@ export async function listModels(config) {
         }
         models.push({ id: model.id, contextLength: window.contextLength });
     }
-    models.sort((a, b) => a.id.localeCompare(b.id));
+    models.sort((a, b) => byCodeUnit(a.id, b.id));
     const key = endpointKey(config);
     listings().set(key, models);
     trainedOnly().set(key, trained);

package/dist/compaction.d.ts

@@ -107,7 +107,7 @@ export interface CompactionOptions {
      * The divisor the default `estimate` uses — `charsPerTokenFor` the model, for a transcript
      * weighed the way `runTurn` sizes its requests. Ignored beside an `estimate` of the caller's own.
      *
-     * @defaultValue `CHARS_PER_TOKEN`
+     * @defaultValue `4`
      */
     charsPerToken?: number;
     /**

package/dist/config.d.ts

@@ -36,7 +36,7 @@ export interface Endpoint {
     /**
      * How long a streamed turn may wait for its first chunk. Zero or less is no limit.
      *
-     * @defaultValue `FIRST_TOKEN_FACTOR` times `requestTimeoutSeconds`
+     * @defaultValue Five times `requestTimeoutSeconds`
      *
      * @remarks
      * Its own number because the first wait is prefill, and on a local server prefill of a long

package/dist/guards.d.ts

@@ -3,9 +3,10 @@
  *
  * A leaf with no imports, because the modules that need these — a browser-safe `spec`, the schema
  * walk, the tool-call reader, the snapshot importer — otherwise share nothing, and each had grown
- * its own copy. `getOrCreate` and `counted` are here for the same reason and are the two things that
- * are not checks: every cache in the package fills itself on a miss, and each had written that
- * out, and a notice that counts something is written in more than one module.
+ * its own copy. `getOrCreate`, `counted` and `byCodeUnit` are here for the same reason and are the
+ * three things that are not checks: every cache in the package fills itself on a miss, and each had
+ * written that out; a notice that counts something is written in more than one module; and so is a
+ * sort whose order must not depend on the host.
  */
 /**
  * Whether a value is a plain keyed object: not null, and not an array.
@@ -50,4 +51,17 @@ export declare function getOrCreate<K, V>(map: Lookup<K, V>, key: K, create: ()
  * @returns The phrase. Only a count of exactly one is singular: zero reads `0 tools`.
  */
 export declare const counted: (count: number, noun: string) => string;
+/**
+ * Orders two strings by code unit, which is the same on every host.
+ *
+ * @param a - The string on the left.
+ * @param b - The string on the right.
+ * @returns Negative where `a` sorts first, positive where `b` does, zero where they are the same.
+ *
+ * @remarks
+ * Rather than `localeCompare`, whose answer depends on the host's locale. An order the package
+ * relies on — the tool array a prompt cache matches, a tie between two ranked tools, a listing a
+ * host may key on — has to come out the same wherever it runs.
+ */
+export declare function byCodeUnit(a: string, b: string): number;
 export {};

package/dist/guards.js

@@ -3,9 +3,10 @@
  *
  * A leaf with no imports, because the modules that need these — a browser-safe `spec`, the schema
  * walk, the tool-call reader, the snapshot importer — otherwise share nothing, and each had grown
- * its own copy. `getOrCreate` and `counted` are here for the same reason and are the two things that
- * are not checks: every cache in the package fills itself on a miss, and each had written that
- * out, and a notice that counts something is written in more than one module.
+ * its own copy. `getOrCreate`, `counted` and `byCodeUnit` are here for the same reason and are the
+ * three things that are not checks: every cache in the package fills itself on a miss, and each had
+ * written that out; a notice that counts something is written in more than one module; and so is a
+ * sort whose order must not depend on the host.
  */
 /**
  * Whether a value is a plain keyed object: not null, and not an array.
@@ -53,3 +54,24 @@ export function getOrCreate(map, key, create) {
  * @returns The phrase. Only a count of exactly one is singular: zero reads `0 tools`.
  */
 export const counted = (count, noun) => `${count} ${noun}${count === 1 ? '' : 's'}`;
+/**
+ * Orders two strings by code unit, which is the same on every host.
+ *
+ * @param a - The string on the left.
+ * @param b - The string on the right.
+ * @returns Negative where `a` sorts first, positive where `b` does, zero where they are the same.
+ *
+ * @remarks
+ * Rather than `localeCompare`, whose answer depends on the host's locale. An order the package
+ * relies on — the tool array a prompt cache matches, a tie between two ranked tools, a listing a
+ * host may key on — has to come out the same wherever it runs.
+ */
+export function byCodeUnit(a, b) {
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+}

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export { type AgentLoopHooks, type AgentLoopOptions, type AgentLoopRequest, type
 export { calibrate, charsPerTokenFor, resetCalibration } from './calibration.ts';
 export { type Capabilities, capabilitiesFor, EFFORT_LADDER, EFFORT_NONE, EFFORT_OFF, effortFor, expireCapabilities, type ModelCapabilities, modelCapabilitiesFor, type NegotiateOptions, negotiate, resetCapabilities, } from './capabilities.ts';
 export type { CatalogServer } from './catalog.ts';
-export { type ClientPoolOptions, configureClients, contextLimitFor, endpointId, endpointKey, FIRST_TOKEN_FACTOR, firstTokenMs, getClient, listModels, type ModelInfo, NO_KEY, resetClients, resolveApiKey, servedWindow, timeoutMs, } from './client.ts';
+export { type ClientPoolOptions, configureClients, contextLimitFor, endpointId, endpointKey, firstTokenMs, getClient, listModels, type ModelInfo, NO_KEY, resetClients, resolveApiKey, servedWindow, timeoutMs, } from './client.ts';
 export { applyCompaction, COMPACT_AT, type CompactionOptions, type CompactionPlan, type CompactionRecord, type CompactionRunOptions, compactTranscript, KEEP_RATIO, type PruneOptions, planCompaction, pruneToolResults, requestIndex, runCompaction, SUMMARY_LEAD, SUMMARY_PROMPT, summariser, summaryInput, } from './compaction.ts';
 export { type AgentConfig, type Endpoint, type ModelParams, type RetryPolicy, ToolDiscovery, type ToolPolicy, } from './config.ts';
 export { type ContinueTurnOptions, continueTurn, isContinuable, } from './continuation.ts';
@@ -22,10 +22,10 @@ export { configureEvents, type EventBusOptions, emit, endRun, fold, history, typ
 export { HOOK_EVENTS, HookEvent, INJECT_EVENTS } from './hook-events.ts';
 export { assembleContext, configureHooks, consult, type Gathered, gather, HOOK_CONTEXT_TOKENS, HOOK_PREFACE, type HookContext, type HookMessage, type HookNote, type HookOptions, type HookOutcome, type HookRunner, notify, resetHooks, turnIndex, turnMessages, UNTRUSTED_PREFACE, untrusted, withContext, } from './hooks.ts';
 export { estimateFrom, type LedgerEntry, type LedgerEstimateOptions, type LedgerRequest, rebaseLedger, recordRequest, type TokenLedger, tokensBetween, } from './ledger.ts';
-export { KEYWORD_DROPOFF, KEYWORD_MIN_SCORE, type KeywordPreselection, type KeywordPreselectOptions, PRESELECT_SCHEMA, PRESELECT_SYSTEM, preselect, preselectByKeywords, preselectInput, preselection, preselectSystem, type ToolMatch, } from './preselect.ts';
+export { type KeywordPreselection, type KeywordPreselectOptions, PRESELECT_SCHEMA, PRESELECT_SYSTEM, preselect, preselectByKeywords, preselectInput, preselection, preselectSystem, type ToolMatch, } from './preselect.ts';
 export { buildBody } from './request-body.ts';
 export { resetAll } from './reset.ts';
-export { backoffMs, ContextOverflow, EndpointSilent, isModelLoading, isOverflow, isTransient, LOADING_POLL_MS, LOADING_TIMEOUT_MS, SMALLEST_LIKELY_WINDOW, sleep, } from './retry.ts';
+export { backoffMs, ContextOverflow, EndpointSilent, isModelLoading, isOverflow, isTransient, SMALLEST_LIKELY_WINDOW, sleep, } from './retry.ts';
 export { preview } from './run-calls.ts';
 export { type RunTurnOptions, runTurn } from './run-turn.ts';
 export { createRuntime, defaultRuntime, type Runtime, type RuntimeOptions } from './runtime.ts';
@@ -35,7 +35,7 @@ export { CAPABILITY_SNAPSHOT_VERSION, type CapabilitySnapshot, type EndpointSnap
 export { AGENT_SPEC, AGENT_SPEC_VERSION, AGENT_TASKS, type AgentHook, type AgentSpec, type EndpointSpec, type ExportSpecOptions, exportSpec, type ModelSpec, type ParsedSpec, type ParseSpecOptions, type PromptPart, parseSpec, REF_FILE, REF_URL, RESOLVED_DEFAULTS, type ResolvedAgent, type ResolvedTask, type RetrySpec, resolveAgentSpec, SPEC_EVENTS, type SpecBundle, type SpecServer, type TaskSpec, type ToolsSpec, } from './spec.ts';
 export { CacheBreakReason, type Produced, type StreamTurnOptions, streamTurn, type Turn, type TurnUsage, } from './stream.ts';
 export { ALL_FENCES, DEFAULT_FENCES, type Fence, FenceSplitter, type FenceSplitterOptions, SPLIT_OUTPUT, SPLIT_REASONING, type Split, stripThinking, THINK_FENCE, } from './thinking.ts';
-export { CHARS_PER_TOKEN, type ContextBreakdown, type ContextBreakdownOptions, compact, contextChars, contextTokens, estimateTokens, messageTokens, requestChars, requestTokens, type TokenEstimateOptions, toolsChars, } from './tokens.ts';
+export { type ContextBreakdown, type ContextBreakdownOptions, compact, contextChars, contextTokens, estimateTokens, messageTokens, requestChars, requestTokens, type TokenEstimateOptions, toolsChars, } from './tokens.ts';
 export { ARGUMENTS_MALFORMED, ARGUMENTS_TRUNCATED, parseToolArguments, recoverToolCalls, ToolArgumentsError, type ToolCall, type ToolCallOutcome, type ToolCallRequest, type ToolCallResult, } from './tool-calls.ts';
-export { CALL_TOOL, carryOver, catalogList, catalogPrompt, expandNames, holdsDefinitions, inCatalog, LOAD_TOOLS, LOAD_TOOLS_DEFINITION, loadedTools, loadResult, MAX_CARRIED, MAX_PER_LOAD, orderTools, PROXY_TOOLS, proxiedCall, proxyCatalogPrompt, proxyLoadResult, requestedNames, shownCall, type ToolOrder, } from './tool-loading.ts';
+export { CALL_TOOL, carryOver, catalogList, catalogPrompt, expandNames, holdsDefinitions, inCatalog, LOAD_TOOLS, LOAD_TOOLS_DEFINITION, loadedTools, loadResult, orderTools, PROXY_TOOLS, proxiedCall, proxyCatalogPrompt, proxyLoadResult, requestedNames, shownCall, type ToolOrder, } from './tool-loading.ts';
 export { FinishReason, FUNCTION_TOOL, JSON_SCHEMA_FORMAT, PartType, Role, SchemaType } from './wire.ts';

package/dist/index.js

@@ -12,7 +12,7 @@
 export { PRESELECT_APPEND, PRESELECT_EXCLUSIVE, runAgentLoop, } from './agent-loop.js';
 export { calibrate, charsPerTokenFor, resetCalibration } from './calibration.js';
 export { capabilitiesFor, EFFORT_LADDER, EFFORT_NONE, EFFORT_OFF, effortFor, expireCapabilities, modelCapabilitiesFor, negotiate, resetCapabilities, } from './capabilities.js';
-export { configureClients, contextLimitFor, endpointId, endpointKey, FIRST_TOKEN_FACTOR, firstTokenMs, getClient, listModels, NO_KEY, resetClients, resolveApiKey, servedWindow, timeoutMs, } from './client.js';
+export { configureClients, contextLimitFor, endpointId, endpointKey, firstTokenMs, getClient, listModels, NO_KEY, resetClients, resolveApiKey, servedWindow, timeoutMs, } from './client.js';
 export { applyCompaction, COMPACT_AT, compactTranscript, KEEP_RATIO, planCompaction, pruneToolResults, requestIndex, runCompaction, SUMMARY_LEAD, SUMMARY_PROMPT, summariser, summaryInput, } from './compaction.js';
 export { ToolDiscovery, } from './config.js';
 export { continueTurn, isContinuable, } from './continuation.js';
@@ -21,10 +21,10 @@ export { configureEvents, emit, endRun, fold, history, RunEventKind, RunOutcome,
 export { HOOK_EVENTS, HookEvent, INJECT_EVENTS } from './hook-events.js';
 export { assembleContext, configureHooks, consult, gather, HOOK_CONTEXT_TOKENS, HOOK_PREFACE, notify, resetHooks, turnIndex, turnMessages, UNTRUSTED_PREFACE, untrusted, withContext, } from './hooks.js';
 export { estimateFrom, rebaseLedger, recordRequest, tokensBetween, } from './ledger.js';
-export { KEYWORD_DROPOFF, KEYWORD_MIN_SCORE, PRESELECT_SCHEMA, PRESELECT_SYSTEM, preselect, preselectByKeywords, preselectInput, preselection, preselectSystem, } from './preselect.js';
+export { PRESELECT_SCHEMA, PRESELECT_SYSTEM, preselect, preselectByKeywords, preselectInput, preselection, preselectSystem, } from './preselect.js';
 export { buildBody } from './request-body.js';
 export { resetAll } from './reset.js';
-export { backoffMs, ContextOverflow, EndpointSilent, isModelLoading, isOverflow, isTransient, LOADING_POLL_MS, LOADING_TIMEOUT_MS, SMALLEST_LIKELY_WINDOW, sleep, } from './retry.js';
+export { backoffMs, ContextOverflow, EndpointSilent, isModelLoading, isOverflow, isTransient, SMALLEST_LIKELY_WINDOW, sleep, } from './retry.js';
 export { preview } from './run-calls.js';
 export { runTurn } from './run-turn.js';
 export { createRuntime, defaultRuntime } from './runtime.js';
@@ -34,7 +34,7 @@ export { CAPABILITY_SNAPSHOT_VERSION, exportCapabilities, importCapabilities, }
 export { AGENT_SPEC, AGENT_SPEC_VERSION, AGENT_TASKS, exportSpec, parseSpec, REF_FILE, REF_URL, RESOLVED_DEFAULTS, resolveAgentSpec, SPEC_EVENTS, } from './spec.js';
 export { CacheBreakReason, streamTurn, } from './stream.js';
 export { ALL_FENCES, DEFAULT_FENCES, FenceSplitter, SPLIT_OUTPUT, SPLIT_REASONING, stripThinking, THINK_FENCE, } from './thinking.js';
-export { CHARS_PER_TOKEN, compact, contextChars, contextTokens, estimateTokens, messageTokens, requestChars, requestTokens, toolsChars, } from './tokens.js';
+export { compact, contextChars, contextTokens, estimateTokens, messageTokens, requestChars, requestTokens, toolsChars, } from './tokens.js';
 export { ARGUMENTS_MALFORMED, ARGUMENTS_TRUNCATED, parseToolArguments, recoverToolCalls, ToolArgumentsError, } from './tool-calls.js';
-export { CALL_TOOL, carryOver, catalogList, catalogPrompt, expandNames, holdsDefinitions, inCatalog, LOAD_TOOLS, LOAD_TOOLS_DEFINITION, loadedTools, loadResult, MAX_CARRIED, MAX_PER_LOAD, orderTools, PROXY_TOOLS, proxiedCall, proxyCatalogPrompt, proxyLoadResult, requestedNames, shownCall, } from './tool-loading.js';
+export { CALL_TOOL, carryOver, catalogList, catalogPrompt, expandNames, holdsDefinitions, inCatalog, LOAD_TOOLS, LOAD_TOOLS_DEFINITION, loadedTools, loadResult, orderTools, PROXY_TOOLS, proxiedCall, proxyCatalogPrompt, proxyLoadResult, requestedNames, shownCall, } from './tool-loading.js';
 export { FinishReason, FUNCTION_TOOL, JSON_SCHEMA_FORMAT, PartType, Role, SchemaType } from './wire.js';

package/dist/platform.d.ts

@@ -11,3 +11,5 @@ export declare const MS_PER_SECOND = 1000;
 export declare const MS_PER_MINUTE: number;
 /** The event an `AbortSignal` fires when it aborts. */
 export declare const ABORT_EVENT = "abort";
+/** The name an error carries when it is what an aborted `AbortSignal` gave as its reason. */
+export declare const ABORT_ERROR = "AbortError";

package/dist/platform.js

@@ -11,3 +11,5 @@ export const MS_PER_SECOND = 1000;
 export const MS_PER_MINUTE = 60 * MS_PER_SECOND;
 /** The event an `AbortSignal` fires when it aborts. */
 export const ABORT_EVENT = 'abort';
+/** The name an error carries when it is what an aborted `AbortSignal` gave as its reason. */
+export const ABORT_ERROR = 'AbortError';

package/dist/preselect.d.ts

@@ -66,29 +66,6 @@ export declare const preselectInput: (catalog: CatalogServer[], prompt: string,
  * more than `maxPerLoad`. Empty where nothing resolved.
  */
 export declare function preselection(names: unknown, catalog: CatalogServer[], maxPerLoad?: number): string[];
-/**
- * The least a best match may score and still be acted on without a model.
- *
- * @remarks
- * A BM25 score, so it is read against the shape of the corpus rather than as a percentage: a
- * query term carried by half the catalogue is worth about 0.7, and one carried by a single tool
- * about 3. One at this floor is therefore "something more distinctive than a word every other
- * tool uses", which is the weakest evidence worth skipping a round trip on.
- *
- * A term is distinctive only against other terms, so a catalogue of three or four tools rarely
- * clears it. That is the right answer rather than a gap: a catalogue that small is not costing
- * enough tokens to be worth choosing from in the first place.
- */
-export declare const KEYWORD_MIN_SCORE = 1;
-/**
- * How far the best unpicked tool must fall below the last picked one for the cut to count clean.
- *
- * @remarks
- * Half. The cap is the only reason a hit is dropped, so a hit just underneath it scoring nearly
- * as much as one just above means the ranking chose arbitrarily, which is exactly the case a
- * model should be spent on.
- */
-export declare const KEYWORD_DROPOFF = 0.5;
 /** One tool's score against a request. */
 export interface ToolMatch {
     name: string;
@@ -109,19 +86,19 @@ export interface KeywordPreselectOptions {
     /**
      * The most to pick. The same cap the model is held to.
      *
-     * @defaultValue `MAX_PER_LOAD`
+     * @defaultValue `12`
      */
     maxPerLoad?: number;
     /**
      * The floor under a confident best match.
      *
-     * @defaultValue `KEYWORD_MIN_SCORE`
+     * @defaultValue `1`
      */
     minScore?: number;
     /**
      * The gap a confident cut needs.
      *
-     * @defaultValue `KEYWORD_DROPOFF`
+     * @defaultValue `0.5`
      */
     dropoff?: number;
     /**
@@ -184,12 +161,13 @@ export interface PreselectOptions {
     /**
      * The most tools the choice may name.
      *
-     * @defaultValue `MAX_PER_LOAD`
+     * @defaultValue `12`
      */
     maxPerLoad?: number;
     /**
      * Try `preselectByKeywords` first and spend the model only on what it cannot settle. `true`
-     * takes its defaults; an object tunes the thresholds. An empty `model` still means no
+     * takes its defaults; an object tunes the thresholds. Its own `maxPerLoad` can ask the words
+     * for fewer than `maxPerLoad` above, never for more. An empty `model` still means no
      * preselection at all, words included — that is what `toolSelectModel: ""` asks for.
      */
     keywords?: boolean | KeywordPreselectOptions;
@@ -204,8 +182,8 @@ export interface PreselectOptions {
  * @param prompt - The request being planned for. Only its head is read; see `preselectInput`.
  * @param [options] - Cancellation, notices, the reply ceiling, the temperature and reasoning effort
  * as `ask` reads them, the cap the choice is held to, and whether to try the words first.
- * @returns Names as the catalogue spells them. Empty where `model` is empty, the catalogue has no
- * tools, the call failed, or its reply named nothing in the catalogue.
+ * @returns Names as the catalogue spells them, never more than `maxPerLoad`. Empty where `model` is
+ * empty, the catalogue has no tools, the call failed, or its reply named nothing in the catalogue.
  *
  * @remarks
  * On-demand loading otherwise spends a round trip on reading the catalogue and calling

package/dist/preselect.js

@@ -1,4 +1,4 @@
-import { counted, isRecord } from './guards.js';
+import { byCodeUnit, counted, isRecord } from './guards.js';
 import { askJson, tryAsk } from './side-task.js';
 import { catalogList, expandNames, MAX_PER_LOAD } from './tool-loading.js';
 import { SchemaType } from './wire.js';
@@ -112,7 +112,7 @@ const IDF_SMOOTHING = 0.5;
  * clears it. That is the right answer rather than a gap: a catalogue that small is not costing
  * enough tokens to be worth choosing from in the first place.
  */
-export const KEYWORD_MIN_SCORE = 1;
+const KEYWORD_MIN_SCORE = 1;
 /**
  * How far the best unpicked tool must fall below the last picked one for the cut to count clean.
  *
@@ -121,7 +121,7 @@ export const KEYWORD_MIN_SCORE = 1;
  * as much as one just above means the ranking chose arbitrarily, which is exactly the case a
  * model should be spent on.
  */
-export const KEYWORD_DROPOFF = 0.5;
+const KEYWORD_DROPOFF = 0.5;
 /** The longest word `terms` leaves its trailing `s` on: `bus` and `was` are not plurals. */
 const SHORTEST_PLURAL = 3;
 /** What the preselector's reply schema is called on the wire. */
@@ -230,7 +230,7 @@ export function preselectByKeywords(catalog, prompt, { maxPerLoad = MAX_PER_LOAD
     }
     // Ties break on the name, not on where the tool sat in the catalogue, so reconnecting a
     // server in a different order does not change what a run opens with.
-    ranked.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+    ranked.sort((a, b) => b.score - a.score || byCodeUnit(a.name, b.name));
     if (!ranked.length) {
         return empty;
     }
@@ -249,8 +249,8 @@ export function preselectByKeywords(catalog, prompt, { maxPerLoad = MAX_PER_LOAD
  * @param prompt - The request being planned for. Only its head is read; see `preselectInput`.
  * @param [options] - Cancellation, notices, the reply ceiling, the temperature and reasoning effort
  * as `ask` reads them, the cap the choice is held to, and whether to try the words first.
- * @returns Names as the catalogue spells them. Empty where `model` is empty, the catalogue has no
- * tools, the call failed, or its reply named nothing in the catalogue.
+ * @returns Names as the catalogue spells them, never more than `maxPerLoad`. Empty where `model` is
+ * empty, the catalogue has no tools, the call failed, or its reply named nothing in the catalogue.
  *
  * @remarks
  * On-demand loading otherwise spends a round trip on reading the catalogue and calling
@@ -269,9 +269,10 @@ export async function preselect(config, model, catalog, prompt, { signal, onNoti
         return [];
     }
     if (keywords) {
+        const tuned = keywords === true ? {} : keywords;
         const guess = preselectByKeywords(catalog, prompt, {
-            maxPerLoad,
-            ...(keywords === true ? {} : keywords),
+            ...tuned,
+            maxPerLoad: Math.min(maxPerLoad, tuned.maxPerLoad ?? maxPerLoad),
         });
         if (guess.confident) {
             onNotice?.(`chose ${counted(guess.names.length, 'tool')} by name`);
@@ -285,6 +286,6 @@ export async function preselect(config, model, catalog, prompt, { signal, onNoti
         reasoningEffort,
         signal,
         onNotice,
-    }), { onNotice });
+    }), { onNotice, signal });
     return preselection(reply, catalog, maxPerLoad);
 }

package/dist/retry.d.ts

@@ -82,6 +82,21 @@ export declare function isTransient(error: unknown): boolean;
  * latches off whatever the re-send left out.
  */
 export declare const refusesRequest: (error: unknown) => boolean;
+/**
+ * Whether a failure is the caller cancelling, rather than anything going wrong.
+ *
+ * @param error - The rejection, as caught.
+ * @returns `true` for the SDK's `APIUserAbortError` and for any error named `AbortError`, which is
+ * what an aborted signal gives as its reason; `false` for everything else, a timeout included.
+ *
+ * @remarks
+ * An abort reaches a catch in two shapes. The SDK raises its own class when a request in flight is
+ * cancelled, and `sleep` rejects with the signal's reason when the cancel lands between attempts.
+ * A catch that knew only the first reported the second as a failure. A signal aborted with a
+ * reason of the caller's own making is not recognised, since only the error is looked at: a
+ * catch that holds the signal asks it as well, as `tryAsk` does.
+ */
+export declare const isAbort: (error: unknown) => boolean;
 /**
  * Whether a failure is a local server still loading the model, rather than one failing to serve.
  *

package/dist/retry.js

@@ -1,5 +1,5 @@
 import OpenAI from 'openai';
-import { ABORT_EVENT } from './platform.js';
+import { ABORT_ERROR, ABORT_EVENT } from './platform.js';
 import { HttpStatus } from './wire.js';
 /**
  * Everything about a request failing that is not about what the request said.
@@ -126,6 +126,21 @@ export function isTransient(error) {
  */
 export const refusesRequest = (error) => error instanceof OpenAI.APIError &&
     (error.status === HttpStatus.BadRequest || error.status === HttpStatus.UnprocessableEntity);
+/**
+ * Whether a failure is the caller cancelling, rather than anything going wrong.
+ *
+ * @param error - The rejection, as caught.
+ * @returns `true` for the SDK's `APIUserAbortError` and for any error named `AbortError`, which is
+ * what an aborted signal gives as its reason; `false` for everything else, a timeout included.
+ *
+ * @remarks
+ * An abort reaches a catch in two shapes. The SDK raises its own class when a request in flight is
+ * cancelled, and `sleep` rejects with the signal's reason when the cancel lands between attempts.
+ * A catch that knew only the first reported the second as a failure. A signal aborted with a
+ * reason of the caller's own making is not recognised, since only the error is looked at: a
+ * catch that holds the signal asks it as well, as `tryAsk` does.
+ */
+export const isAbort = (error) => error instanceof OpenAI.APIUserAbortError || (error instanceof Error && error.name === ABORT_ERROR);
 /** The error type llama.cpp gives a request it cannot serve yet. */
 const UNAVAILABLE_ERROR = 'unavailable_error';
 /**

package/dist/run-turn.d.ts

@@ -75,10 +75,10 @@ export interface RunTurnOptions extends Omit<StreamTurnOptions, 'produced'> {
      * How long to wait on a server answering that the model is still loading; zero gives up on the
      * first such answer like any other 503.
      *
-     * @defaultValue `LOADING_TIMEOUT_MS`
+     * @defaultValue `120000`
      *
      * @remarks
-     * Polled every `LOADING_POLL_MS` without spending `maxRetries`, and announced once rather than
+     * Polled every three seconds without spending `maxRetries`, and announced once rather than
      * per poll. A consumer that starts alongside its llama.cpp, or asks a router for a model it
      * has to swap in, meets this on its first request every time.
      */

package/dist/schema-compat.js

@@ -381,7 +381,13 @@ function collectRefs(node, into) {
  * outside it still refers in.
  */
 function pruneDefs(schema) {
-    const pools = POOL_KEYS.filter((key) => isRecord(schema[key]));
+    const pools = [];
+    for (const key of POOL_KEYS) {
+        const pool = schema[key];
+        if (isRecord(pool)) {
+            pools.push([key, pool]);
+        }
+    }
     if (!pools.length) {
         return schema;
     }
@@ -411,19 +417,18 @@ function pruneDefs(schema) {
     // 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 = { ...schema };
-    for (const key of pools) {
+    for (const [key] of pools) {
         delete body[key];
     }
     visit(body);
     let pruned = schema;
-    for (const key of pools) {
+    for (const [key, pool] of pools) {
         const names = live[key];
         if (!names?.size) {
             const { [key]: _unreached, ...rest } = pruned;
             pruned = rest;
             continue;
         }
-        const pool = schema[key];
         if (names.size === Object.keys(pool).length) {
             continue;
         }

package/dist/side-task.d.ts

@@ -1,4 +1,4 @@
-import OpenAI from 'openai';
+import type OpenAI from 'openai';
 import { type OnNotice } from './capabilities.ts';
 import type { Endpoint, EndpointIdentity } from './config.ts';
 /**
@@ -154,15 +154,16 @@ export declare function askJson<T>(config: Endpoint, model: string, system: stri
  *
  * @param label - Names the task in the notice when it fails.
  * @param run - The call to attempt. Anything it throws becomes `undefined`, an abort excepted.
- * @param [options] - `onNotice`, told what was given up on.
- * @returns What `run` resolved with, or `undefined` when it threw. An `APIUserAbortError` is thrown
- * on and raises no notice.
+ * @param [options] - `onNotice`, told what was given up on, and the `signal` that `run` is
+ * cancelled by.
+ * @returns What `run` resolved with, or `undefined` when it threw. Whatever it threw once the
+ * signal had aborted is thrown on and raises no notice, as is an error that is itself an abort.
  *
  * @remarks
  * A side task is never worth failing the work it supports. Callers that can carry on without
  * an answer use this and get `undefined` instead of an exception.
  */
-export declare function tryAsk<T>(label: string, run: () => Promise<T>, { onNotice }?: Pick<SideTaskOptions, 'onNotice'>): Promise<T | undefined>;
+export declare function tryAsk<T>(label: string, run: () => Promise<T>, { onNotice, signal }?: Pick<SideTaskOptions, 'onNotice' | 'signal'>): Promise<T | undefined>;
 /**
  * The first array or object in a model's reply, parsed, whatever prose or fence surrounds it.
  *

package/dist/side-task.js

@@ -1,12 +1,11 @@
-import OpenAI from 'openai';
 import { capabilitiesFor, ceilingAndTemperature, EFFORT_NONE, effortFor, modelCapabilitiesFor, negotiate, } from './capabilities.js';
 import { endpointId, getClient, modelKey, resolveApiKey, sameUrl } from './client.js';
 import { errorMessage } from './errors.js';
-import { refusesRequest } from './retry.js';
+import { isAbort, refusesRequest } from './retry.js';
 import { relaxSchema, sanitizeSchema } from './schema-compat.js';
 import { scoped } from './scope.js';
 import { stripThinking } from './thinking.js';
-import { looseJson } from './tool-calls.js';
+import { CODE_FENCE, looseJson } from './tool-calls.js';
 import { JSON_SCHEMA_FORMAT, Role } from './wire.js';
 /**
  * One-shot calls that support a run without being one: picking tools, naming a session,
@@ -234,22 +233,25 @@ export async function askJson(config, model, system, user, schema, { name = 'ans
  *
  * @param label - Names the task in the notice when it fails.
  * @param run - The call to attempt. Anything it throws becomes `undefined`, an abort excepted.
- * @param [options] - `onNotice`, told what was given up on.
- * @returns What `run` resolved with, or `undefined` when it threw. An `APIUserAbortError` is thrown
- * on and raises no notice.
+ * @param [options] - `onNotice`, told what was given up on, and the `signal` that `run` is
+ * cancelled by.
+ * @returns What `run` resolved with, or `undefined` when it threw. Whatever it threw once the
+ * signal had aborted is thrown on and raises no notice, as is an error that is itself an abort.
  *
  * @remarks
  * A side task is never worth failing the work it supports. Callers that can carry on without
  * an answer use this and get `undefined` instead of an exception.
  */
-export async function tryAsk(label, run, { onNotice } = {}) {
+export async function tryAsk(label, run, { onNotice, signal } = {}) {
     try {
         return await run();
     }
     catch (error) {
         // A cancelled run is not a failed side task. Swallowing the abort made the two
-        // indistinguishable and left the cancellation with nowhere to go.
-        if (error instanceof OpenAI.APIUserAbortError) {
+        // indistinguishable and left the cancellation with nowhere to go. The signal is asked first:
+        // an abort with a reason of the caller's own rejects with that reason, which no class names.
+        const wasCancelled = signal?.aborted === true || isAbort(error);
+        if (wasCancelled) {
             throw error;
         }
         onNotice?.(`${label}: ${errorMessage(error)}`);
@@ -274,7 +276,7 @@ export async function tryAsk(label, run, { onNotice } = {}) {
  * a reply as in a call, and a side task that fails over one costs the run a second request.
  */
 export function parseJson(text) {
-    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const [fenced] = text.matchAll(CODE_FENCE);
     const body = (fenced?.[1] ?? text).trim();
     const start = body.search(/[[{]/);
     if (start < 0) {

package/dist/tokens.d.ts

@@ -13,7 +13,7 @@ export declare const CHARS_PER_TOKEN = 4;
  * vocabulary either.
  *
  * @param text - Prose or serialised JSON — both counted the same way, which is why JSON reads low.
- * @returns The length over `CHARS_PER_TOKEN`, rounded up: zero for an empty string, and one for
+ * @returns The length over four, rounded up: zero for an empty string, and one for
  * anything shorter than a token.
  *
  * @remarks
@@ -46,7 +46,7 @@ export interface TokenEstimateOptions {
      * The divisor — `charsPerTokenFor` for a model whose reported usage has calibrated it. A value
      * that is not a number above zero is ignored.
      *
-     * @defaultValue `CHARS_PER_TOKEN`
+     * @defaultValue `4`
      */
     charsPerToken?: number;
 }
@@ -83,7 +83,7 @@ export declare function requestChars(body: OpenAI.ChatCompletionCreateParamsStre
  * What this request will cost the window, in tokens, near enough.
  *
  * @param body - The request as it will be sent, tools included.
- * @param [options] - The divisor, `CHARS_PER_TOKEN` when none is given.
+ * @param [options] - The divisor, four when none is given.
  * @returns Whole tokens: the messages' and the tools', each rounded up on its own and added.
  *
  * @remarks
@@ -172,7 +172,7 @@ export declare function contextTokens(body: OpenAI.ChatCompletionCreateParamsStr
  * One message's estimated tokens, by the same count `requestTokens` sums for a whole request.
  *
  * @param message - The message as it will be sent.
- * @param [options] - The divisor, `CHARS_PER_TOKEN` when none is given.
+ * @param [options] - The divisor, four when none is given.
  * @returns `messageChars` over the divisor, rounded up per message, where `requestTokens` rounds
  * once over them all.
  *

package/dist/tokens.js

@@ -13,7 +13,7 @@ export const CHARS_PER_TOKEN = 4;
  * vocabulary either.
  *
  * @param text - Prose or serialised JSON — both counted the same way, which is why JSON reads low.
- * @returns The length over `CHARS_PER_TOKEN`, rounded up: zero for an empty string, and one for
+ * @returns The length over four, rounded up: zero for an empty string, and one for
  * anything shorter than a token.
  *
  * @remarks
@@ -80,7 +80,7 @@ const REASONING_ALT_KEY = 15;
  * The divisor an option asked for, or the fallback when it asked for nothing usable.
  *
  * @param charsPerToken - What the caller gave. Absent, zero, negative or `NaN` is nothing usable.
- * @returns `charsPerToken` when it is above zero, otherwise `CHARS_PER_TOKEN`.
+ * @returns `charsPerToken` when it is above zero, otherwise four.
  */
 const divisor = (charsPerToken) => charsPerToken !== undefined && charsPerToken > 0 ? charsPerToken : CHARS_PER_TOKEN;
 /**
@@ -197,7 +197,7 @@ export function requestChars(body) {
  * What this request will cost the window, in tokens, near enough.
  *
  * @param body - The request as it will be sent, tools included.
- * @param [options] - The divisor, `CHARS_PER_TOKEN` when none is given.
+ * @param [options] - The divisor, four when none is given.
  * @returns Whole tokens: the messages' and the tools', each rounded up on its own and added.
  *
  * @remarks
@@ -327,7 +327,7 @@ export function contextTokens(body, { charsPerToken, promptTokens } = {}) {
  * One message's estimated tokens, by the same count `requestTokens` sums for a whole request.
  *
  * @param message - The message as it will be sent.
- * @param [options] - The divisor, `CHARS_PER_TOKEN` when none is given.
+ * @param [options] - The divisor, four when none is given.
  * @returns `messageChars` over the divisor, rounded up per message, where `requestTokens` rounds
  * once over them all.
  *

package/dist/tool-calls.d.ts

@@ -14,6 +14,14 @@ export declare const ARGUMENT_PREVIEW_CHARS = 200;
 export declare const ARGUMENTS_TRUNCATED: 'truncated';
 /** The `ToolArgumentsError` kind for a call the model wrote wrongly. */
 export declare const ARGUMENTS_MALFORMED: 'malformed';
+/**
+ * A fenced block in a model's reply, tagged `json` or not tagged; the first group is what it holds.
+ *
+ * @remarks
+ * Global, for `matchAll`, which reads from a copy: nothing here keeps a place in the text between
+ * two uses. What it captures still wants trimming.
+ */
+export declare const CODE_FENCE: RegExp;
 /** A tool call as the loop handles it, recovered or streamed. */
 export type ToolCall = OpenAI.ChatCompletionMessageFunctionToolCall;
 /**

package/dist/tool-calls.js

@@ -16,6 +16,14 @@ export const ARGUMENT_PREVIEW_CHARS = 200;
 export const ARGUMENTS_TRUNCATED = 'truncated';
 /** The `ToolArgumentsError` kind for a call the model wrote wrongly. */
 export const ARGUMENTS_MALFORMED = 'malformed';
+/**
+ * A fenced block in a model's reply, tagged `json` or not tagged; the first group is what it holds.
+ *
+ * @remarks
+ * Global, for `matchAll`, which reads from a copy: nothing here keeps a place in the text between
+ * two uses. What it captures still wants trimming.
+ */
+export const CODE_FENCE = /```(?:json)?\s*([\s\S]*?)```/gi;
 /**
  * Tool arguments that could not be read as an object, with why.
  *
@@ -405,7 +413,7 @@ function bareCalls(text, names) {
             return [{ start, end: read.end, calls }];
         }
     }
-    const fences = [...text.matchAll(/```(?:json)?[ \t]*\n?([\s\S]*?)```/gi)];
+    const fences = [...text.matchAll(CODE_FENCE)];
     if (fences.length !== 1) {
         return [];
     }

package/dist/tool-loading.js

@@ -1,4 +1,4 @@
-import { isRecord } from './guards.js';
+import { byCodeUnit, isRecord } from './guards.js';
 import { ARGUMENT_PREVIEW_CHARS } from './tool-calls.js';
 import { FUNCTION_TOOL, SchemaType } from './wire.js';
 /**
@@ -170,26 +170,6 @@ export function loadedTools(previous, matched) {
     }
     return tools;
 }
-/**
- * Orders two names by code unit.
- *
- * @param a - The name on the left.
- * @param b - The name on the right.
- * @returns Negative where `a` sorts first, positive where `b` does, zero where they are the same.
- *
- * @remarks
- * Rather than `localeCompare`, whose answer depends on the host's locale — which is the kind of
- * instability `orderTools` exists to remove.
- */
-function byCodeUnit(a, b) {
-    if (a < b) {
-        return -1;
-    }
-    if (a > b) {
-        return 1;
-    }
-    return 0;
-}
 /**
  * The tool array in a stable order, so the same set of tools renders the same way twice.
  *

package/llms.txt

@@ -27,7 +27,7 @@ The loop above a turn: send, run the tools the model asked for, send again, unti
 How many characters a token is worth on one model, learned from what its endpoint reports.
 
 - `calibrate` — Takes one reading from a request that was answered, so the next one to this model is sized by it.
-- `charsPerTokenFor` — The characters per token to size a request to this model with, `CHARS_PER_TOKEN` until a turn has reported one.
+- `charsPerTokenFor` — The characters per token to size a request to this model with, four until a turn has reported one.
 - `resetCalibration` — Forgets every reading, so the next request is sized at `CHARS_PER_TOKEN` again.
 
 ### capabilities
@@ -60,7 +60,6 @@ The contract between whatever holds the tools and the loop that offers them to a
 - `contextLimitFor` — How much a model will read, in tokens.
 - `endpointId` — `endpointKey` hashed, for the remembered facts that can leave the process.
 - `endpointKey` — What counts as one endpoint, everywhere in this package that has to remember something about one — the model listings, `capabilities`, and the no-thinking hints in `side-task`.
-- `FIRST_TOKEN_FACTOR` — How many idle windows the first chunk gets when `firstTokenSeconds` is not given.
 - `firstTokenMs` — The wait for a streamed turn's first chunk, in the SDK's spelling: `undefined` is no limit.
 - `getClient` — The client for an endpoint, built once and kept.
 - `listModels` — Asks an endpoint what it serves, and remembers the answer.
@@ -193,8 +192,6 @@ What stretches of a transcript cost, read off the prompt counts the server alrea
 
 Choosing a run's tools before it starts, from the request and the catalogue's names.
 
-- `KEYWORD_DROPOFF` — How far the best unpicked tool must fall below the last picked one for the cut to count clean.
-- `KEYWORD_MIN_SCORE` — The least a best match may score and still be acted on without a model.
 - `KeywordPreselection` (type) — What `preselectByKeywords` found.
 - `KeywordPreselectOptions` (type) — What `preselectByKeywords` takes besides the catalogue and the request.
 - `PRESELECT_SCHEMA` — The shape a preselector's answer is held to where the server takes a schema: `{ tools: [...] }`.
@@ -224,8 +221,6 @@ Everything about a request failing that is not about what the request said.
 - `isModelLoading` — Whether a failure is a local server still loading the model, rather than one failing to serve.
 - `isOverflow` — Whether a refusal means the request was too big, rather than merely refused.
 - `isTransient` — Whether a failed request is worth trying again.
-- `LOADING_POLL_MS` — How long to wait between asking a loading server again.
-- `LOADING_TIMEOUT_MS` — How long `runTurn` waits for a model to load unless told otherwise.
 - `SMALLEST_LIKELY_WINDOW` — The smallest window worth believing in, and the floor under `runTurn`'s guard.
 - `sleep` — A delay an abort cuts short, rejecting rather than resolving early.
 
@@ -345,7 +340,6 @@ Telling a model's scratchpad from its answer when both arrive in `content`.
 
 ### tokens
 
-- `CHARS_PER_TOKEN` — The characters one token is taken to be, where nothing has measured it.
 - `ContextBreakdown` (type) — What a request is made of, by the part of it a consumer can actually do something about.
 - `ContextBreakdownOptions` (type) — What `contextTokens` takes besides the request.
 - `compact` — A token count as a message shows it: 1234 → "1.2k".
@@ -385,8 +379,6 @@ Reading what a model meant by a tool call when it did not write one cleanly.
 - `LOAD_TOOLS_DEFINITION` — One object for the life of the process — the agent loop asks for it on every iteration.
 - `loadedTools` — A tool array with newly loaded definitions appended, in the order they were loaded.
 - `loadResult` — What `load_tools` reports back: the descriptions, now that they are worth their tokens.
-- `MAX_CARRIED` — The most a conversation carries between turns.
-- `MAX_PER_LOAD` — The most a single `load_tools` call may pull in.
 - `orderTools` — The tool array in a stable order, so the same set of tools renders the same way twice.
 - `PROXY_TOOLS` — The whole tool array of a proxied run, `load_tools` then `call_tool`, frozen because it is shared.
 - `proxiedCall` — The tool a `call_tool` names and the arguments to run it with, or a throw the model can read.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubicecho/agent-core",
-  "version": "2.25.0",
+  "version": "3.0.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",
@@ -46,10 +46,10 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json && node scripts/llms-txt.mjs",
-    "prepare": "npm run build",
+    "prepack": "npm run build",
     "check": "npm run check:biome && npm run check:types",
     "check:biome": "biome check --write .",
-    "check:types": "tsc -p tsconfig.tests.json",
+    "check:types": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
     "llms": "node scripts/llms-txt.mjs",