@rarebit-one/harness-kernel 0.18.0 → 0.19.0

package/README.md

@@ -59,7 +59,7 @@ Every other engine and the whole native loop work without it. Running the
 |------|---------|
 | **Model seam** | `ModelInvocation` — one arrow for every model kind, with declared capabilities, a uniform result envelope and `probe()` |
 | **Providers** | `Provider` interface + `selectProvider()` over Anthropic, OpenAI, OpenRouter, a self-hosted `local` (any OpenAI-compatible server), an offline `mock` (by request) and a `ScriptedProvider` for recorded evals; `chatModel()` puts any of them on the seam; typed per-call `ProviderOptions` (prompt caching, token cap, response format, OpenRouter routing) |
-| **Agent loop** | `runConversation()` — a provider-neutral tool-use loop over a seeded conversation, with step and wall-clock budgets, terminal (final-answer) tools, summed usage and the served model in the result; `runAgent()` is its one-prompt form |
+| **Agent loop** | `runConversation()` — a provider-neutral tool-use loop over a seeded conversation, with step, wall-clock and optional cost budgets, terminal (final-answer) tools, summed usage and the served model in the result; `runAgent()` is its one-prompt form |
 | **Loop** | `Loop` + `nativeLoop` — the control loop as a seam; the kernel ships one and it is the loop `runAgent` and `runConversation` have always run |
 | **Run events** | `RunEvent` — an ordered, structured account of a run (turns, tool calls, budgets, outcome), emitted to an optional sink |
 | **Tools** | `Tool` (+ `ToolContext`), `primitiveTools()` (`run_code`, `read_file`, `list_files`, `http_fetch`), `connectorTools()`, `modelAsTool()`, metadata + projections (`replaySafeTools`, …) |
@@ -251,7 +251,7 @@ Every entry point takes an optional `AbortSignal` — `runAgent({ signal })`,
 const controller = new AbortController()
 const result = await engine.run(spec, { log, signal: controller.signal })
 // later: controller.abort("user canceled")
-result.outcome // "completed" | "steps_exhausted" | "timed_out" | "canceled" | "failed"
+result.outcome // "completed" | "steps_exhausted" | "timed_out" | "cost_exhausted" | "canceled" | "failed" | "suspended"
 ```
 
 The native loop merges it with its own wall-clock deadline and threads the
@@ -358,7 +358,7 @@ const result = await runConversation({
   providerOptions: { promptCache: {} },
 })
 
-result.stopReason // "end_turn" | "terminal_tool" | "steps_exhausted" | "timed_out" | "canceled" | "suspended"
+result.stopReason // "end_turn" | "terminal_tool" | "length" | "steps_exhausted" | "timed_out" | "cost_exhausted" | "canceled" | "suspended"
 result.terminal?.input // { text, quick_replies } when the model called `reply`
 result.messages // store this; seed the next turn with it
 result.pending // the external calls to execute when outcome is "suspended"
@@ -373,8 +373,39 @@ so the transcript carries no dangling call, and then ends the run with
 `stopReason: "terminal_tool"` and the call on `result.terminal`. An executor
 that throws turns the call into an ordinary tool error the model gets to
 correct. `terminalTool()` builds one with a no-op executor; the structured
-answer is the call's `input`, which the kernel does not validate against the
-schema (run your own validator on it, or supply an executor that throws).
+answer is the call's `input`. By default the kernel does not check it against
+the schema; see **Argument validation** below, or supply an executor that
+throws for rules a schema cannot express.
+
+**Argument validation.** `validateToolInput: true` (off by default; also on
+`RunSpec` for the native engine) checks every call's arguments against its
+tool's `inputSchema` before the call runs or parks. A call that does not fit
+is not run: the model gets an error result naming each failing argument by
+JSON Pointer (`invalid arguments for reply; the call was not run. … /text: is
+required`), the stream records `tool.failed` with reason `invalid_input`, and
+a terminal call refused this way does not end the run. This is a refusal, the
+same family as the cut-off refusal below, not a retry: the loop makes no extra
+model call, and the model corrects the call within its own step budget. The
+check covers the JSON Schema that tool schemas use (`type`, `properties`,
+`required`, `additionalProperties`, `enum`, `const`, `items`, the length, size
+and range bounds, `pattern`, `allOf`/`anyOf`/`oneOf`, local `$ref`s) and
+ignores every other keyword (`format`, `not`, `if`/`then`/`else`, …), so it can
+miss a bad call but never refuses one the schema accepts. That is why it also
+applies to MCP connector tools, whose schemas the server supplies: a server
+keyword the check does not know is skipped, not guessed at, and a bad call is
+caught before the round trip. OpenAPI's `nullable` is honoured, and a schema
+declaring draft 03–07 has its `$ref` siblings ignored as those drafts did, and
+a keyword its declared draft did not have (`const` before draft 6,
+`prefixItems` before 2020-12) is ignored too; a
+schema the check cannot read lets the call through rather than failing the
+run, and so does a local `$ref` inside an embedded resource (a subschema with
+its own `$id`) or a schema whose check would take more than a fixed amount of
+work (shared definitions reached from many composition branches). One caution: `pattern` runs synchronously on the model's input, so a
+pattern with catastrophic backtracking can stall the run past its deadline;
+turn validation on only for tools whose schemas you would run that way.
+`validateToolInput(schema, input)` is exported
+for a caller that wants the same check elsewhere (on `terminal.input`, or in
+its own loop); it returns `{ path, message }[]`, empty when the input fits.
 
 The seed must end with a user message or with the tool results the model is
 waiting for; the loop copies it and never mutates the array it was handed.
@@ -417,7 +448,7 @@ if (parked.outcome === "suspended") {
     system,
     messages: withToolResults(parked.messages, results),
     tools: [...tools, askHuman], // keep it: the model may ask again
-    ...remainingLimits({ maxSteps, maxDurationMs }, parked.consumed),
+    ...remainingLimits({ maxSteps, maxDurationMs, maxCostUsd }, parked.consumed),
   })
 }
 ```
@@ -430,16 +461,106 @@ closes each parked call in its own event stream, at step 0, as `tool.succeeded`
 or `tool.failed` with `reason: "rejected"`, so a consumer following the stream
 across both runs sees every `tool.pending` matched. `remainingLimits` carries
 the budget over, floored at one step and one minute so the first resumed step
-always runs; a resumed run is a continuation, not a fresh budget. A terminal
+always runs (a cost budget carries over as the limit minus the cost the parked
+run reported); a resumed run is a continuation, not a fresh budget. A terminal
 answer or a stop in the same step ends the run instead, and the parked calls
 are answered as not run so the transcript stays whole.
 
+**Settling a stored transcript.** A transcript the kernel returns from a
+finished, stopped or cut-off run is already whole, but a `suspended` one ends on
+the parked calls, and a transcript an application built, cut or appended to
+itself may leave calls unanswered anywhere. Every provider rejects a tool call
+with no result. `settleMessages` answers each missing one (into the tool turn
+that follows its assistant turn, else as a new tool turn after it) and leaves
+answered calls alone, so settling twice changes nothing. `withUserTurn` settles
+and appends the next user message, and its output always passes the loop's seed
+check:
+
+```ts
+import { settleMessages, withToolResults, withUserTurn } from "@rarebit-one/harness-kernel"
+
+// The user moved on instead of answering what the last run parked:
+// the parked calls are closed as not run, then the new message follows.
+const next = withUserTurn(stored, incoming)
+
+// Or say why, per call:
+const declined = withUserTurn(stored, incoming, {
+  answer: (call) => ({ content: `${call.name} was abandoned`, isError: true, rejected: true }),
+})
+
+// A resume where the caller answered only some parked calls; settle closes the rest.
+const resume = settleMessages(withToolResults(parked.messages, results))
+```
+
+Without `answer`, a missing result is `{ content: "not run: the turn ended
+before this tool call was answered", isError: true }`. Settle after
+`withToolResults`, never before: the other way round gives a parked call its
+placeholder and then its real result, and providers refuse two results for one
+call. What the loop never writes throws rather than being dropped: a tool turn
+that answers no call (no assistant turn before it, or a result for a call id
+that turn never made), two results for one call, two calls with one id, and one
+turn's results split across consecutive tool turns. A tool turn settle completes
+lists its results in call order. Both helpers are pure: no I/O, nothing stored, and neither array is
+mutated. They do not window or trim history, and they carry no budget: pass
+fresh limits for a per-turn budget, or `remainingLimits(limits, consumed)` to
+spend one budget across turns.
+
 **Budget visibility.** `budgetVisible: true` (off by default) appends one
 ephemeral user line to every request, `[budget] N of M step(s) and Ss remain`,
-counting down. It is never written into `messages`, and it rides after the
+counting down (with `, Ss and $X of cost` in place of `and Ss` under a cost
+budget). It is never written into `messages`, and it rides after the
 history so the cached prefix (system, tools, earlier turns) is untouched. The
 limits stay hard either way; the line only lets the model pace itself.
 
+### Parallel tool calls
+
+By default the loop runs a step's tool calls one at a time, in the order the
+model issued them. A run can opt into running some of them together:
+
+```ts
+import { isConcurrencySafe, runConversation, type Tool } from "@rarebit-one/harness-kernel"
+
+const readFile: Tool = { spec, meta: { concurrencySafe: true }, execute }
+
+await runConversation({
+  provider,
+  system,
+  messages,
+  tools,
+  toolConcurrency: { maxConcurrent: 8, concurrencySafe: isConcurrencySafe },
+})
+```
+
+`meta.concurrencySafe: true` is how a tool says it has no effect another call
+could observe or race. The loop never reads it: the run passes the predicate,
+and `isConcurrencySafe` is the one that honours the tools' own claims. An
+application with its own rule (by name, by connector) passes that instead.
+
+The ordering rule keeps the model's order wherever it can matter. A step's
+calls are split, in order, into segments: each run of consecutive safe calls is
+one segment and runs in parallel, at most `maxConcurrent` at once; every other
+call is a segment of its own, and a segment starts only when the one before it
+has settled (a cap above a step's number of calls simply runs them all). So
+`[read, read, write, read]` runs both reads together, then the write alone,
+then the last read. A call nobody vouched for sees every earlier call finished
+and no later call started, exactly as in series.
+
+Everything else holds as in series. Results go back to the model in call order,
+whatever order they finished in. `tool.called` is emitted, in call order, as
+each call starts and before its effect; `tool.succeeded`/`tool.failed` arrive
+as each one finishes, and `seq` stays gapless. A cancel or the deadline aborts
+the calls in flight, and calls not yet started are answered as not run. If the
+loop itself fails partway through a segment (a `log` callback that throws,
+say), no further call starts, and the failure propagates only once the calls in
+flight have settled, so no event follows `run.finished`. When several terminal
+calls succeed, the answer is the first one the model issued, not the first to
+finish. External calls are parked as they come up and the run suspends once the
+step's other calls have settled.
+
+`NativeEngine` takes its run from a `RunSpec`, which is data, so it does not
+carry the predicate; give the engine a loop that adds it:
+`{ name: "native", run: (req, ctx) => nativeLoop.run({ ...req, toolConcurrency }, ctx) }`.
+
 ### Provider options and prompt caching
 
 `providerOptions` rides on every model call a run makes and each adapter maps it
@@ -498,8 +619,26 @@ Usage carries what the provider prices: beside the token counts, `TokenUsage`
 has `cacheWriteTokens`, `reasoningTokens` and `reportedCost`
 (`{ amount, currency: "USD" }`, from OpenRouter's `usage.cost`) when the
 response reports them, on every `model.turn` event and summed by amount on the
-result, so a per-turn cost cap can abort the run through its `signal`. Absent
-means unknown, never free.
+result. Absent means unknown, never free.
+
+**Cost budget.** `maxCostUsd` (on `runConversation`/`runAgent`, `RunSpec.limits`
+for the native engine, `LoopLimits` for a loop) is a third budget beside steps
+and time, with no default: absent means unlimited. After each model turn the
+loop compares the run's summed `reportedCost` with it. Once it is reached, a
+turn that asked for tools ends the run before any of them start, with
+`outcome: "cost_exhausted"`, a `run.budget_exhausted` event of `kind: "cost"`,
+the accumulated prose plus a note, and every call of that turn answered as not
+run so the transcript resumes. No summary call is made, because it would spend
+past a limit already reached; a turn that answered in prose completes as usual.
+The turn that crosses the line is the overshoot, since its cost is known only
+after it returns. Only reported cost counts: a turn that reports none adds
+nothing (logged once per run), so under a provider that does not price its
+responses the limit sees only part of the spend, or none of it. Only the run's own
+model turns count, too: a tool that spends (a `modelAsTool` sub-model, a paid
+API) does so outside the limit, because its usage never reaches the run's. The kernel carries no price
+table; to bring unpriced calls inside the limit, fill `usage.reportedCost` in a
+model `Middleware` from your own prices. Conversation-level or daily caps span
+runs and stay with the application. The out-of-process engines ignore it.
 
 Two more per-call knobs: `maxRetries` overrides the SDK retry count for one
 call (set `0` alongside an OpenRouter `models` chain, or the SDK and the router
@@ -508,6 +647,101 @@ both retry), and the `openai` adapter sends the cap as `max_completion_tokens`
 local servers get `max_tokens`. `connectorTools(..., { toolName })` names MCP
 tools your way when the default `<connector>__<tool>` prefix is in the way.
 
+A connector whose credential rotates during a run sets `auth.headers`, a
+function (async allowed) returning the headers for one request, instead of a
+static `auth.token`. The HTTP transports ask it before every request, and after
+a 401 ask once more with `refresh: true` and retry that request once; a throw
+fails the request with `connector <name>: auth headers function failed`, never
+the function's own message. The native engine masks every value it returns in
+tool output, as it does the run's `secrets` and a static token, so return only
+credential headers. These requests never follow a cross-origin redirect. The
+out-of-process engines read their server config once, so they refuse such a run
+in `supports()`, and stdio refuses it (its token is set at spawn).
+`ConnectorConfig.clientInfo` (`{ name, version? }`) replaces the default client
+identity announced to the server.
+
+### Retry and fallback
+
+The kernel retries nothing by itself beyond what the vendor SDKs do
+(`maxRetries`, default 2). A caller that needs more — a wait that knows the
+run's deadline, an honoured `Retry-After`, other models to try once the primary
+is exhausted — wraps its model in `withRetry` and turns the SDK's own retries
+off, so the two do not multiply:
+
+```ts
+import { chatModel, withRetry, OpenRouterProvider } from "@rarebit-one/harness-kernel"
+
+const primary = chatModel(new OpenRouterProvider(key, "vendor-a/large"))
+const backup = chatModel(new OpenRouterProvider(key, "vendor-b/medium"))
+
+const model = withRetry(primary, {
+  maxAttempts: 4,                              // per model, first call included
+  backoff: (n) => [1000, 2000, 3000][n - 1] ?? 3000, // or { baseMs, maxMs, jitter }
+  waitBudgetMs: 6000,                          // total wait across this wrapper's calls
+  deadlineAt: turnStartedAt + 45_000,          // optional inside the loop, which passes the run's deadline
+  minCallMs: 10_000,                           // never leave the next call under 10 s
+  fallbacks: [backup],                         // explicit, ordered; none by default
+  stickyFallback: true,                        // once the primary is exhausted, skip it
+  onEvent: (e) => log(JSON.stringify(e)),      // each retry and fallback as it happens
+})
+
+await runConversation({ provider: model, providerOptions: { maxRetries: 0 }, ... })
+```
+
+Each failure is classified `retry` (try the same model again after a backoff,
+then move on), `fallback` (move to the next model now) or `fatal` (rethrow it
+unchanged). `defaultRetryClassifier` retries rate limits, timeouts, 5xx and
+dropped connections, and treats everything else as fatal: auth, payment, an
+invalid request, a refused credential or option, and any error it does not
+recognise. Pass `classify` to decide differently, for example to send a 5xx
+straight to the fallback. A server's `Retry-After` (or `retry-after-ms`)
+replaces the computed wait; one longer than the budget left is not shortened,
+since a shortened wait would only be refused again, so the chain moves on.
+A server wait above `maxRetryAfterMs` (default 60 s, as the SDKs do) is
+treated the same way. Wrappers compose: a `withRetry` used as one entry of
+another's chain that runs out (`RetryExhaustedError`) moves the outer chain to
+its next model, so each model can carry its own retry policy.
+
+The deadline is the earliest of `deadlineAt`, the run's deadline
+(`InvokeContext.budget.deadlineAt`, which the native loop sets on every call,
+so a late step knows how little of the run is left) and the call's
+`budget.maxDurationMs`. Outside the native loop, pass `deadlineAt` yourself.
+Each model in the chain is called with that deadline as `budget.deadlineAt`,
+so a nested `withRetry` never waits past it either.
+
+`waitBudgetMs` and `stickyFallback` are state of the wrapper instance and never
+reset: when you set either, **build one wrapper per run or turn**. A wrapper
+registered once at startup and shared by every run would spend its wait budget
+on the first rate limit and never retry again, or never return to its primary.
+A wrapper with neither option keeps no state between calls and is safe to
+share.
+
+On success `ModelResult.meta.retry` says what happened: which model `served`,
+its `position` in the chain, how many `attempts` were made, which models it
+`fellBackFrom` and how long it `waitedMs` (two adapters of one provider share
+an id, which is what `position` is for). A chain entry that is itself a
+`withRetry` wrapper folds its own report in, so `served` names the model inside
+it that answered. The chat result's own `model`, `responseId` and `upstream`
+come from the model that answered, so `model.turn` events audit a fallback the
+same way they audit any turn. When the chain runs out, `RetryExhaustedError`
+carries every failure, the last as its `cause`, and `waitedMs`; an outer wrapper
+counts a nested one that ran out call by call. An abort stops a wait at once
+and is rethrown as the signal's reason, so the loop still ends `canceled` or
+`timed_out`, never `failed`.
+
+There is never an implicit fallback: an empty `fallbacks` means retry only.
+A streaming call is never retried once its sink has received output. And
+`private: true` (set it for a `RunSpec.private` run) refuses a fallback chain
+when the wrapper is built, including a primary that is itself a `withRetry`
+wrapper with fallbacks (a nested wrapper must be built `private: true` too),
+because a fallback is exactly how a private run's
+material would reach another model; retrying its one model is still allowed.
+No upstream error text leaves a private wrapper by its own hand: `onEvent`
+events carry no `error`, log lines name the status at most, and
+`RetryExhaustedError`'s `failures` and `cause` are narrowed to the status. A
+fatal error is still rethrown as the model threw it.
+The wrapper is payload-generic, so it fits any model kind, not only chat.
+
 ### Recorded evals with `ScriptedProvider`
 
 ```ts
@@ -540,11 +774,15 @@ would defeat the point.
 ### Engines
 
 An engine is a pluggable agent harness. `native` is the in-process tool-use loop
-above; `claude-code` and `codex` shell out to those CLIs/SDKs. All three share
-one capability surface (`open_issue`, `write_file`, `promote_knowledge`) scoped
-to a single run's workspace, and all three mutate files **out of band** — the
-caller diffs the working tree afterwards, so the engine contract never has to
-model "an edit" uniformly.
+above; `claude-code` and `codex` shell out to those CLIs/SDKs. The kernel ships
+one capability, `write_file` (`writeFileCapability`), scoped to a single run's
+workspace, and `claude-code` mounts it by default. Every other capability is the
+application's, injected per engine: `domainTools` for `native`,
+`capabilityTools` for `claude-code`, a spawnable `capabilityServerScript` for
+`codex` (see
+[The kernel defines no domain tools](#the-kernel-defines-no-domain-tools)). All
+three mutate files **out of band** — the caller diffs the working tree
+afterwards, so the engine contract never has to model "an edit" uniformly.
 
 ```ts
 import { selectEngine } from "@rarebit-one/harness-kernel"
@@ -696,7 +934,8 @@ checks.
 A `vm` run is also refused when it holds **exposed** credentials, which no
 gateway can inject and which therefore reach the guest in the clear: non-empty
 `secrets`, or a connector credential the harness carries itself (`auth.token`,
-or `headers` / `env` values on a caller's connector shape). A connector whose
+an `auth.headers` function, or `headers` / `env` values on a caller's connector
+shape). A connector whose
 token is the gateway's run token is routed, not exposed. The caller's policy can
 lift this with `RunSpec.exposedCredentials: "allowed"`; absent, it refuses.
 Below `vm` nothing changes.

package/dist/agent.d.ts

@@ -5,6 +5,7 @@ import type { TokenUsage } from "./models/types.js";
 import type { ProviderOptions } from "./providers/options.js";
 import type { AgentMessage, FinishReason, Provider, ToolCall, ToolResult } from "./providers/types.js";
 import { type Tool } from "./tools/registry.js";
+import { type ToolConcurrency } from "./tools/concurrency.js";
 /** What {@link runAgent} and {@link runConversation} share. */
 export interface LoopRunOptions {
     /**
@@ -30,12 +31,29 @@ export interface LoopRunOptions {
      * than throwing. Defaults to `RUNNER_RUN_TIMEOUT_MS` if set, else 10min.
      */
     maxDurationMs?: number;
+    /**
+     * Cost budget for the whole loop in US dollars, counted from the cost each
+     * model call reports. Absent (the default) means unlimited. When reached, the
+     * run stops before running the tools the last turn asked for, with
+     * `outcome: "cost_exhausted"` and the accumulated prose. See
+     * `LoopLimits.maxCostUsd` for what counts and what an unpriced call does.
+     */
+    maxCostUsd?: number;
     /**
      * Tell the model, on every step, how many steps and how much time remain.
      * Off by default. Advisory only: the loop's limits stay hard. See
      * `LoopLimits.budgetVisible`.
      */
     budgetVisible?: boolean;
+    /**
+     * Check each tool call's arguments against the tool's `inputSchema` before
+     * running it. Off by default. A call that does not fit is not run: the model
+     * gets an error result naming the failing arguments, `tool.failed` reports
+     * `reason: "invalid_input"`, and a terminal call refused this way does not
+     * end the run. Applies to every tool the run has, connector tools included;
+     * see `validateToolInput` for the subset of JSON Schema it checks.
+     */
+    validateToolInput?: boolean;
     /**
      * Cancels the run. On abort the in-flight model request and tool are
      * stopped, no summary call is made, and the run resolves (never rejects)
@@ -44,6 +62,11 @@ export interface LoopRunOptions {
     signal?: AbortSignal;
     /** The run's id, handed to tools on `ToolContext.runId`. */
     runId?: string;
+    /**
+     * Run a step's concurrency-safe tool calls in parallel. Off by default:
+     * every call runs in series, in the model's order. See `ToolConcurrency`.
+     */
+    toolConcurrency?: ToolConcurrency;
     log?: (line: string) => void;
     /**
      * Structured event sink. Absent (the default) means the loop behaves exactly
@@ -128,6 +151,7 @@ export interface ConversationResult {
 export declare function resolveLoopLimits(limits?: {
     maxSteps?: number | undefined;
     maxDurationMs?: number | undefined;
+    maxCostUsd?: number | undefined;
     budgetVisible?: boolean | undefined;
 }): LoopLimits;
 /**

package/dist/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"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"}