@cubicecho/agent-core 2.21.1 → 2.23.0

package/dist/client.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import OpenAI from "openai";
+import { scoped } from "./scope.js";
 /**
  * The SDK insists on a non-empty key even where the server will not look at it. This is what it
  * gets. It also reads as "this endpoint has no key" at a call site, which an empty string does
@@ -31,7 +32,7 @@ export const timeoutMs = (config) => {
  * Bounded, because a cache is only a cache while its keys are. Insertion order is the whole of
  * the eviction: a `Map` iterates oldest-first, and `getClient` re-inserts on a hit.
  */
-const clients = new Map();
+const clients = scoped(() => new Map());
 /**
  * How many endpoints' clients are kept at once, until `configureClients` moves it.
  *
@@ -55,7 +56,7 @@ const CLIENT_DEFAULTS = {
     listingMissMs: LISTING_MISS_MS,
 };
 /** What is in force now. Read where it is used, so a change applies from the next call. */
-let poolLimits = { ...CLIENT_DEFAULTS };
+const poolLimits = scoped(() => ({ ...CLIENT_DEFAULTS }));
 /**
  * Drops the least recently asked-for clients until the pool fits. Nothing is closed on the way
  * out: the SDK holds no handle a caller can release, and an evicted client is garbage once
@@ -63,20 +64,21 @@ let poolLimits = { ...CLIENT_DEFAULTS };
  * of the eviction.
  */
 const evict = () => {
-    for (const oldest of clients.keys()) {
-        if (clients.size <= poolLimits.maxClients)
+    for (const oldest of clients().keys()) {
+        if (clients().size <= poolLimits().maxClients)
             break;
-        clients.delete(oldest);
+        clients().delete(oldest);
     }
 };
 /**
  * Changes what the client pool is held to, for a process whose endpoints are not shaped like the
  * deployments these defaults were chosen for.
  *
- * Module-level for the same reason `configureEvents` is: the pool is one module-level thing, and
- * its size is a deployment's setting, said once at startup. A multi-tenant host keying on a key
- * per user raises `maxClients` so its tenants stop evicting each other's connection pools; a dev
- * box shortens `listingMissMs` so a model it has just pulled is seen sooner.
+ * One setting per runtime for the same reason `configureEvents` is: the pool is one thing per
+ * runtime, and its size is a deployment's setting, said once at startup. A multi-tenant host
+ * keying on a key per user raises `maxClients` so its tenants stop evicting each other's
+ * connection pools, or gives each tenant a `createRuntime` of its own; a dev box shortens
+ * `listingMissMs` so a model it has just pulled is seen sooner.
  *
  * A `maxClients` below the pool's current size evicts down to it at once, least recently asked
  * for first, as the next `getClient` would have. A shorter `listingMissMs` applies to misses
@@ -91,11 +93,11 @@ const evict = () => {
 export function configureClients(options = {}) {
     for (const [name, value] of Object.entries(options)) {
         if (typeof value === "number" && value > 0) {
-            poolLimits[name] = value;
+            poolLimits()[name] = value;
         }
     }
     evict();
-    return { ...poolLimits };
+    return { ...poolLimits() };
 }
 /** How many idle windows the first chunk gets when `firstTokenSeconds` is not given. */
 export const FIRST_TOKEN_FACTOR = 5;
@@ -132,16 +134,16 @@ export function getClient(config) {
     // Stringified rather than joined on a separator: no character is impossible in a URL or a
     // key, and two different endpoints must never resolve to the same cached client.
     const key = JSON.stringify([config.baseUrl, apiKey, timeout]);
-    const existing = clients.get(key);
+    const existing = clients().get(key);
     if (existing) {
         // Re-inserted so it counts as the youngest. A `Map` keeps insertion order and hands the
         // oldest key over first, which is the whole of the LRU below.
-        clients.delete(key);
-        clients.set(key, existing);
+        clients().delete(key);
+        clients().set(key, existing);
         return existing;
     }
     const client = new OpenAI({ baseURL: config.baseUrl, apiKey, timeout, maxRetries: 0 });
-    clients.set(key, client);
+    clients().set(key, client);
     evict();
     return client;
 }
@@ -197,14 +199,14 @@ function contextLengthOf(model) {
  * It is only ever a cache of something asked for anyway, and a listing that fails leaves
  * whatever was there rather than emptying it.
  */
-const listings = new Map();
+const listings = scoped(() => new Map());
 /**
  * The models in each endpoint's last listing whose window is only the trained one, by id.
  *
  * Kept beside `listings` rather than on `ModelInfo`, so what `listModels` hands back is the shape
  * it has always been. Replaced with each listing that lands, and left alone by one that fails.
  */
-const trainedOnly = new Map();
+const trainedOnly = scoped(() => new Map());
 /**
  * When an endpoint was last asked about a model it did not name, keyed on the two together.
  *
@@ -219,7 +221,7 @@ const trainedOnly = new Map();
  * picked up within the minute instead of at the next restart. Bounded by the (endpoint, model)
  * pairs actually asked about, which is the bound the listings themselves have.
  */
-const misses = new Map();
+const misses = scoped(() => new Map());
 /**
  * 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`.
@@ -257,9 +259,9 @@ export const endpointId = (config) => createHash("sha256").update(endpointKey(co
  * A model's entry stays until `resetClients`, like a listing; a server that answered without one
  * is asked again after `listingMissMs`, like a listing that did not name the model.
  */
-const served = new Map();
+const served = scoped(() => new Map());
 /** Endpoints with neither native route, which are not asked for either again. */
-const unserved = new Set();
+const unserved = scoped(() => new Set());
 /**
  * Endpoints whose `/api/v0/models` answered with an error, and when.
  *
@@ -271,11 +273,11 @@ const unserved = new Set();
  * Per endpoint and on its own, whatever `/props` said: a server whose `/props` answers without a
  * window is never `unserved`, and without this its missing route was asked again with every miss.
  */
-const refusals = new Map();
+const refusals = scoped(() => new Map());
 /** Whether `/api/v0/models` is to be left alone on this endpoint for now. */
 const refused = (endpoint) => {
-    const refusal = refusals.get(endpoint);
-    return (refusal !== undefined && (refusal.gone || Date.now() - refusal.at < poolLimits.listingMissMs));
+    const refusal = refusals().get(endpoint);
+    return (refusal !== undefined && (refusal.gone || Date.now() - refusal.at < poolLimits().listingMissMs));
 };
 /** How long a probe may take before the window is taken from the listing instead. */
 const PROBE_TIMEOUT_MS = 10_000;
@@ -324,11 +326,11 @@ async function probe(config, path) {
  */
 export async function servedWindow(config) {
     const endpoint = endpointKey(config);
-    if (unserved.has(endpoint))
+    if (unserved().has(endpoint))
         return 0;
     const key = JSON.stringify([endpoint, config.model]);
-    const known = served.get(key);
-    if (known && (known.window > 0 || Date.now() - known.at < poolLimits.listingMissMs))
+    const known = served().get(key);
+    if (known && (known.window > 0 || Date.now() - known.at < poolLimits().listingMissMs))
         return known.window;
     let window = 0;
     try {
@@ -341,17 +343,17 @@ export async function servedWindow(config) {
             if (!refused(endpoint)) {
                 const lmstudio = await probe(config, "/api/v0/models");
                 if (lmstudio.failed)
-                    refusals.set(endpoint, { at: Date.now(), gone: lmstudio.missing });
+                    refusals().set(endpoint, { at: Date.now(), gone: lmstudio.missing });
                 else
-                    refusals.delete(endpoint);
+                    refusals().delete(endpoint);
                 const { data } = (lmstudio.body ?? {});
                 const entry = Array.isArray(data)
                     ? data.find((model) => model?.id === config.model)
                     : undefined;
                 window = positive(entry?.loaded_context_length);
             }
-            if (props.missing && refusals.get(endpoint)?.gone) {
-                unserved.add(endpoint);
+            if (props.missing && refusals().get(endpoint)?.gone) {
+                unserved().add(endpoint);
                 return 0;
             }
         }
@@ -359,7 +361,7 @@ export async function servedWindow(config) {
     catch {
         return 0;
     }
-    served.set(key, { window, at: Date.now() });
+    served().set(key, { window, at: Date.now() });
     return window;
 }
 /**
@@ -379,8 +381,8 @@ export async function listModels(config) {
     })
         .sort((a, b) => a.id.localeCompare(b.id));
     const key = endpointKey(config);
-    listings.set(key, models);
-    trainedOnly.set(key, trained);
+    listings().set(key, models);
+    trainedOnly().set(key, trained);
     return models;
 }
 /**
@@ -411,7 +413,9 @@ export async function contextLimitFor(config, declared = 0) {
     if (declared > 0)
         return declared;
     const key = endpointKey(config);
-    const listed = () => listings.get(key)?.find((model) => model.id === config.model);
+    const listed = () => listings()
+        .get(key)
+        ?.find((model) => model.id === config.model);
     // The listing is asked for again when it does not name this model, rather than only when
     // there is no listing at all. Models arrive after a process starts — an `ollama pull` on a
     // box that has been up a week, a worker added to a router, a name the operator has only just
@@ -421,11 +425,11 @@ export async function contextLimitFor(config, declared = 0) {
     // the window instead of under it and fails against the endpoint's own refusal.
     if (!listed()) {
         const missKey = JSON.stringify([key, config.model]);
-        const asked = misses.get(missKey);
+        const asked = misses().get(missKey);
         // Asked again, but not on every call. A model that is never coming answers the same zero
         // however often the endpoint is asked, and a caller sizing a window per turn pays a round
         // trip for each of them; `listingMissMs` is how long that answer is allowed to stand.
-        if (asked === undefined || Date.now() - asked >= poolLimits.listingMissMs) {
+        if (asked === undefined || Date.now() - asked >= poolLimits().listingMissMs) {
             // A failure is not remembered: an endpoint that was down when the last run started is not
             // an endpoint with no models, and a window nobody could ask about is not a failed run.
             const answered = await listModels(config).then(() => true, () => false);
@@ -435,9 +439,9 @@ export async function contextLimitFor(config, declared = 0) {
             // half a minute.
             if (answered) {
                 if (listed())
-                    misses.delete(missKey);
+                    misses().delete(missKey);
                 else
-                    misses.set(missKey, Date.now());
+                    misses().set(missKey, Date.now());
             }
         }
     }
@@ -445,7 +449,7 @@ export async function contextLimitFor(config, declared = 0) {
     const fromListing = entry?.contextLength ?? 0;
     // A top-level key settles it. A trained window does not: llama.cpp lists the one the model was
     // built with, and taking it over what `/props` says lets an overflow through the guard.
-    if (fromListing > 0 && !trainedOnly.get(key)?.has(config.model))
+    if (fromListing > 0 && !trainedOnly().get(key)?.has(config.model))
         return fromListing;
     const window = await servedWindow(config);
     return window > 0 ? window : fromListing;
@@ -455,12 +459,12 @@ export async function contextLimitFor(config, declared = 0) {
  * tests, and for a settings change under test.
  */
 export function resetClients() {
-    poolLimits = { ...CLIENT_DEFAULTS };
-    clients.clear();
-    listings.clear();
-    misses.clear();
-    trainedOnly.clear();
-    served.clear();
-    unserved.clear();
-    refusals.clear();
+    poolLimits.reset();
+    clients().clear();
+    listings().clear();
+    misses().clear();
+    trainedOnly().clear();
+    served().clear();
+    unserved().clear();
+    refusals().clear();
 }

package/dist/events.d.ts

@@ -50,8 +50,10 @@ export interface EventBusOptions {
  * Changes what the bus keeps, for a process whose runs are not shaped like the ones these
  * defaults were chosen for.
  *
- * The bus is one module-level thing rather than an object a caller holds, so this is too: it is
+ * The bus is one thing per runtime rather than an object a caller holds, so this is too: it is
  * a deployment's setting, said once at startup, and not something to move around under a run.
+ * Called at the top level that is the process's bus; a runtime made by `createRuntime` has its
+ * own, set through its options or its own `configureEvents`.
  * What it costs is memory against how much of a run a late or slow watcher can still read —
  * a server with hundreds of concurrent runs wants a smaller backlog, and one whose tool calls
  * take an hour wants a longer `retainUnendedMs` than the thirty minutes assumed here.

package/dist/events.js

@@ -1,3 +1,4 @@
+import { scoped } from "./scope.js";
 import { LOAD_TOOLS } from "./tool-loading.js";
 /** The numbers a run of the shape this bus was written for wants. */
 const DEFAULTS = {
@@ -6,14 +7,15 @@ const DEFAULTS = {
     retainMs: 60_000,
     retainUnendedMs: 30 * 60_000,
 };
-/** What is in force now. Read where it is used, so a change applies from the next event. */
-let limits = { ...DEFAULTS };
+const bus = scoped(() => ({ limits: { ...DEFAULTS }, streams: new Map(), sweeping: null }));
 /**
  * Changes what the bus keeps, for a process whose runs are not shaped like the ones these
  * defaults were chosen for.
  *
- * The bus is one module-level thing rather than an object a caller holds, so this is too: it is
+ * The bus is one thing per runtime rather than an object a caller holds, so this is too: it is
  * a deployment's setting, said once at startup, and not something to move around under a run.
+ * Called at the top level that is the process's bus; a runtime made by `createRuntime` has its
+ * own, set through its options or its own `configureEvents`.
  * What it costs is memory against how much of a run a late or slow watcher can still read —
  * a server with hundreds of concurrent runs wants a smaller backlog, and one whose tool calls
  * take an hour wants a longer `retainUnendedMs` than the thirty minutes assumed here.
@@ -27,14 +29,14 @@ let limits = { ...DEFAULTS };
  * @returns Everything in force afterwards, including what this call did not change.
  */
 export function configureEvents(options = {}) {
+    const { limits } = bus();
     for (const [name, value] of Object.entries(options)) {
         if (typeof value === "number" && value > 0)
             limits[name] = value;
     }
     return { ...limits };
 }
-const streams = new Map();
-const streamFor = (runId) => {
+const streamFor = ({ streams }, runId) => {
     const existing = streams.get(runId);
     if (existing)
         return existing;
@@ -60,9 +62,9 @@ const streamFor = (runId) => {
  *
  * One timer for the whole map, rescheduled only while there is something in it to expire.
  */
-let sweeping = null;
-function sweep() {
-    sweeping = null;
+function sweep(held) {
+    const { limits, streams } = held;
+    held.sweeping = null;
     const now = Date.now();
     for (const [runId, stream] of streams) {
         if (stream.listeners.size)
@@ -70,13 +72,13 @@ function sweep() {
         if (stream.touched <= now - (stream.ended ? limits.retainMs : limits.retainUnendedMs))
             streams.delete(runId);
     }
-    scheduleSweep();
+    scheduleSweep(held);
 }
-function scheduleSweep() {
-    if (sweeping || streams.size === 0)
+function scheduleSweep(held) {
+    if (held.sweeping || held.streams.size === 0)
         return;
-    sweeping = setTimeout(sweep, limits.retainMs);
-    sweeping.unref?.();
+    held.sweeping = setTimeout(() => sweep(held), held.limits.retainMs);
+    held.sweeping.unref?.();
 }
 /**
  * Forgets a run that will not be emitting `done` — one whose process is tearing down, or whose
@@ -86,6 +88,7 @@ function scheduleSweep() {
  * @param runId The run to forget. An id nothing was emitted under is ignored.
  */
 export function endRun(runId) {
+    const { streams } = bus();
     const stream = streams.get(runId);
     if (!stream)
         return;
@@ -106,7 +109,9 @@ export function endRun(runId) {
  * @param input The event. `kind` is required; `runId` and `seq` are not a caller's to set.
  */
 export function emit(runId, input) {
-    const stream = streamFor(runId);
+    const held = bus();
+    const { limits } = held;
+    const stream = streamFor(held, runId);
     // One clock read, used for both the event and the sweep's bookkeeping.
     const at = Date.now();
     const event = {
@@ -130,7 +135,7 @@ export function emit(runId, input) {
     // then dropped: a finished run's record is the row, not this.
     if (event.kind === "done")
         stream.ended = true;
-    scheduleSweep();
+    scheduleSweep(held);
     for (const listener of stream.listeners) {
         // The guarantee above is the point of this: a listener that throws must not take out the
         // emitter, the listeners after it, or the bookkeeping already done above.
@@ -155,8 +160,14 @@ export function emit(runId, input) {
  * function it is suspended at an `await` rather than at a `yield`, and a `return()` there is
  * queued behind a promise only the next event can settle. An abort resolves that promise itself.
  */
-export async function* watch(runId, signal) {
-    const stream = streamFor(runId);
+export function watch(runId, signal) {
+    // Read here, not in the generator: its body runs when the first event is asked for, and by
+    // then the caller may be outside the runtime whose run this is.
+    return watching(bus(), runId, signal);
+}
+async function* watching(held, runId, signal) {
+    const { limits, streams } = held;
+    const stream = streamFor(held, runId);
     // A cursor rather than `shift()`. Draining a backlog an event at a time off the front of an
     // array is a copy of the whole array per event, which on the ten-thousand-delta run this bus
     // is built for is the one quadratic left in the file. The prefix behind the cursor is dropped
@@ -272,7 +283,7 @@ export async function* watch(runId, signal) {
  *
  * @param runId The run to read. An unknown or already-swept run gives an empty array.
  */
-export const history = (runId) => [...(streams.get(runId)?.events ?? [])];
+export const history = (runId) => [...(bus().streams.get(runId)?.events ?? [])];
 /**
  * Test seam: forget every run, so one test's events cannot be read by the next.
  *
@@ -286,11 +297,13 @@ export const history = (runId) => [...(streams.get(runId)?.events ?? [])];
  * teardown configures again, which is the same line it already wrote once.
  */
 export const resetEvents = () => {
-    streams.clear();
-    if (sweeping)
-        clearTimeout(sweeping);
-    sweeping = null;
-    limits = { ...DEFAULTS };
+    const held = bus();
+    held.streams.clear();
+    if (held.sweeping)
+        clearTimeout(held.sweeping);
+    held.sweeping = null;
+    // In place, so a watcher still open reads the defaults too and not the caps it began under.
+    Object.assign(held.limits, DEFAULTS);
 };
 /**
  * Consecutive tokens of one kind are one thing being said, not hundreds of things.

package/dist/hooks.d.ts

@@ -160,8 +160,8 @@ export interface HookOptions {
  * Changes what hooks are held to, for a process whose windows are not the size these defaults
  * were chosen for, or whose host wants its own name above the context.
  *
- * Module-level for the same reason `configureEvents` is: a budget and a preface are a deployment's
- * settings, said once at startup. A caller that sizes the budget per model or per agent — a 128k
+ * One setting per runtime for the same reason `configureEvents` is: a budget and a preface are a
+ * deployment's settings, said once at startup. A caller that sizes the budget per model or per agent — a 128k
  * window can afford more recall than an 8k one — passes `maxTokens` to `gather` instead, and a
  * `preface` passed to `withContext` or `runAgentLoop`'s hooks wins over this one the same way.
  *

package/dist/hooks.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { errorMessage } from "./errors.js";
+import { scoped } from "./scope.js";
 import { estimateTokens } from "./tokens.js";
 /** Every event a hook can be bound to, in the order a session meets them. */
 export const HOOK_EVENTS = [
@@ -36,13 +37,13 @@ const HOOK_DEFAULTS = {
     preface: HOOK_PREFACE,
 };
 /** What is in force now. Read where it is used, so a change applies from the next request. */
-let hookSettings = { ...HOOK_DEFAULTS };
+const hookSettings = scoped(() => ({ ...HOOK_DEFAULTS }));
 /**
  * Changes what hooks are held to, for a process whose windows are not the size these defaults
  * were chosen for, or whose host wants its own name above the context.
  *
- * Module-level for the same reason `configureEvents` is: a budget and a preface are a deployment's
- * settings, said once at startup. A caller that sizes the budget per model or per agent — a 128k
+ * One setting per runtime for the same reason `configureEvents` is: a budget and a preface are a
+ * deployment's settings, said once at startup. A caller that sizes the budget per model or per agent — a 128k
  * window can afford more recall than an 8k one — passes `maxTokens` to `gather` instead, and a
  * `preface` passed to `withContext` or `runAgentLoop`'s hooks wins over this one the same way.
  *
@@ -55,11 +56,11 @@ let hookSettings = { ...HOOK_DEFAULTS };
 export function configureHooks(options = {}) {
     const { contextTokens, preface } = options;
     if (typeof contextTokens === "number" && contextTokens > 0) {
-        hookSettings.contextTokens = contextTokens;
+        hookSettings().contextTokens = contextTokens;
     }
     if (typeof preface === "string")
-        hookSettings.preface = preface;
-    return { ...hookSettings };
+        hookSettings().preface = preface;
+    return { ...hookSettings() };
 }
 /**
  * Test seam: puts `configureHooks` back to the defaults, so one test's budget or preface is not the
@@ -67,14 +68,14 @@ export function configureHooks(options = {}) {
  * `resetAll` calls it.
  */
 export const resetHooks = () => {
-    hookSettings = { ...HOOK_DEFAULTS };
+    hookSettings.reset();
 };
 /**
  * The budget a call is held to: its own when it gave a usable one, the process's otherwise. The
  * same rule `configureHooks` applies, so a `0` threaded through for "no opinion" does not quietly
  * turn every hook's context off.
  */
-const budget = (given) => typeof given === "number" && given > 0 ? given : hookSettings.contextTokens;
+const budget = (given) => typeof given === "number" && given > 0 ? given : hookSettings().contextTokens;
 const attribute = (text) => text.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;");
 /**
  * Builds the context a set of outcomes adds and the notes that go with it.
@@ -143,7 +144,7 @@ export function assembleContext(outcomes, maxTokens) {
  * unless something moved it. Empty says nothing, rather than leaving a blank line where it was.
  * @returns `history` when there was nothing to add or nowhere to add it, otherwise a new array.
  */
-export function withContext(history, index, context, preface = hookSettings.preface) {
+export function withContext(history, index, context, preface = hookSettings().preface) {
     const message = history[index];
     if (!context || message?.role !== "user")
         return history;

package/dist/index.d.ts

@@ -9,7 +9,7 @@
  * prompts, and whatever the run is about — because that is the caller's, and it is the part
  * that differs between one server and the next.
  */
-export { type AgentLoopHooks, type AgentLoopOptions, type AgentLoopRequest, type AgentLoopResult, buildBody, preselect, preview, resolveApiKey, runAgentLoop, type StepWindow, type ToolCallOutcome, type ToolCallRequest, type ToolCallResult, } from "./agent-loop.ts";
+export { type AgentLoopHooks, type AgentLoopOptions, type AgentLoopRequest, type AgentLoopResult, buildBody, preselect, preview, resolveApiKey, runAgentLoop, type StepWindow, type ToolCallOutcome, type ToolCallRequest, type ToolCallResult, taskCall, } from "./agent-loop.ts";
 export { calibrate, charsPerTokenFor, resetCalibration } from "./calibration.ts";
 export { type Capabilities, capabilitiesFor, EFFORT_LADDER, effortFor, expireCapabilities, type ModelCapabilities, modelCapabilitiesFor, type NegotiateOptions, negotiate, resetCapabilities, } from "./capabilities.ts";
 export type { CatalogServer } from "./catalog.ts";
@@ -24,8 +24,9 @@ export { estimateFrom, type LedgerEntry, type LedgerEstimateOptions, type Ledger
 export { resetAll } from "./reset.ts";
 export { backoffMs, CHARS_PER_TOKEN, type ContextBreakdown, type ContextBreakdownOptions, ContextOverflow, compact, contextChars, contextTokens, EndpointSilent, isModelLoading, isOverflow, isTransient, LOADING_POLL_MS, LOADING_TIMEOUT_MS, messageTokens, requestChars, requestTokens, SMALLEST_LIKELY_WINDOW, sleep, type TokenEstimateOptions, toolsChars, } from "./retry.ts";
 export { type RunTurnOptions, runTurn } from "./run-turn.ts";
+export { createRuntime, defaultRuntime, type Runtime, type RuntimeOptions } from "./runtime.ts";
 export { isGrammarError, relaxTools, sanitizeTools } from "./schema-compat.ts";
-export { type AskJsonOptions, ask, askJson, clean, listLines, parseJson, resetHints, type SideTaskInput, type SideTaskOptions, tryAsk, } from "./side-task.ts";
+export { type AskJsonOptions, ask, askJson, clean, listLines, parseJson, resetHints, type SideTask, type SideTaskInput, type SideTaskOptions, tryAsk, } from "./side-task.ts";
 export { CAPABILITY_SNAPSHOT_VERSION, type CapabilitySnapshot, type EndpointSnapshot, exportCapabilities, importCapabilities, type ModelSnapshot, } from "./snapshot.ts";
 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, RESOLVED_DEFAULTS, type ResolvedAgent, type ResolvedTask, type RetrySpec, resolveAgentSpec, SPEC_EVENTS, type SpecBundle, type SpecServer, type TaskSpec, type ToolsSpec, } from "./spec.ts";
 export { type Produced, type StreamTurnOptions, streamTurn, type Turn, type TurnUsage, } from "./stream.ts";

package/dist/index.js

@@ -9,7 +9,7 @@
  * prompts, and whatever the run is about — because that is the caller's, and it is the part
  * that differs between one server and the next.
  */
-export { buildBody, preselect, preview, resolveApiKey, runAgentLoop, } from "./agent-loop.js";
+export { buildBody, preselect, preview, resolveApiKey, runAgentLoop, taskCall, } from "./agent-loop.js";
 export { calibrate, charsPerTokenFor, resetCalibration } from "./calibration.js";
 export { capabilitiesFor, EFFORT_LADDER, effortFor, expireCapabilities, modelCapabilitiesFor, negotiate, resetCapabilities, } from "./capabilities.js";
 export { configureClients, contextLimitFor, endpointId, endpointKey, FIRST_TOKEN_FACTOR, firstTokenMs, getClient, listModels, NO_KEY, resetClients, servedWindow, timeoutMs, } from "./client.js";
@@ -22,6 +22,7 @@ export { estimateFrom, rebaseLedger, recordRequest, tokensBetween, } from "./led
 export { resetAll } from "./reset.js";
 export { backoffMs, CHARS_PER_TOKEN, ContextOverflow, compact, contextChars, contextTokens, EndpointSilent, isModelLoading, isOverflow, isTransient, LOADING_POLL_MS, LOADING_TIMEOUT_MS, messageTokens, requestChars, requestTokens, SMALLEST_LIKELY_WINDOW, sleep, toolsChars, } from "./retry.js";
 export { runTurn } from "./run-turn.js";
+export { createRuntime, defaultRuntime } from "./runtime.js";
 export { isGrammarError, relaxTools, sanitizeTools } from "./schema-compat.js";
 export { ask, askJson, clean, listLines, parseJson, resetHints, tryAsk, } from "./side-task.js";
 export { CAPABILITY_SNAPSHOT_VERSION, exportCapabilities, importCapabilities, } from "./snapshot.js";

package/dist/reset.d.ts

@@ -1,8 +1,9 @@
 /**
  * Forgets everything this package remembers between calls.
  *
- * Six modules here keep state for the life of the process, each for a good reason and each
- * with its own seam: the pooled clients and their model listings, the endpoints that turned
+ * Six modules here keep state for the life of the runtime — the process's, unless this is called
+ * as a method of one `createRuntime` made, which clears that one alone — each for a good reason
+ * and each with its own seam: the pooled clients and their model listings, the endpoints that turned
  * out not to take `stream_options` or a grammar, each model's measured characters per token,
  * the models that refused the no-thinking hints, the event bus, and the hooks' configured
  * budget and preface. `resetClients`, `resetCapabilities`, `resetCalibration`, `resetHints`,
@@ -18,5 +19,8 @@
  *
  * It is also the seam that does not need finding again. A seventh module with a cache is a seventh
  * line here, rather than an edit to the teardown of three consumers who will not all notice.
+ *
+ * A test that builds a `createRuntime` per case has nothing to tear down, and is the better
+ * answer where cases run in parallel: this clears state every concurrent caller is sharing.
  */
 export declare function resetAll(): void;

package/dist/reset.js

@@ -7,8 +7,9 @@ import { resetHints } from "./side-task.js";
 /**
  * Forgets everything this package remembers between calls.
  *
- * Six modules here keep state for the life of the process, each for a good reason and each
- * with its own seam: the pooled clients and their model listings, the endpoints that turned
+ * Six modules here keep state for the life of the runtime — the process's, unless this is called
+ * as a method of one `createRuntime` made, which clears that one alone — each for a good reason
+ * and each with its own seam: the pooled clients and their model listings, the endpoints that turned
  * out not to take `stream_options` or a grammar, each model's measured characters per token,
  * the models that refused the no-thinking hints, the event bus, and the hooks' configured
  * budget and preface. `resetClients`, `resetCapabilities`, `resetCalibration`, `resetHints`,
@@ -24,6 +25,9 @@ import { resetHints } from "./side-task.js";
  *
  * It is also the seam that does not need finding again. A seventh module with a cache is a seventh
  * line here, rather than an edit to the teardown of three consumers who will not all notice.
+ *
+ * A test that builds a `createRuntime` per case has nothing to tear down, and is the better
+ * answer where cases run in parallel: this clears state every concurrent caller is sharing.
  */
 export function resetAll() {
     resetClients();