@cubicecho/agent-core 2.21.1 → 2.23.0

package/dist/runtime.d.ts

@@ -0,0 +1,120 @@
+import { preselect, runAgentLoop } from "./agent-loop.ts";
+import { calibrate, charsPerTokenFor, resetCalibration } from "./calibration.ts";
+import { capabilitiesFor, expireCapabilities, resetCapabilities } from "./capabilities.ts";
+import { type ClientPoolOptions, configureClients, contextLimitFor, getClient, listModels, resetClients, servedWindow } from "./client.ts";
+import { compactTranscript, runCompaction, summariser } from "./compaction.ts";
+import { continueTurn } from "./continuation.ts";
+import { configureEvents, type EventBusOptions, emit, endRun, history, resetEvents, watch } from "./events.ts";
+import { assembleContext, configureHooks, consult, gather, type HookOptions, notify, resetHooks, withContext } from "./hooks.ts";
+import { resetAll } from "./reset.ts";
+import { runTurn } from "./run-turn.ts";
+import { ask, askJson, resetHints, tryAsk } from "./side-task.ts";
+import { exportCapabilities, importCapabilities } from "./snapshot.ts";
+/**
+ * Every exported function that reads or writes what a runtime remembers, itself or through what
+ * it calls. The rest of the package is pure, and is the same function whichever runtime it is
+ * called beside.
+ */
+declare const STATEFUL: {
+    runAgentLoop: typeof runAgentLoop;
+    preselect: typeof preselect;
+    runTurn: typeof runTurn;
+    continueTurn: typeof continueTurn;
+    ask: typeof ask;
+    askJson: typeof askJson;
+    tryAsk: typeof tryAsk;
+    summariser: typeof summariser;
+    runCompaction: typeof runCompaction;
+    compactTranscript: typeof compactTranscript;
+    getClient: typeof getClient;
+    listModels: typeof listModels;
+    contextLimitFor: typeof contextLimitFor;
+    servedWindow: typeof servedWindow;
+    configureClients: typeof configureClients;
+    capabilitiesFor: typeof capabilitiesFor;
+    expireCapabilities: typeof expireCapabilities;
+    exportCapabilities: typeof exportCapabilities;
+    importCapabilities: typeof importCapabilities;
+    calibrate: typeof calibrate;
+    charsPerTokenFor: typeof charsPerTokenFor;
+    emit: typeof emit;
+    endRun: typeof endRun;
+    history: typeof history;
+    watch: typeof watch;
+    configureEvents: typeof configureEvents;
+    configureHooks: typeof configureHooks;
+    gather: typeof gather;
+    notify: typeof notify;
+    consult: typeof consult;
+    assembleContext: typeof assembleContext;
+    withContext: typeof withContext;
+    resetClients: typeof resetClients;
+    resetCapabilities: typeof resetCapabilities;
+    resetCalibration: typeof resetCalibration;
+    resetHints: typeof resetHints;
+    resetEvents: typeof resetEvents;
+    resetHooks: typeof resetHooks;
+    resetAll: typeof resetAll;
+};
+/** What a runtime starts out configured with. Every field optional; see `createRuntime`. */
+export interface RuntimeOptions {
+    /** The client pool's bounds, as `configureClients` takes them. */
+    clients?: ClientPoolOptions;
+    /** The event bus's bounds, as `configureEvents` takes them. */
+    events?: EventBusOptions;
+    /** The hooks' budget and preface, as `configureHooks` takes them. */
+    hooks?: HookOptions;
+}
+/**
+ * One set of the package's caches, with the functions that use them as methods.
+ *
+ * Each method is the top-level function of the same name, with the same signature and doc
+ * comment, run against this runtime's state instead of the process's: its pooled clients and
+ * model listings, latched capabilities, measured characters per token, no-thinking hints, event
+ * bus, and hook settings. `resetAll` and the six narrower resets clear this runtime alone.
+ */
+export type Runtime = typeof STATEFUL & {
+    /**
+     * Runs `fn` with this runtime current, so every top-level function it calls — directly, after
+     * an `await`, or from a timer it sets — uses this runtime's state. What the methods do, for
+     * code that calls the top-level functions itself.
+     *
+     * It does not reach a callback that outlives `fn` and is called from elsewhere — a generator
+     * resumed later, a function handed back and called by someone else. Call a method there.
+     *
+     * @param fn What to run. Its return value, or what it throws, is handed straight back.
+     */
+    run<T>(fn: () => T): T;
+};
+/**
+ * A runtime of its own: separate clients, listings, capability latches, hints, event bus and hook
+ * settings from the process's and from every other runtime's.
+ *
+ * For a host that must not share them — one that mints a key per tenant, where a shared pool has
+ * tenants evicting each other's clients and a shared bus has one tenant's run id readable by
+ * another — and for tests, where a runtime per case needs no `resetAll` between them and can run
+ * in parallel. A host with one deployment's worth of endpoints does not need one: the top-level
+ * functions are the default runtime's methods.
+ *
+ * The runtime is carried by async context rather than by argument, so `runAgentLoop` called as a
+ * method uses this runtime all the way down, and so does a top-level function the host calls from
+ * inside it — from `dispatch`, a hook, `onEvent`. Outside a method or `run`, a top-level function
+ * is the default runtime's again; a request handler that emits to a run a runtime started calls
+ * `runtime.emit`.
+ *
+ * Nothing needs closing. A runtime is garbage once nothing holds it; its one timer, the event
+ * bus's sweep, is unreferenced and stops rescheduling when its last run has been swept.
+ *
+ * @param options What to configure it with before first use. A part left out keeps the
+ * defaults — not the default runtime's settings, which a new runtime does not inherit.
+ */
+export declare function createRuntime(options?: RuntimeOptions): Runtime;
+/**
+ * The runtime the top-level functions use when no other is running.
+ *
+ * `defaultRuntime.getClient(endpoint)` and `getClient(endpoint)` are the same call outside any
+ * runtime. Inside one they differ: the top-level function follows the runtime that is running,
+ * and this always reaches the process-wide state.
+ */
+export declare const defaultRuntime: Runtime;
+export {};

package/dist/runtime.js

@@ -0,0 +1,113 @@
+import { preselect, runAgentLoop } from "./agent-loop.js";
+import { calibrate, charsPerTokenFor, resetCalibration } from "./calibration.js";
+import { capabilitiesFor, expireCapabilities, resetCapabilities } from "./capabilities.js";
+import { configureClients, contextLimitFor, getClient, listModels, resetClients, servedWindow, } from "./client.js";
+import { compactTranscript, runCompaction, summariser } from "./compaction.js";
+import { continueTurn } from "./continuation.js";
+import { configureEvents, emit, endRun, history, resetEvents, watch, } from "./events.js";
+import { assembleContext, configureHooks, consult, gather, notify, resetHooks, withContext, } from "./hooks.js";
+import { resetAll } from "./reset.js";
+import { runTurn } from "./run-turn.js";
+import { inScope, rootScope } from "./scope.js";
+import { ask, askJson, resetHints, tryAsk } from "./side-task.js";
+import { exportCapabilities, importCapabilities } from "./snapshot.js";
+/**
+ * Every exported function that reads or writes what a runtime remembers, itself or through what
+ * it calls. The rest of the package is pure, and is the same function whichever runtime it is
+ * called beside.
+ */
+const STATEFUL = {
+    runAgentLoop,
+    preselect,
+    runTurn,
+    continueTurn,
+    ask,
+    askJson,
+    tryAsk,
+    summariser,
+    runCompaction,
+    compactTranscript,
+    getClient,
+    listModels,
+    contextLimitFor,
+    servedWindow,
+    configureClients,
+    capabilitiesFor,
+    expireCapabilities,
+    exportCapabilities,
+    importCapabilities,
+    calibrate,
+    charsPerTokenFor,
+    emit,
+    endRun,
+    history,
+    watch,
+    configureEvents,
+    configureHooks,
+    gather,
+    notify,
+    consult,
+    assembleContext,
+    withContext,
+    resetClients,
+    resetCapabilities,
+    resetCalibration,
+    resetHints,
+    resetEvents,
+    resetHooks,
+    resetAll,
+};
+/** Makes the methods of the runtime whose state is `scope`. */
+function bind(scope) {
+    const within = (fn) => (...args) => inScope(scope, () => fn(...args));
+    const methods = Object.fromEntries(Object.entries(STATEFUL).map(([name, fn]) => [
+        name,
+        within(fn),
+    ]));
+    return {
+        ...methods,
+        // What it hands back is called later, by `compactTranscript` or by the host, and asks then.
+        summariser: (...args) => within(summariser(...args)),
+        run: (fn) => inScope(scope, fn),
+    };
+}
+/**
+ * A runtime of its own: separate clients, listings, capability latches, hints, event bus and hook
+ * settings from the process's and from every other runtime's.
+ *
+ * For a host that must not share them — one that mints a key per tenant, where a shared pool has
+ * tenants evicting each other's clients and a shared bus has one tenant's run id readable by
+ * another — and for tests, where a runtime per case needs no `resetAll` between them and can run
+ * in parallel. A host with one deployment's worth of endpoints does not need one: the top-level
+ * functions are the default runtime's methods.
+ *
+ * The runtime is carried by async context rather than by argument, so `runAgentLoop` called as a
+ * method uses this runtime all the way down, and so does a top-level function the host calls from
+ * inside it — from `dispatch`, a hook, `onEvent`. Outside a method or `run`, a top-level function
+ * is the default runtime's again; a request handler that emits to a run a runtime started calls
+ * `runtime.emit`.
+ *
+ * Nothing needs closing. A runtime is garbage once nothing holds it; its one timer, the event
+ * bus's sweep, is unreferenced and stops rescheduling when its last run has been swept.
+ *
+ * @param options What to configure it with before first use. A part left out keeps the
+ * defaults — not the default runtime's settings, which a new runtime does not inherit.
+ */
+export function createRuntime(options = {}) {
+    const runtime = bind(new Map());
+    if (options.clients)
+        runtime.configureClients(options.clients);
+    if (options.events)
+        runtime.configureEvents(options.events);
+    if (options.hooks)
+        runtime.configureHooks(options.hooks);
+    return runtime;
+}
+/**
+ * The runtime the top-level functions use when no other is running.
+ *
+ * `defaultRuntime.getClient(endpoint)` and `getClient(endpoint)` are the same call outside any
+ * runtime. Inside one they differ: the top-level function follows the runtime that is running,
+ * and this always reaches the process-wide state.
+ */
+export const defaultRuntime = bind(rootScope);

package/dist/scope.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Everything one runtime remembers: each module's state, under a key only that module holds.
+ *
+ * A map rather than a record of named caches, so a module that grows a cache declares it where
+ * it is used and `runtime.ts` does not have to hear about it.
+ */
+export type Scope = Map<symbol, unknown>;
+/** The default runtime's scope: what the top-level functions use when no runtime is running. */
+export declare const rootScope: Scope;
+/** The scope of the runtime whose method is running, or the default one outside any. */
+export declare const currentScope: () => Scope;
+/**
+ * Runs `fn` with `scope` as the current one, for it and for everything it awaits or schedules.
+ *
+ * @param scope The runtime's state. Nested calls replace it for their own duration only.
+ * @param fn What to run. Its return value, or what it throws, is handed straight back.
+ */
+export declare const inScope: <T>(scope: Scope, fn: () => T) => T;
+/** One module's state, read from whichever scope is current. See `scoped`. */
+export interface Scoped<T> {
+    /** The current scope's copy, made on first use. */
+    (): T;
+    /** Drops the current scope's copy, so the next read makes a fresh one. */
+    reset(): void;
+}
+/**
+ * Declares a piece of module state that every runtime has its own copy of.
+ *
+ * What used to be `const cache = new Map()` at the top of a module is `scoped(() => new Map())`,
+ * and each use reads `cache()`. The copy is made lazily, so a runtime pays only for the modules
+ * it touches.
+ *
+ * @param create Builds a fresh, empty copy. Called once per scope, and again after `reset`.
+ */
+export declare function scoped<T>(create: () => T): Scoped<T>;

package/dist/scope.js

@@ -0,0 +1,42 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+/**
+ * Which scope the code running now belongs to, carried across every `await` beneath a runtime's
+ * method. Async context rather than a parameter, because the state is read five calls down —
+ * `runAgentLoop` to `runTurn` to `negotiate` to `capabilitiesFor` — and threading it would put a
+ * runtime argument on every exported function in between.
+ */
+const active = new AsyncLocalStorage();
+/** The default runtime's scope: what the top-level functions use when no runtime is running. */
+export const rootScope = new Map();
+/** The scope of the runtime whose method is running, or the default one outside any. */
+export const currentScope = () => active.getStore() ?? rootScope;
+/**
+ * Runs `fn` with `scope` as the current one, for it and for everything it awaits or schedules.
+ *
+ * @param scope The runtime's state. Nested calls replace it for their own duration only.
+ * @param fn What to run. Its return value, or what it throws, is handed straight back.
+ */
+export const inScope = (scope, fn) => active.run(scope, fn);
+/**
+ * Declares a piece of module state that every runtime has its own copy of.
+ *
+ * What used to be `const cache = new Map()` at the top of a module is `scoped(() => new Map())`,
+ * and each use reads `cache()`. The copy is made lazily, so a runtime pays only for the modules
+ * it touches.
+ *
+ * @param create Builds a fresh, empty copy. Called once per scope, and again after `reset`.
+ */
+export function scoped(create) {
+    const key = Symbol();
+    const read = () => {
+        const scope = currentScope();
+        if (!scope.has(key))
+            scope.set(key, create());
+        return scope.get(key);
+    };
+    return Object.assign(read, {
+        reset: () => {
+            currentScope().delete(key);
+        },
+    });
+}

package/dist/side-task.d.ts

@@ -20,10 +20,22 @@ export declare const resetHints: () => void;
 export type SideTaskInput = string | OpenAI.ChatCompletionContentPart[];
 /** What a side task may be given. All optional — one given none of them still runs. */
 export interface SideTaskOptions {
-    /** Ceiling on the reply, default 512. These answers are meant to be short. */
+    /**
+     * Ceiling on the reply, default 512. These answers are meant to be short. Zero or less sends
+     * none and leaves it to the server, which is what `maxTokens: 0` means on the main model too.
+     */
     maxTokens?: number;
     /** Sampling temperature, default 0.3. Naming and classifying want the same answer twice. */
     temperature?: number;
+    /**
+     * A reasoning effort to ask for in place of the no-thinking hints, for a side task an operator
+     * has pointed at a model that should deliberate — a compaction summary is the usual one.
+     *
+     * Absent, `""` and `"off"` all keep the hints, because off is what they already ask for. Any
+     * other value is sent as `reasoning_effort`, stepped up by `effortFor` where the model has
+     * refused it by value, and `chat_template_kwargs` is left out of the request altogether.
+     */
+    reasoningEffort?: string;
     /** Abandons the call, usually because the run it supports has gone away. */
     signal?: AbortSignal;
     /**
@@ -40,6 +52,27 @@ export interface SideTaskOptions {
      */
     onNotice?: (message: string) => void;
 }
+/**
+ * One side task's own settings, as a resolved agent spec carries them under `tasks.<key>`.
+ *
+ * Declared here rather than imported from `spec.ts`, whose `ResolvedTask` it matches field for
+ * field: the spec module is one nothing else in `src/` imports, and a host that is not on the spec
+ * can write one of these by hand. An absent setting is the side task's own default — 0.3, the
+ * entry point's ceiling, thinking off — and never the main model's, so raising the agent's
+ * temperature for the chat does not make its titler creative. See `taskCall`.
+ */
+export interface SideTask {
+    /** The model that does the task. */
+    model: string;
+    /** Where that model is reached, which need not be where the agent's is. */
+    endpoint: Endpoint;
+    /** The reply's ceiling. Absent is the entry point's default; zero sends none. */
+    maxTokens?: number;
+    /** Absent is 0.3, whatever the agent's own temperature is. Zero means zero. */
+    temperature?: number;
+    /** As `SideTaskOptions.reasoningEffort`: a level replaces the no-thinking hints. */
+    reasoningEffort?: string;
+}
 /**
  * Runs a side task and returns the reply text, thinking stripped. Throws like any request.
  *
@@ -47,7 +80,7 @@ export interface SideTaskOptions {
  * @param model The model to ask, usually smaller than the one running the work.
  * @param system The instruction.
  * @param user The input it applies to. Content parts where the model is being shown an image.
- * @param options Reply ceiling, temperature, cancellation, notices.
+ * @param options Reply ceiling, temperature, a reasoning effort, cancellation, notices.
  */
 export declare function ask(config: Endpoint, model: string, system: string, user: SideTaskInput, options?: SideTaskOptions): Promise<string>;
 /** What `askJson` takes besides a side task's options. */

package/dist/side-task.js

@@ -4,6 +4,7 @@ import { endpointId, getClient } from "./client.js";
 import { errorMessage } from "./errors.js";
 import { isTransient } from "./retry.js";
 import { relaxTools, sanitizeTools } from "./schema-compat.js";
+import { scoped } from "./scope.js";
 import { stripThinking } from "./thinking.js";
 /**
  * One-shot calls that support a run without being one: picking tools, naming a session,
@@ -39,13 +40,13 @@ const NO_THINKING = { chat_template_kwargs: { enable_thinking: false } };
  * Only the `chat_template_kwargs` half is here. `reasoning_effort` is `negotiate`'s to latch, on
  * the same (endpoint, model) pair, where a run on that model can read it too.
  */
-const noHints = new Set();
+const noHints = scoped(() => new Set());
 /** An (endpoint, model) pair as `noHints` holds it: `[endpointId, model]`, stringified. */
 export const hintKey = (endpoint, model) => JSON.stringify([endpoint, model]);
 /** The pairs that refused the hints, the live set, for `exportCapabilities` and `importCapabilities`. */
-export const refusedHints = () => noHints;
+export const refusedHints = () => noHints();
 /** Test seam, alongside `resetClients` and `resetAll`: forget which models refused the hints. */
-export const resetHints = () => noHints.clear();
+export const resetHints = () => noHints().clear();
 /**
  * Whether a failure is the server complaining about the request, rather than failing to answer.
  *
@@ -72,7 +73,7 @@ function rejectedTheRequest(error) {
  * @param model The model to ask, usually smaller than the one running the work.
  * @param system The instruction.
  * @param user The input it applies to. Content parts where the model is being shown an image.
- * @param options Reply ceiling, temperature, cancellation, notices.
+ * @param options Reply ceiling, temperature, a reasoning effort, cancellation, notices.
  */
 export function ask(config, model, system, user, options = {}) {
     return complete(config, model, system, user, options);
@@ -81,22 +82,29 @@ export function ask(config, model, system, user, options = {}) {
  * The request `ask` and `askJson` share, with `format` deciding the extra body fields from what
  * the model and the endpoint have refused, rebuilt on every re-send.
  */
-async function complete(config, model, system, user, { maxTokens = 512, temperature = 0.3, signal, onNotice }, format) {
+async function complete(config, model, system, user, { maxTokens = 512, temperature = 0.3, reasoningEffort, signal, onNotice }, format) {
+    // The effort the caller chose, or empty where it chose none: `""` and `"off"` read as absent,
+    // since off is what the hints below already ask for.
+    const level = effortFor(undefined, reasoningEffort);
     // Whether the last request carried an effort, which `negotiate` decides and not this function.
     let sentEffort = false;
     const send = (hints, effort, supports, refused) => {
         // `none` is what a side task wants and not always what the model offers: OpenAI's reasoning
         // models refuse it by value and list `minimal` as their floor. `effortFor` answers with the
         // cheapest rung this one takes, which `negotiate` has been stepping up as it was refused.
-        const asked = effort ? effortFor(refused, "none") : "";
+        // A level the caller chose goes through the same ladder, which only ever steps up from it.
+        const asked = effort ? effortFor(refused, level || "none") : "";
         sentEffort = asked !== "";
         return getClient(config).chat.completions.create({
             model,
             // The reasoning models want the ceiling spelled the other way, and they are exactly the
-            // models a side task most wants to stop deliberating.
-            ...(refused && !refused.legacyTokenLimit
-                ? { max_completion_tokens: maxTokens }
-                : { max_tokens: maxTokens }),
+            // models a side task most wants to stop deliberating. Zero is no ceiling, as it is on the
+            // main model: a spec's `maxTokens: 0` sent as `max_tokens: 0` asks for an empty reply.
+            ...(maxTokens > 0
+                ? refused && !refused.legacyTokenLimit
+                    ? { max_completion_tokens: maxTokens }
+                    : { max_tokens: maxTokens }
+                : {}),
             // One that will only run at the temperature it was built with is sent none: a side task
             // wants the same answer twice, and 1.0 from that model is as close as it gets.
             ...(refused && !refused.chosenTemperature ? {} : { temperature }),
@@ -121,7 +129,9 @@ async function complete(config, model, system, user, { maxTokens = 512, temperat
         onNotice,
     });
     const key = hintKey(endpointId(config), model);
-    const hints = !noHints.has(key);
+    // A chosen effort replaces the template hint rather than riding beside it: `enable_thinking:
+    // false` next to `reasoning_effort: "high"` is a request that contradicts itself.
+    const hints = !level && !noHints().has(key);
     let response;
     try {
         response = await attempt(hints, true);
@@ -134,7 +144,9 @@ async function complete(config, model, system, user, { maxTokens = 512, temperat
         const effort = sentEffort;
         if (!(hints || effort) || !rejectedTheRequest(error))
             throw error;
-        onNotice?.(`${model} rejected a request carrying the no-thinking hints; retrying without them`);
+        onNotice?.(level
+            ? `${model} rejected a request carrying a reasoning effort; retrying without it`
+            : `${model} rejected a request carrying the no-thinking hints; retrying without them`);
         response = await attempt(false, false);
         // Latched on the finding, not the hypothesis: a context overflow is a 400 `negotiate` does
         // not recognise too, and it fails the retry the same way, leaving the next call to try the
@@ -142,7 +154,7 @@ async function complete(config, model, system, user, { maxTokens = 512, temperat
         // cannot latch is blamed; if it was the effort after all, the next call is left with only
         // the effort to drop and latches that instead.
         if (hints)
-            noHints.add(key);
+            noHints().add(key);
         else
             modelCapabilitiesFor(supports, model).reasoningEffort = false;
     }

package/dist/spec.d.ts

@@ -132,8 +132,14 @@ export interface TaskSpec {
     model?: string;
     /** Where that model lives, when it is not on the agent's endpoint. */
     endpoint?: EndpointSpec;
+    /** The reply's ceiling. Absent is the side task's own default, not the agent's `maxTokens`. */
     maxTokens?: number;
+    /** Absent is the side task's own default, 0.3, whatever the agent's temperature is. */
     temperature?: number;
+    /**
+     * A level has the task deliberate. Absent and `"off"` leave it with the no-thinking hints a
+     * side task is sent by default; see `SideTaskOptions.reasoningEffort`.
+     */
     reasoningEffort?: string;
 }
 /** A tool call bound to a lifecycle event, run by the host rather than the model. */
@@ -178,7 +184,13 @@ export interface SpecBundle {
      */
     mcpServers?: SpecServer[];
 }
-/** One side task, resolved: a model, and the endpoint it is reached through. */
+/**
+ * One side task, resolved: a model, and the endpoint it is reached through.
+ *
+ * The three settings are present only where a layer stated them, and nothing is filled in from
+ * the agent's own model — `taskCall` turns one into a call, and what is absent there is left to
+ * the side task's default.
+ */
 export interface ResolvedTask {
     model: string;
     /** This task's endpoint, which is the agent's unless a layer named another. */

package/llms.txt

@@ -26,6 +26,7 @@ The loop above a turn: send, run the tools the model asked for, send again, unti
 - `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
 
@@ -221,6 +222,13 @@ 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.
 
+### runtime
+
+- `createRuntime` — A runtime of its own: separate clients, listings, capability latches, hints, event bus and hook settings from the process's and from every other runtime's.
+- `defaultRuntime` — The runtime the top-level functions use when no other is running.
+- `Runtime` (type) — One set of the package's caches, with the functions that use them as methods.
+- `RuntimeOptions` (type) — What a runtime starts out configured with.
+
 ### schema-compat
 
 JSON Schema compatibility for llama.cpp-backed servers.
@@ -240,6 +248,7 @@ One-shot calls that support a run without being one: picking tools, naming a ses
 - `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.
 - `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.

package/package.json

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