@rarebit-one/harness-kernel 0.5.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rarebit One
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,286 @@
+# harness-kernel
+
+A **provider-neutral AI-harness kernel** in TypeScript: LLM adapters, a tool-use
+loop, MCP connectors, sandbox primitives, and a pluggable agent-engine seam.
+
+It is deliberately a *kernel*, not a framework. It holds the commodity mechanics
+every AI harness needs and nothing else — applications are the userland. The
+kernel never knows an application exists; dependencies point **one way only**
+(`app layer → kernel`, never the reverse).
+
+```
+                    harness-kernel
+             ▲            ▲            ▲
+      app harness   app harness   app harness      (one-way deps)
+```
+
+## Status
+
+**v0 — private, unpublished.** The package is built OSS-ready (MIT licensed, npm
+OIDC trusted-publishing workflow wired) but the repo is private and nothing has
+been published to npm. `publish.yml` fires on a GitHub Release for **any** tag,
+so it ships **inert**: the one mutating step is skipped unless the repo variable
+`PUBLISH_LIVE` is `"true"`, and an unarmed run reports what it would have
+published. "No Release exists yet" was never a safety property — it was an
+absence.
+
+v0 is a mechanical extraction of a proven, already-provider-neutral agent core
+into a standalone package — the mechanics are battle-tested, the packaging is
+new. Seam-widening (a general `ModelInvocation` seam, streaming, multimodal
+input, middleware, context providers) is planned as an additive v0.2.
+
+## Install
+
+```bash
+npm install @rarebit-one/harness-kernel   # once published
+```
+
+ESM-only, Node >= 22.
+
+## What's in it
+
+| Area | Exports |
+|------|---------|
+| **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, and an offline `mock`; `chatModel()` puts any of them on the seam |
+| **Agent loop** | `runAgent()` — a provider-neutral tool-use loop with step and wall-clock budgets |
+| **Loop** | `Loop` + `nativeLoop` — the control loop as a seam; the kernel ships one and it is the loop `runAgent` has always run |
+| **Run events** | `RunEvent` — an ordered, structured account of a run (turns, tool calls, budgets, outcome), emitted to an optional sink |
+| **Tools** | `Tool`, `primitiveTools()` (`run_code`, `read_file`, `list_files`, `http_fetch`), `connectorTools()`, `modelAsTool()`, metadata + projections |
+| **Connectors** | `connectMcp()` — MCP clients over stdio / streamable HTTP / SSE |
+| **Engines** | The `AgentEngine` seam + `native`, `claude-code`, and `codex` harnesses, plus the capability *mechanism* (scope guards, a generic `write_file`, and MCP/stdio transports) — the capability *set* is yours to inject |
+| **Routing** | `RouteResolver` + `StaticRouteResolver` — capability → model, prompt, tools |
+| **Context** | `ContextProvider` chain, assembled in parallel and rendered into the prompt |
+| **Secrets** | `secretsToEnv()` — resolved secret values into an exec environment |
+
+## Extension points
+
+The kernel is meant to be extended from outside, never patched from inside.
+There are seven seams, and each ships with the in-process default that makes it
+usable on its own — no database, no service, no infrastructure.
+
+**1. Model kinds.** A chat LLM is one kind among several. Register any other and
+resolve it back through the same call:
+
+```ts
+import { ModelRegistry, chatModel, selectProvider } from "@rarebit-one/harness-kernel"
+
+const registry = new ModelRegistry()
+  .registerInstance(chatModel(selectProvider("anthropic")))
+  .register({ kind: "vision.detect", id: "yolo" }, () => myDetector)
+
+const detector = registry.resolve<DetectRequest, DetectionResult>({
+  kind: "vision.detect",
+  id: "yolo",
+})
+```
+
+`Req` and `Res` stay typed per kind — the seam unifies the arrow and the
+envelope (`ModelResult`, `InvokeContext`, `ModelCaps`, `probe`), never the
+payload. An unresolved ref throws rather than returning `undefined`.
+
+**2. Route resolution.** One layer up: which model, prompt and tools serve a
+named capability. `StaticRouteResolver` is capabilities-as-code; a dynamic
+resolver is your adapter behind the same interface.
+
+```ts
+const resolver = new StaticRouteResolver([
+  { name: "summarise", model: { kind: "chat", id: "anthropic" }, prompt: "Summarise." },
+])
+const route = await resolver.resolve("summarise")
+const model = registry.resolve(route.model) // the resolver picks, the registry binds
+```
+
+**3. Middleware.** Payload-blind, so one implementation covers every kind:
+
+```ts
+const model = withMiddleware(anyModel, [correlationMiddleware(), loggingMiddleware()])
+```
+
+**4. Engines.** The `AgentEngine` seam — `native`, `claude-code`, `codex`, or
+your own. File mutations stay out of band.
+
+**5. Context providers.** Replace a single pre-baked context string with a
+chain, so a live source can inject fragments:
+
+```ts
+new NativeEngine({ contextProviders: [myLiveFeed] })
+```
+
+Providers run in parallel; one that fails is logged and skipped rather than
+failing the run.
+
+**6. Tools.** Rich metadata (capability scoping, invocation-mode gating,
+confirmation, reversibility, retention, client visibility) with lossy
+projections down to what a provider actually needs — and `modelAsTool()`, which
+surfaces any model invocation as a callable tool. That last one is the cleanest
+form of extension: a perception model becomes something the chat loop can call
+without the loop, the engines, or any kernel code learning perception exists.
+
+**7. The loop.** The control flow itself. Everything above answers "which
+implementation?" for something the loop *uses*; this is the loop.
+
+```ts
+const confirmFirst: Loop = {
+  name: "confirm-first",
+  run: async (req, ctx) => {
+    const gated = req.tools.filter((t) => t.meta?.requiresConfirmation)
+    if (gated.length > 0) return { text: "awaiting confirmation", steps: 0, outcome: "completed" }
+    return nativeLoop.run(req, ctx)
+  },
+}
+new NativeEngine({ loop: confirmFirst })
+```
+
+A loop is handed **resolved** materials — a bound model, built prompts, a
+projected tool surface, budgets as numbers rather than optionals (via
+`resolveLoopLimits`, the one place defaults live). It decides control flow and
+nothing else, which is what keeps a second implementation small enough to be
+worth writing. `runAgent` and `nativeLoop` are the same code path, so they
+cannot drift.
+
+Capabilities are **checked, not assumed**: asking a model to stream when it
+declared `streaming: false` throws a `CapabilityError` instead of quietly
+returning a buffered response.
+
+### Run events
+
+`log` is prose for a human. The event stream is the same run, machine-readable:
+
+```ts
+import { runAgent, recordRunEvents } from "@rarebit-one/harness-kernel"
+
+const { sink, events } = recordRunEvents()
+await runAgent({ provider, system, userPrompt, tools, emit: sink })
+// events: run.started -> model.turn -> tool.called -> tool.succeeded -> ... -> run.finished
+```
+
+The **bookends** — `run.started` and `run.finished` — are emitted by
+`runWithEvents`, which wraps whichever `Loop` runs. A loop emits only what
+happens inside it, so a custom loop that emits nothing still produces a run that
+is visibly a run. A guarantee that depends on every future implementor
+remembering it is not a guarantee.
+
+On the failure path `steps` and `text` are **omitted**, not zeroed: the loop
+threw and never returned a result, so any number there would be invented. The
+`model.turn` events already in the stream are the authoritative record of how
+far it got.
+
+Engines take the same sink through `EngineContext`:
+
+```ts
+await engine.run(spec, { log, emit: sink })
+```
+
+Both are **optional** — omit them and the loop behaves exactly as it did before
+events existed. Every event carries a monotonic `seq` from a single per-run
+counter, so a gap is detectable: a dropped event must never look like an event
+that never happened. A sink that throws is reported through `log` and skipped,
+never allowed to fail the run.
+
+A sink is an observer and can never be a participant: `tool.called.input` is a
+detached copy, so a sink that redacts in place cannot change what the tool
+receives. The flip side is a disclosure surface worth knowing about — that field
+carries the **raw tool arguments**, so any secret or PII a model passed as an
+argument now reaches every attached sink. Nothing outside the model conversation
+captured these before; a sink that persists or forwards events should redact.
+
+`run.finished` is always the last event, including when the loop throws — the
+error propagates unchanged, but `outcome: "failed"` closes the stream first, so
+a crashed run is never mistaken for one still in flight.
+
+**The kernel emits this stream; it does not store it.** Resume, fork, search and
+replay all want persistence and a schema — infrastructure a kernel must not
+ship. `recordRunEvents()` is an in-memory recorder for tests and the reference
+shape for a real store, not a session store itself.
+
+`tool.succeeded` carries the tool's own `reversible` / `undoToolName` /
+`undoWindowSeconds` from `ToolMetadata`, copied at call time. That is the
+missing half of a bargain the metadata already made: it could declare a tool
+undoable but nothing recorded that the tool *ran*, so an application had nothing
+concrete to undo. Deciding whether to undo remains policy, and stays in the
+application.
+
+## Usage
+
+```ts
+import { selectProvider, runAgent, primitiveTools } from "@rarebit-one/harness-kernel"
+
+const provider = selectProvider("anthropic", { model: "claude-sonnet-5" })
+
+const text = await runAgent({
+  provider,
+  system: "You are a helpful autonomous agent.",
+  userPrompt: "Summarise the repo's README.",
+  tools: primitiveTools("/path/to/sandbox", process.env),
+})
+```
+
+With no provider API key configured, `selectProvider` falls back to the offline
+`mock` provider — so the whole loop runs end to end with no keys and no network.
+That is deliberate: the test suite depends on it, and so can yours.
+
+### 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.
+
+```ts
+import { selectEngine } from "@rarebit-one/harness-kernel"
+
+const engine = selectEngine("native", { domainTools }) // "claude-code" | "codex" | unknown → native
+const support = engine.supports(spec)
+if (!support.ok) throw new Error(support.reason) // fail loud, never silently degrade
+const { text } = await engine.run(spec, { log: console.error })
+```
+
+### The kernel defines no domain tools
+
+`primitiveTools()` is strictly generic — sandboxed shell/file/HTTP access. Tools
+that collect **application** output don't exist here at all: what a run may emit
+is your vocabulary, so you define it and inject it.
+
+```ts
+import { primitiveTools, writeFileCapability, denyCrossWorkspace } from "@rarebit-one/harness-kernel"
+
+// Your sinks, your tools — the kernel never sees them.
+const knowledge: MyNote[] = []
+const domainTools = (allowed?: string[]) => myEmissionTools({ knowledge }, allowed)
+
+const engine = selectEngine("native", { domainTools })
+```
+
+The same holds for the workspace-scoped **capabilities** the external engines
+mount over MCP. The kernel ships exactly one — `writeFileCapability`, a sandbox
+write with no product semantics — plus the guards (`denyCrossWorkspace`,
+`resolveWithin`) so your own capabilities inherit identical security properties:
+
+```ts
+selectEngine("claude-code", {
+  capabilityTools: (ctx) => [writeFileCapability(ctx), ...myCapabilities(ctx)],
+})
+
+// codex runs out-of-process, so it needs a script it can spawn — a child
+// process can't be handed a closure. Omitting it throws rather than serving an
+// empty surface.
+selectEngine("codex", { capabilityServerScript: "/app/dist/my-capability-server.js" })
+```
+
+## Development
+
+```bash
+npm ci
+npm run typecheck      # tsc --noEmit
+npm run lint           # eslint .   (lint:fix to autofix)
+npm run format         # prettier --write .   (format:check to verify)
+npm test               # vitest run
+npm run build          # tsc -p tsconfig.build.json → dist/ + .d.ts
+```
+
+## License
+
+MIT © Rarebit One

package/dist/agent.d.ts

@@ -0,0 +1,71 @@
+import { type RunEventSink } from "./events.js";
+import { type LoopContext, type LoopRequest, type LoopResult } from "./loop.js";
+import { type ChatModel } from "./models/chat.js";
+import type { Provider } from "./providers/types.js";
+import { type Tool } from "./tools/registry.js";
+export interface RunAgentOptions {
+    /**
+     * The chat model driving the loop. A bare {@link Provider} is accepted and
+     * adapted onto the model seam internally, so existing callers are unaffected;
+     * pass a {@link ChatModel} to drive the loop through a registry-resolved,
+     * middleware-wrapped invocation instead.
+     */
+    provider: Provider | ChatModel;
+    system: string;
+    userPrompt: string;
+    tools: Tool[];
+    maxSteps?: number;
+    /**
+     * Wall-clock budget for the whole loop in ms. Checked between steps; when
+     * exceeded the loop stops cleanly and returns what's accumulated (with a note)
+     * rather than throwing. Defaults to `RUNNER_RUN_TIMEOUT_MS` if set, else 10min.
+     */
+    maxDurationMs?: number;
+    log?: (line: string) => void;
+    /**
+     * Structured event sink. Absent (the default) means the loop behaves exactly
+     * as it did before events existed — `log` is unaffected either way, and the
+     * return value is unchanged. See `events.ts` for why the kernel emits this
+     * stream but never stores it.
+     */
+    emit?: RunEventSink;
+}
+/**
+ * Resolve a partial budget to the concrete numbers a {@link LoopRequest} needs.
+ *
+ * One place, deliberately. A {@link Loop} is handed numbers rather than
+ * optionals, so if each caller resolved its own defaults a second loop
+ * implementation could silently run to a different ceiling than the one the
+ * kernel ships. `runAgent` and `NativeEngine` both come here.
+ */
+export declare function resolveLoopLimits(limits?: {
+    maxSteps?: number | undefined;
+    maxDurationMs?: number | undefined;
+}): {
+    maxSteps: number;
+    maxDurationMs: number;
+};
+/**
+ * Cap on tool output fed back into the conversation, independent of the sandbox
+ * buffer caps — an 8 MB stdout would otherwise blow the context window.
+ * Env-overridable (`RUNNER_MAX_TOOL_RESULT_BYTES`, default 64 KiB) and resolved
+ * per call so a changed env takes effect without a reload.
+ */
+export declare function maxToolResultBytes(): number;
+/**
+ * Drives a provider-agnostic tool-use loop: the model converses, the runner
+ * executes any requested tools in the sandbox, feeds the results back, and
+ * repeats until the model stops calling tools (or the step budget is hit). The
+ * model orchestrates; deterministic work happens in the tools.
+ */
+export declare function runAgent(options: RunAgentOptions): Promise<string>;
+/**
+ * The native tool-use loop, as a {@link Loop}.
+ *
+ * Exported for `loop.ts` to wrap; applications reach it through `nativeLoop`
+ * rather than calling this directly. It is the whole of the kernel's control
+ * flow, and the only place any of it lives — `runAgent` and `nativeLoop` both
+ * come here, so the two cannot drift.
+ */
+export declare function runNativeLoop(req: LoopRequest, loopCtx: LoopContext): Promise<LoopResult>;
+//# sourceMappingURL=agent.d.ts.map

package/dist/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EAGlB,MAAM,aAAa,CAAA;AACpB,OAAO,EAGL,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,UAAU,EAChB,MAAM,WAAW,CAAA;AAClB,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAE9D,OAAO,KAAK,EAAgB,QAAQ,EAAc,MAAM,sBAAsB,CAAA;AAC9E,OAAO,EAAe,KAAK,IAAI,EAAE,MAAM,qBAAqB,CAAA;AAG5D,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAA;IAC9B,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,IAAI,EAAE,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC5B;;;;;OAKG;IACH,IAAI,CAAC,EAAE,YAAY,CAAA;CACpB;AAYD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,CAAC,EAAE;IACzC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC7B,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACnC,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAK9C;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAG3C;AA0CD;;;;;GAKG;AACH,wBAAsB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC,CAiBxE;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAkK/F"}

package/dist/agent.js

@@ -0,0 +1,258 @@
+import { runEventEmitter, } from "./events.js";
+import { nativeLoop, runWithEvents, } from "./loop.js";
+import { asChatModel } from "./models/chat.js";
+import { executeTool } from "./tools/registry.js";
+import { toToolSpecs } from "./tools/metadata.js";
+const DEFAULT_MAX_STEPS = 12;
+const FALLBACK_MAX_DURATION_MS = 10 * 60 * 1000;
+/** Resolve the wall-clock run budget from env, falling back to 10 minutes. */
+function defaultMaxDurationMs() {
+    const raw = Number(process.env.RUNNER_RUN_TIMEOUT_MS);
+    return Number.isFinite(raw) && raw > 0 ? raw : FALLBACK_MAX_DURATION_MS;
+}
+const FALLBACK_MAX_TOOL_RESULT_BYTES = 64 * 1024;
+/**
+ * Resolve a partial budget to the concrete numbers a {@link LoopRequest} needs.
+ *
+ * One place, deliberately. A {@link Loop} is handed numbers rather than
+ * optionals, so if each caller resolved its own defaults a second loop
+ * implementation could silently run to a different ceiling than the one the
+ * kernel ships. `runAgent` and `NativeEngine` both come here.
+ */
+export function resolveLoopLimits(limits) {
+    return {
+        maxSteps: limits?.maxSteps ?? DEFAULT_MAX_STEPS,
+        maxDurationMs: limits?.maxDurationMs ?? defaultMaxDurationMs(),
+    };
+}
+/**
+ * Cap on tool output fed back into the conversation, independent of the sandbox
+ * buffer caps — an 8 MB stdout would otherwise blow the context window.
+ * Env-overridable (`RUNNER_MAX_TOOL_RESULT_BYTES`, default 64 KiB) and resolved
+ * per call so a changed env takes effect without a reload.
+ */
+export function maxToolResultBytes() {
+    const raw = Number(process.env.RUNNER_MAX_TOOL_RESULT_BYTES);
+    return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : FALLBACK_MAX_TOOL_RESULT_BYTES;
+}
+/**
+ * The reversibility fields a tool declares, copied at call time.
+ *
+ * Each is spread only when declared: absent means "makes no claim", which is a
+ * different fact from `reversible: false` ("declared irreversible") and a
+ * rollback consumer must be able to tell them apart.
+ */
+function undoFields(meta) {
+    return {
+        ...(meta?.reversible !== undefined ? { reversible: meta.reversible } : {}),
+        ...(meta?.undoToolName !== undefined ? { undoToolName: meta.undoToolName } : {}),
+        ...(meta?.undoWindowSeconds !== undefined ? { undoWindowSeconds: meta.undoWindowSeconds } : {}),
+    };
+}
+/**
+ * A detached copy of a tool's arguments for the event stream.
+ *
+ * The sink must never be able to change what the tool receives: emitting is
+ * observation, and an observer that mutates `input` in place would make merely
+ * *attaching* a sink alter the run's side effects. `structuredClone` handles
+ * the nested case; the shallow fallback covers a value it refuses (a function,
+ * say) rather than letting a clone failure take the run down.
+ */
+function detach(input) {
+    try {
+        return structuredClone(input);
+    }
+    catch {
+        return { ...input };
+    }
+}
+function truncate(text, max = maxToolResultBytes()) {
+    return text.length <= max
+        ? text
+        : `${text.slice(0, max)}\n…[truncated ${text.length - max} bytes]`;
+}
+/**
+ * Drives a provider-agnostic tool-use loop: the model converses, the runner
+ * executes any requested tools in the sandbox, feeds the results back, and
+ * repeats until the model stops calling tools (or the step budget is hit). The
+ * model orchestrates; deterministic work happens in the tools.
+ */
+export async function runAgent(options) {
+    // A `Provider` is adapted onto the model seam; a `ChatModel` passes straight
+    // through. Either way the loop talks to one interface, so a
+    // middleware-wrapped or registry-resolved model drives it identically.
+    const log = options.log ?? (() => { });
+    const result = await runWithEvents(nativeLoop, {
+        model: asChatModel(options.provider),
+        system: options.system,
+        userPrompt: options.userPrompt,
+        tools: options.tools,
+        limits: resolveLoopLimits(options),
+    }, { log, events: runEventEmitter(options.emit, log) });
+    return result.text;
+}
+/**
+ * The native tool-use loop, as a {@link Loop}.
+ *
+ * Exported for `loop.ts` to wrap; applications reach it through `nativeLoop`
+ * rather than calling this directly. It is the whole of the kernel's control
+ * flow, and the only place any of it lives — `runAgent` and `nativeLoop` both
+ * come here, so the two cannot drift.
+ */
+export async function runNativeLoop(req, loopCtx) {
+    const { model, system, userPrompt, tools } = req;
+    const { maxSteps, maxDurationMs } = req.limits;
+    const log = loopCtx.log;
+    const ctx = { log, budget: { maxDurationMs } };
+    // The emitter is the caller's: `seq` is per RUN, not per loop, so a loop that
+    // made its own would restart the numbering mid-stream.
+    const events = loopCtx.events;
+    const byName = new Map(tools.map((t) => [t.spec.name, t]));
+    const specs = toToolSpecs(tools);
+    const messages = [{ role: "user", text: userPrompt }];
+    const deadline = Date.now() + maxDurationMs;
+    let finalText = "";
+    let lastAssistantText = "";
+    let exhausted = false;
+    let timedOut = false;
+    let stepsTaken = 0;
+    // A throw propagates untouched; `runWithEvents` closes the stream around it,
+    // so every loop gets that property rather than only this one.
+    for (let step = 0; step < maxSteps; step += 1) {
+        // Wall-clock budget: enforced between steps so an in-flight provider/tool
+        // call isn't interrupted mid-flight, mirroring how maxSteps stops cleanly.
+        // Because the check is only between steps, a single step can overshoot the
+        // budget by its entire duration: up to (provider timeout × maxRetries) for the
+        // converse call plus the time to execute all of that step's tool calls. So the
+        // effective ceiling is `maxDurationMs + one full step`, not `maxDurationMs`.
+        if (Date.now() >= deadline) {
+            timedOut = true;
+            log(`reached run time budget (${maxDurationMs}ms) after ${step} step(s)`);
+            events.emit({ type: "run.budget_exhausted", kind: "duration", step });
+            break;
+        }
+        const { value: turn } = await model.invoke({ system, messages, tools: specs }, ctx);
+        stepsTaken = step + 1;
+        messages.push({ role: "assistant", text: turn.text, toolCalls: turn.toolCalls });
+        if (turn.text)
+            lastAssistantText = turn.text;
+        events.emit({
+            type: "model.turn",
+            step,
+            text: turn.text,
+            toolCalls: turn.toolCalls.map((c) => ({ id: c.id, name: c.name })),
+        });
+        if (turn.toolCalls.length === 0) {
+            finalText = turn.text;
+            break;
+        }
+        const results = [];
+        for (const call of turn.toolCalls) {
+            const tool = byName.get(call.name);
+            if (!tool) {
+                results.push({
+                    toolCallId: call.id,
+                    content: `unknown tool: ${call.name}`,
+                    isError: true,
+                });
+                log(`tool ${call.name} (unknown)`);
+                events.emit({
+                    type: "tool.failed",
+                    step,
+                    callId: call.id,
+                    name: call.name,
+                    reason: "unknown_tool",
+                    error: `unknown tool: ${call.name}`,
+                });
+                continue;
+            }
+            // Emitted BEFORE execution: a process that dies mid-tool still leaves
+            // evidence that the effect may have started, which is the one case a
+            // rollback consumer cannot afford to infer from silence.
+            events.emit({
+                type: "tool.called",
+                step,
+                callId: call.id,
+                name: call.name,
+                input: detach(call.input),
+                ...undoFields(tool.meta),
+            });
+            try {
+                // Uses the tool's structured executor when it has one, so a typed
+                // payload survives alongside the string the model sees. Tools without
+                // one take the original string path unchanged.
+                const output = await executeTool(tool, call.input);
+                results.push({
+                    toolCallId: call.id,
+                    content: truncate(output.content),
+                    ...(output.structured !== undefined ? { structured: output.structured } : {}),
+                });
+                log(`tool ${call.name} ok (${output.content.length} bytes)`);
+                // Reversibility is copied from the tool's own metadata at call time —
+                // the tool set can differ per run, so a consumer reading the stream
+                // later must not have to reconstruct which registry was in play.
+                events.emit({
+                    type: "tool.succeeded",
+                    step,
+                    callId: call.id,
+                    name: call.name,
+                    bytes: Buffer.byteLength(output.content, "utf8"),
+                    ...undoFields(tool.meta),
+                });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                results.push({ toolCallId: call.id, content: message, isError: true });
+                log(`tool ${call.name} error: ${message}`);
+                events.emit({
+                    type: "tool.failed",
+                    step,
+                    callId: call.id,
+                    name: call.name,
+                    reason: "threw",
+                    error: message,
+                });
+            }
+        }
+        messages.push({ role: "tool", results });
+        if (step === maxSteps - 1) {
+            exhausted = true;
+            events.emit({ type: "run.budget_exhausted", kind: "steps", step });
+        }
+    }
+    // Ran out of time mid-loop: don't spend more of the (already-blown) budget on
+    // a summary call — just return whatever prose we accumulated, clearly noted.
+    if (!finalText && timedOut) {
+        const accumulated = lastAssistantText || "(no output before time budget exhausted)";
+        const text = `${accumulated}\n\n[run stopped: wall-clock budget of ${maxDurationMs}ms exceeded]`;
+        return { text, steps: stepsTaken, outcome: "timed_out" };
+    }
+    // Hit the step budget mid-tool-use: ask once more with no tools so the model
+    // can summarize, falling back to its last prose rather than losing the work.
+    if (!finalText && exhausted) {
+        log(`reached max steps (${maxSteps}); requesting a final summary`);
+        try {
+            const summary = (await model.invoke({ system, messages, tools: [] }, ctx)).value;
+            // Emitted like any other turn: `run.finished.text` can come from this
+            // call, and a terminal event whose text traces back to no turn in the
+            // transcript would break the stream's one promise.
+            events.emit({ type: "model.turn", step: stepsTaken, text: summary.text, toolCalls: [] });
+            finalText = summary.text || lastAssistantText;
+        }
+        catch (err) {
+            log(`final summary failed: ${err instanceof Error ? err.message : String(err)}`);
+            finalText = lastAssistantText;
+        }
+    }
+    const text = finalText || "(no output)";
+    // `completed` means the model stopped calling tools of its own accord. A run
+    // that hit the step budget and was asked for a summary still reports
+    // `steps_exhausted`, because the distinction is exactly what a consumer needs
+    // to know about the trustworthiness of the answer.
+    const outcome = timedOut ? "timed_out" : exhausted ? "steps_exhausted" : "completed";
+    // `runWithEvents` builds the terminal event from exactly this result, so the
+    // return value and the stream cannot disagree — there is one source now, not
+    // two that happen to be written from the same variables.
+    return { text, steps: stepsTaken, outcome };
+}
+//# sourceMappingURL=agent.js.map

package/dist/agent.js.map

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