@cubicecho/agent-core 2.23.0 → 2.25.0

package/dist/wire.d.ts

@@ -0,0 +1,81 @@
+/**
+ * The words the chat-completions wire is written in, each under a name.
+ *
+ * A leaf with no imports, because every module that builds a message or reads one needs these and
+ * they share nothing else. The `openai` types still say which word a field takes — these are the
+ * same literals, so a message built from them is checked exactly as one built from strings — and
+ * what the names add is that a role or a finish reason is spelled in one place.
+ */
+/** Who a message is from. */
+export declare const Role: {
+    /** The instructions a conversation opens with. */
+    readonly System: 'system';
+    /** What a reasoning model takes in place of `system`. */
+    readonly Developer: 'developer';
+    /** The person, or whatever stands in for one. */
+    readonly User: 'user';
+    /** The model. */
+    readonly Assistant: 'assistant';
+    /** A tool's result, answering the call whose id it carries. */
+    readonly Tool: 'tool';
+};
+/** Any one of the roles in `Role`. */
+export type Role = (typeof Role)[keyof typeof Role];
+/** Why a model stopped writing. */
+export declare const FinishReason: {
+    /** It was done. */
+    readonly Stop: 'stop';
+    /** It ran into the reply ceiling, and what it wrote is cut off. */
+    readonly Length: 'length';
+    /** It asked for tools. */
+    readonly ToolCalls: 'tool_calls';
+    /** A filter withheld the reply. */
+    readonly ContentFilter: 'content_filter';
+};
+/** Any one of the reasons in `FinishReason`. */
+export type FinishReason = (typeof FinishReason)[keyof typeof FinishReason];
+/** What a part of a message's content is. */
+export declare const PartType: {
+    /** Text. */
+    readonly Text: 'text';
+    /** The model declining, in place of an answer. */
+    readonly Refusal: 'refusal';
+    /** An image, by URL or inline. */
+    readonly ImageUrl: 'image_url';
+    /** An attached file. */
+    readonly File: 'file';
+};
+/** Any one of the part types in `PartType`. */
+export type PartType = (typeof PartType)[keyof typeof PartType];
+/** The types JSON Schema has, as the `type` keyword spells them. */
+export declare const SchemaType: {
+    readonly Object: 'object';
+    readonly Array: 'array';
+    readonly String: 'string';
+    readonly Number: 'number';
+    readonly Integer: 'integer';
+    readonly Boolean: 'boolean';
+    readonly Null: 'null';
+};
+/** Any one of the types in `SchemaType`. */
+export type SchemaType = (typeof SchemaType)[keyof typeof SchemaType];
+/** The one `type` a tool definition or a tool call has on this wire. */
+export declare const FUNCTION_TOOL: 'function';
+/** The `response_format` type that carries a schema the reply has to fit. */
+export declare const JSON_SCHEMA_FORMAT: 'json_schema';
+/** The HTTP statuses this package reads a meaning into. */
+export declare const HttpStatus: {
+    readonly Ok: 200;
+    readonly BadRequest: 400;
+    readonly Unauthorized: 401;
+    readonly NotFound: 404;
+    readonly MethodNotAllowed: 405;
+    readonly RequestTimeout: 408;
+    readonly Conflict: 409;
+    readonly UnprocessableEntity: 422;
+    readonly TooManyRequests: 429;
+    /** The first of the 5xx range, and so the floor of "the server's fault". */
+    readonly InternalServerError: 500;
+    readonly NotImplemented: 501;
+    readonly ServiceUnavailable: 503;
+};

package/dist/wire.js

@@ -0,0 +1,73 @@
+/**
+ * The words the chat-completions wire is written in, each under a name.
+ *
+ * A leaf with no imports, because every module that builds a message or reads one needs these and
+ * they share nothing else. The `openai` types still say which word a field takes — these are the
+ * same literals, so a message built from them is checked exactly as one built from strings — and
+ * what the names add is that a role or a finish reason is spelled in one place.
+ */
+/** Who a message is from. */
+export const Role = {
+    /** The instructions a conversation opens with. */
+    System: 'system',
+    /** What a reasoning model takes in place of `system`. */
+    Developer: 'developer',
+    /** The person, or whatever stands in for one. */
+    User: 'user',
+    /** The model. */
+    Assistant: 'assistant',
+    /** A tool's result, answering the call whose id it carries. */
+    Tool: 'tool',
+};
+/** Why a model stopped writing. */
+export const FinishReason = {
+    /** It was done. */
+    Stop: 'stop',
+    /** It ran into the reply ceiling, and what it wrote is cut off. */
+    Length: 'length',
+    /** It asked for tools. */
+    ToolCalls: 'tool_calls',
+    /** A filter withheld the reply. */
+    ContentFilter: 'content_filter',
+};
+/** What a part of a message's content is. */
+export const PartType = {
+    /** Text. */
+    Text: 'text',
+    /** The model declining, in place of an answer. */
+    Refusal: 'refusal',
+    /** An image, by URL or inline. */
+    ImageUrl: 'image_url',
+    /** An attached file. */
+    File: 'file',
+};
+/** The types JSON Schema has, as the `type` keyword spells them. */
+export const SchemaType = {
+    Object: 'object',
+    Array: 'array',
+    String: 'string',
+    Number: 'number',
+    Integer: 'integer',
+    Boolean: 'boolean',
+    Null: 'null',
+};
+/** The one `type` a tool definition or a tool call has on this wire. */
+export const FUNCTION_TOOL = 'function';
+/** The `response_format` type that carries a schema the reply has to fit. */
+export const JSON_SCHEMA_FORMAT = 'json_schema';
+/** The HTTP statuses this package reads a meaning into. */
+export const HttpStatus = {
+    Ok: 200,
+    BadRequest: 400,
+    Unauthorized: 401,
+    NotFound: 404,
+    MethodNotAllowed: 405,
+    RequestTimeout: 408,
+    Conflict: 409,
+    UnprocessableEntity: 422,
+    TooManyRequests: 429,
+    /** The first of the 5xx range, and so the floor of "the server's fault". */
+    InternalServerError: 500,
+    NotImplemented: 501,
+    ServiceUnavailable: 503,
+};

package/llms.txt

@@ -17,16 +17,10 @@ The loop above a turn: send, run the tools the model asked for, send again, unti
 - `AgentLoopOptions` (type) — What `runAgentLoop` takes.
 - `AgentLoopRequest` (type) — One step's request as `onRequest` is handed it: what the model is about to read.
 - `AgentLoopResult` (type) — What a finished loop hands back.
-- `buildBody` — The one place a streamed request's body is decided from a config and what the endpoint and the model have refused.
-- `preselect` — The tools a request is likely to need, picked by a small model before the run starts, or none.
-- `preview` — A long tool argument or result cut to what a watcher needs, with the full length said.
-- `resolveApiKey` — The key to send, where an endpoint may inherit one from the settings it overrides.
+- `PRESELECT_APPEND` — The `preselectRouting` that loads the shortlist after what was carried, and sends the first step like any other.
+- `PRESELECT_EXCLUSIVE` — The `preselectRouting` that sends the first step the shortlist alone.
 - `runAgentLoop` — Runs a question to its answer: one `runTurn` per step, the tools it asks for between them, until a turn asks for none.
 - `StepWindow` (type) — How full the window is as a step is about to be sent, as `beforeStep` is told it.
-- `ToolCallOutcome` (type) — What one tool call did, in the order the model asked.
-- `ToolCallRequest` (type) — One call the model made, as `dispatch` and `onToolCall` are handed it.
-- `ToolCallResult` (type) — One call's whole answer, as `onToolResult` is handed it.
-- `taskCall` — A side task's settings as the call that honours them: its endpoint, its model, and the options `ask`, `askJson`, `summariser` and `preselect` take last.
 
 ### calibration
 
@@ -43,6 +37,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.
 - `EFFORT_LADDER` — The efforts this package can place, cheapest first.
+- `EFFORT_NONE` — The lowest effort the wire has a word for, which is what a side task asks for.
+- `EFFORT_OFF` — The setting that asks for no `reasoning_effort` field at all.
 - `effortFor` — What to actually put in `reasoning_effort` for a model that has refused the value asked for.
 - `expireCapabilities` — Forgets every endpoint whose entry is older than this, so the next request finds out again.
 - `ModelCapabilities` (type) — What one model on that endpoint turned out not to support.
@@ -71,8 +67,9 @@ The contract between whatever holds the tools and the loop that offers them to a
 - `ModelInfo` (type) — A model an endpoint offers, and what it says the model will read.
 - `NO_KEY` — The SDK insists on a non-empty key even where the server will not look at it.
 - `resetClients` — Forgets every cached client and listing, and puts `configureClients` back to the defaults.
+- `resolveApiKey` — The key to send, where an endpoint may inherit one from the settings it overrides.
 - `servedWindow` — The window a local server's own API says it is serving a model in, for the servers whose listing does not say.
-- `timeoutMs` — Zero, less, or absent means no limit, which the SDK spells as `undefined`.
+- `timeoutMs` — An endpoint's request timeout in the SDK's spelling: milliseconds, and `undefined` for no limit.
 
 ### compaction
 
@@ -104,6 +101,7 @@ What this package needs to know about a caller's configuration.
 - `Endpoint` (type) — Where to send a request and how long to wait.
 - `ModelParams` (type) — What to ask the model for.
 - `RetryPolicy` (type) — How many times a lost or refused request is worth sending again.
+- `ToolDiscovery` — Any one of the modes in `ToolDiscovery`.
 - `ToolPolicy` (type) — How tools reach the model, and how long it may keep calling them.
 
 ### continuation
@@ -131,19 +129,28 @@ What a run is doing, while it is doing it.
 - `EventBusOptions` (type) — What the bus keeps and for how long.
 - `emit` — Records one event and hands it to everyone watching that run.
 - `endRun` — Forgets a run that will not be emitting `done` — one whose process is tearing down, or whose loop threw where it could not be caught.
-- `fold` — Consecutive tokens of one kind are one thing being said, not hundreds of things.
+- `fold` — A run's events with each stretch of `thinking` or of `output` joined into one block, for a reader that takes a run in snapshots.
 - `history` — The backlog alone, for a caller that wants a snapshot rather than a subscription.
 - `RunEvent` (type) — One thing that happened in a run, as a watcher receives it.
 - `RunEventInput` (type) — What `emit` is given: the run and the sequence are the bus's to assign.
-- `RunEventKind` (type) — Which kind of thing happened, and what `text`, `name`, `ok` and `usage` carry for it.
+- `RunEventKind` — Any one of the kinds in `RunEventKind`.
 - `RunMetrics` (type) — A run summed and derived from its events: what it cost, where the time went, and why.
 - `RunMetricsOptions` (type) — What `runMetrics` takes besides the events.
+- `RunOutcome` — Any one of the outcomes in `RunOutcome`.
 - `RunUsage` (type) — What a run has spent, counted from the start of the run rather than for the turn that carried it: a client draws the latest one it has seen and needs no arithmetic of its own, and one lost to the backlog cap costs nothing because the next supersedes it.
 - `resetEvents` — Test seam: forget every run, so one test's events cannot be read by the next.
 - `runMetrics` — A run's totals, timings and cache findings, derived from the events it emitted.
 - `TurnReport` (type) — One turn's usage and measurements as a `usage` event carries them.
 - `watch` — Everything that has happened on a run, then everything that happens next, until it ends.
 
+### hook-events
+
+The points in a session a hook can be bound to, apart from everything that runs one.
+
+- `HOOK_EVENTS` — Every event a hook can be bound to, in the order a session meets them.
+- `HookEvent` — Any one of the events in `HookEvent`.
+- `INJECT_EVENTS` — The events whose hooks run before a request, and so the only ones whose output can reach it.
+
 ### hooks
 
 Lifecycle hooks, from the host's side: what a session looks like to them, where their context lands in a request, and what is said about each one.
@@ -154,16 +161,13 @@ Lifecycle hooks, from the host's side: what a session looks like to them, where
 - `Gathered` (type) — The context a set of outcomes adds to a request, and a note for each hook worth mentioning.
 - `gather` — Runs the hooks ahead of a request and builds what they add to it.
 - `HOOK_CONTEXT_TOKENS` — The most context all of a request's hooks add between them by default, in estimated tokens.
-- `HOOK_EVENTS` — Every event a hook can be bound to, in the order a session meets them.
 - `HOOK_PREFACE` — Said once, above the blocks, so the model reads them as background rather than instructions.
 - `HookContext` (type) — What a host knows at an event.
-- `HookEvent` (type) — A point in a session a hook can be bound to.
 - `HookMessage` (type) — One message of a session as a hook is handed it.
 - `HookNote` (type) — One hook's line for whoever is watching: the context it added, or why it added none.
 - `HookOptions` (type) — What hooks are held to across a process.
 - `HookOutcome` (type) — What one hook did.
 - `HookRunner` (type) — Runs one event's hooks.
-- `INJECT_EVENTS` — The events whose hooks run before a request, and so the only ones whose output can reach it.
 - `notify` — Runs the hooks for an event that reads what happened and adds nothing to a request.
 - `resetHooks` — Test seam: puts `configureHooks` back to the defaults, so one test's budget or preface is not the next's.
 - `turnIndex` — Which turn of a session begins at a point, from 0: the user messages ahead of it.
@@ -185,6 +189,27 @@ What stretches of a transcript cost, read off the prompt counts the server alrea
 - `TokenLedger` (type) — A transcript's entries in the order their requests were sent, which is also by `through`.
 - `tokensBetween` — What the messages from `from` up to, not including, `to` cost the window, measured where the ledger can say and estimated where it cannot.
 
+### preselect
+
+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: [...] }`.
+- `PRESELECT_SYSTEM` — The preselection system prompt at the default cap, for a caller that never changes it.
+- `preselect` — The tools a request is likely to need, picked by a small model before the run starts, or none.
+- `preselectByKeywords` — The tools a request's own words point at, ranked, and whether they point clearly enough.
+- `preselectInput` — The user message for a preselection call: the catalogue, then the request.
+- `preselection` — Resolves a preselection against the catalogue: unknown names dropped, count capped.
+- `preselectSystem` — The system prompt a preselector is given, holding it to the cap its answer will be held to.
+- `ToolMatch` (type) — One tool's score against a request.
+
+### request-body
+
+- `buildBody` — The one place a streamed request's body is decided from a config and what the endpoint and the model have refused.
+
 ### reset
 
 - `resetAll` — Forgets everything this package remembers between calls.
@@ -193,34 +218,29 @@ What stretches of a transcript cost, read off the prompt counts the server alrea
 
 Everything about a request failing that is not about what the request said.
 
-- `backoffMs` — Exponential, with jitter so several tasks failing at once do not return in lockstep.
-- `CHARS_PER_TOKEN` — The divisor behind `estimateTokens`, applied here to a character count rather than a string.
-- `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.
+- `backoffMs` — How long to wait before a retry: exponential, with jitter so several tasks failing at once do not return in lockstep.
 - `ContextOverflow` — The request was bigger than the model will read.
-- `compact` — 1234 → "1.2k".
-- `contextChars` — What each part of a request is worth in characters, by the same walk `requestTokens` divides.
-- `contextTokens` — What each part of a request costs the window, in tokens, adding up to the whole.
 - `EndpointSilent` — The endpoint stopped answering mid-request.
 - `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.
-- `messageTokens` — One message's estimated tokens, by the same count `requestTokens` sums for a whole request.
-- `requestChars` — How many characters a request is worth: the walk `requestTokens` divides, without the division.
-- `requestTokens` — What this request will cost the window, in tokens, near enough.
 - `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.
-- `TokenEstimateOptions` (type) — What the two token estimates below take besides what they measure.
-- `toolsChars` — How many characters a tool array is worth, measured once per array.
+
+### run-calls
+
+The tools between two turns: a step's calls read, run and written into the transcript.
+
+- `preview` — A long tool argument or result cut to what a watcher needs, with the full length said.
 
 ### run-turn
 
 One turn, given as many attempts as the caller allows.
 
 - `RunTurnOptions` (type) — A retry is not the same event as a downgrade, but a watcher wants to be told about both.
-- `runTurn` — `request` is a callback rather than a body because the body has to be rebuilt from whatever the last attempt latched off: the tools it sends depend on `strictSchemas`, and `relaxTools` has to apply to the schemas that were just sanitised.
+- `runTurn` — One turn seen through to an answer: negotiated with the endpoint, retried where the failure is transient, and waited for where the model is still loading.
 
 ### runtime
 
@@ -233,8 +253,10 @@ One turn, given as many attempts as the caller allows.
 
 JSON Schema compatibility for llama.cpp-backed servers.
 
-- `isGrammarError` — Does this failure look like the server could not build a grammar from our tool schemas?
-- `relaxTools` — The retry shape: llama.cpp's converter rejects regex escape classes (`\d`, `\w`, `\s`) in `pattern` and most `format` values, both of which only ever narrowed a string the tool re-validates anyway.
+- `isGrammarError` — Whether a failure looks like the server could not build a grammar from our tool schemas.
+- `relaxSchema` — One schema without its `pattern` and `format` keywords, for a schema that is not a tool's.
+- `relaxTools` — The tool array with every schema's `pattern` and `format` keywords gone — the shape a turn is retried with.
+- `sanitizeSchema` — One JSON Schema as a strict server will accept it, for a schema that is not a tool's parameters.
 - `sanitizeTools` — Tool definitions a strict server will accept, remembered per definition object.
 
 ### side-task
@@ -246,12 +268,13 @@ One-shot calls that support a run without being one: picking tools, naming a ses
 - `askJson` — A side task whose answer is JSON matching a schema, parsed.
 - `clean` — Strips the quoting and list punctuation models decorate short answers with.
 - `listLines` — A list-shaped reply, one item per line, cleaned of the bullets and quotes models decorate them with.
-- `parseJson` — Models are asked for JSON and often answer with prose around it, or a fenced block.
+- `parseJson` — The first array or object in a model's reply, parsed, whatever prose or fence surrounds it.
 - `resetHints` — Test seam, alongside `resetClients` and `resetAll`: forget which models refused the hints.
 - `SideTask` (type) — One side task's own settings, as a resolved agent spec carries them under `tasks.<key>`.
 - `SideTaskInput` (type) — The input a side task applies its instruction to: text, or the content parts a vision model reads.
 - `SideTaskOptions` (type) — What a side task may be given.
-- `tryAsk` — A side task is never worth failing the work it supports.
+- `taskCall` — A side task's settings as the call that honours them: its endpoint, its model, and the options `ask`, `askJson`, `summariser` and `preselect` take last.
+- `tryAsk` — Runs a side task and answers `undefined` where it fails, so the work it supports carries on.
 
 ### snapshot
 
@@ -281,12 +304,14 @@ A JSON document that defines an agent, and the rules for reading one.
 - `ParseSpecOptions` (type) — What `parseSpec` takes besides the document.
 - `PromptPart` (type) — One layer of system prompt, named so a layer above can stack beside it or replace it.
 - `parseSpec` — Reads a document, dropping what it cannot use and refusing only what it cannot identify.
+- `REF_FILE` — The `ref.type` of a prompt part whose text is in a file.
+- `REF_URL` — The `ref.type` of a prompt part whose text is behind a URL.
 - `RESOLVED_DEFAULTS` — What a field falls back to when no layer said anything at all.
 - `ResolvedAgent` (type) — What layered documents resolve to: the flat shape the loop already takes, plus the parts of an agent that are the host's to act on.
 - `ResolvedTask` (type) — One side task, resolved: a model, and the endpoint it is reached through.
 - `RetrySpec` (type) — What to do about a request lost before the model produced anything.
 - `resolveAgentSpec` — Layers documents into the flat object the loop takes, weakest first.
-- `SPEC_EVENTS` — Every event a hook may be bound to, restated so this module stays free of `node:crypto`.
+- `SPEC_EVENTS` — Every event a hook may be bound to: `HOOK_EVENTS`, under the name a document's reader knows.
 - `SpecBundle` (type) — What an agent carries so it can travel whole: the definitions of the servers it names.
 - `SpecServer` (type) — A bundled MCP server, validated only as far as a round trip needs and otherwise passed through.
 - `TaskSpec` (type) — One side task, which may run on a different model — and a different machine — than the agent.
@@ -296,6 +321,7 @@ A JSON document that defines an agent, and the rules for reading one.
 
 Reading one streamed turn back into a message.
 
+- `CacheBreakReason` — Any one of the reasons in `CacheBreakReason`.
 - `Produced` (type) — Whether the model has said anything a second attempt would say twice.
 - `StreamTurnOptions` (type) — What `streamTurn` takes besides the request body.
 - `streamTurn` — Runs one turn as a stream, reporting tokens as they arrive and assembling them back into a message.
@@ -311,22 +337,40 @@ Telling a model's scratchpad from its answer when both arrive in `content`.
 - `Fence` (type) — One way a model marks off its scratchpad inside `content`.
 - `FenceSplitter` — A state machine over a stream of `content` that routes fenced text to reasoning.
 - `FenceSplitterOptions` (type) — What `FenceSplitter` takes besides its fences.
+- `SPLIT_OUTPUT` — What a `Split` is called when it was not.
+- `SPLIT_REASONING` — What a `Split` is called when it was inside a fence.
 - `Split` (type) — A piece of `content`, said to be one or the other.
 - `stripThinking` — What is left of a complete reply once every scratchpad is taken out of it.
 - `THINK_FENCE` — DeepSeek, Qwen3, QwQ and most distills.
 
 ### 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".
+- `contextChars` — What each part of a request is worth in characters, by the same walk `requestTokens` divides.
+- `contextTokens` — What each part of a request costs the window, in tokens, adding up to the whole.
 - `estimateTokens` — Rough token count.
+- `messageTokens` — One message's estimated tokens, by the same count `requestTokens` sums for a whole request.
+- `requestChars` — How many characters a request is worth: the walk `requestTokens` divides, without the division.
+- `requestTokens` — What this request will cost the window, in tokens, near enough.
+- `TokenEstimateOptions` (type) — What the two token estimates below take besides what they measure.
+- `toolsChars` — How many characters a tool array is worth, measured once per array.
 
 ### tool-calls
 
 Reading what a model meant by a tool call when it did not write one cleanly.
 
+- `ARGUMENTS_MALFORMED` — The `ToolArgumentsError` kind for a call the model wrote wrongly.
+- `ARGUMENTS_TRUNCATED` — The `ToolArgumentsError` kind for a call cut off at the reply ceiling.
 - `parseToolArguments` — A tool call's arguments as the object the tool is handed.
 - `recoverToolCalls` — Tool calls a model wrote into its reply as text, taken out of it and made into calls.
 - `ToolArgumentsError` — Tool arguments that could not be read as an object, with why.
 - `ToolCall` (type) — A tool call as the loop handles it, recovered or streamed.
+- `ToolCallOutcome` (type) — What one tool call did, in the order the model asked.
+- `ToolCallRequest` (type) — One call the model made, as `dispatch` and `onToolCall` are handed it.
+- `ToolCallResult` (type) — One call's whole answer, as `onToolResult` is handed it.
 
 ### tool-loading
 
@@ -337,10 +381,6 @@ Reading what a model meant by a tool call when it did not write one cleanly.
 - `expandNames` — Resolves requested names against the catalogue, expanding trailing `*` wildcards.
 - `holdsDefinitions` — Whether a tool result is a proxied load carrying definitions, which is the only copy of them the model has.
 - `inCatalog` — Whether the catalogue holds a tool by this name.
-- `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.
 - `LOAD_TOOLS` — On-demand tool loading.
 - `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.
@@ -348,17 +388,21 @@ Reading what a model meant by a tool call when it did not write one cleanly.
 - `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.
-- `PRESELECT_SCHEMA` — The shape a preselector's answer is held to where the server takes a schema: `{ tools: [...] }`.
-- `PRESELECT_SYSTEM` — The preselection system prompt at the default cap, for a caller that never changes it.
 - `PROXY_TOOLS` — The whole tool array of a proxied run, `load_tools` then `call_tool`, frozen because it is shared.
-- `preselectByKeywords` — The tools a request's own words point at, ranked, and whether they point clearly enough.
-- `preselectInput` — The user message for a preselection call: the catalogue, then the request.
-- `preselection` — Resolves a preselection against the catalogue: unknown names dropped, count capped.
-- `preselectSystem` — The system prompt a preselector is given, holding it to the cap its answer will be held to.
 - `proxiedCall` — The tool a `call_tool` names and the arguments to run it with, or a throw the model can read.
 - `proxyCatalogPrompt` — The catalogue block for a proxied run's system prompt, worded for `call_tool` rather than for a tool list.
 - `proxyLoadResult` — What a proxied `load_tools` answers: each new tool's whole definition as a line of JSON, since the result is the only place the model will ever see it.
 - `requestedNames` — `load_tools` arguments, defensively — a model may send a bare string or a nested object.
 - `shownCall` — A tool call as a watcher should see it: a `call_tool` as the tool it ran, anything else as it is.
-- `ToolMatch` (type) — One tool's score against a request.
 - `ToolOrder` (type) — How a tool array is ordered before it is sent: `true` by name, `false` as the caller built it, or a comparator over the two names.
+
+### wire
+
+The words the chat-completions wire is written in, each under a name.
+
+- `FinishReason` — Any one of the reasons in `FinishReason`.
+- `FUNCTION_TOOL` — The one `type` a tool definition or a tool call has on this wire.
+- `JSON_SCHEMA_FORMAT` — The `response_format` type that carries a schema the reply has to fit.
+- `PartType` — Any one of the part types in `PartType`.
+- `Role` — Any one of the roles in `Role`.
+- `SchemaType` — Any one of the types in `SchemaType`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubicecho/agent-core",
-  "version": "2.23.0",
+  "version": "2.25.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",
@@ -47,13 +47,13 @@
   "scripts": {
     "build": "tsc -p tsconfig.build.json && node scripts/llms-txt.mjs",
     "prepare": "npm run build",
-    "typecheck": "tsc -p tsconfig.tests.json",
+    "check": "npm run check:biome && npm run check:types",
+    "check:biome": "biome check --write .",
+    "check:types": "tsc -p tsconfig.tests.json",
     "test": "vitest run",
     "test:watch": "vitest",
     "llms": "node scripts/llms-txt.mjs",
     "llms:check": "node scripts/llms-txt.mjs --check",
-    "lint": "biome check .",
-    "format": "biome check --write .",
     "bench": "vitest bench --run",
     "coverage": "vitest run --coverage"
   },