@rarebit-one/harness-kernel 0.5.1

package/dist/engines/types.d.ts

@@ -0,0 +1,107 @@
+import type { RunEventSink } from "../events.js";
+import type { ProviderSelection } from "../providers/index.js";
+import type { ConnectorConfig, Permissions, WorkflowDefinition } from "../types.js";
+/**
+ * The provider-neutral, harness-neutral description of one workflow run, handed
+ * to an {@link AgentEngine}. It carries the *materials* (a prepared on-disk
+ * working tree, the workflow, assembled context, permissions, secrets,
+ * connectors, provider selection) — NOT a fixed prompt or tool set, which are
+ * each engine's own concern.
+ *
+ * Crucially, file mutations are out-of-band: an engine edits files under
+ * {@link RunSpec.workdir} and the caller (executeRun) computes the change set by
+ * diffing that tree against the input manifest. So the engine contract never
+ * has to model "an edit" uniformly across the native loop, Claude Code, or Codex.
+ */
+export interface RunSpec {
+    runId: string;
+    workspaceId: string;
+    workflowPath: string;
+    /** The parsed workflow YAML (prompt, runner profile, verify steps, …). */
+    workflow: WorkflowDefinition;
+    /** The run's structured inputs (context_bundle.inputs). */
+    inputs: Record<string, unknown>;
+    /** Pre-assembled curated context text. The native loop bakes it into the
+     *  prompt; a filesystem-native engine (Claude Code) may ignore it and explore. */
+    context: string;
+    /** Absolute path to the prepared sandbox working tree (the engine edits here). */
+    workdir: string;
+    permissions: Permissions;
+    /** Workflow-declared secrets, resolved by the caller. */
+    secrets: Record<string, string>;
+    /** Connectors (MCP/HTTP) with auth tokens already resolved. */
+    connectors: ConnectorConfig[];
+    /** Preferred provider + per-run model + per-org BYO keys. */
+    provider: {
+        preferred?: string | null;
+    } & ProviderSelection;
+    /** Optional budget overrides; engines that don't honour these ignore them. */
+    limits?: {
+        maxSteps?: number;
+        maxDurationMs?: number;
+    };
+}
+export interface EngineContext {
+    /** Append a timestamped line to the run's logs. */
+    log: (line: string) => void;
+    /**
+     * Optional structured event sink for the run.
+     *
+     * `log` is prose for a human; this is the machine-readable account of the
+     * same run. Optional so every existing caller and every existing engine
+     * compiles and behaves unchanged — an engine that has nothing structured to
+     * say simply never calls it, and a caller that wants only logs omits it.
+     *
+     * Engines differ in what they can honour, and that is expected rather than a
+     * gap to close: the in-process loop emits the full stream because it sees
+     * every turn and every tool call, whereas an out-of-process engine only sees
+     * what its transport surfaces. An engine emitting a subset is not degrading
+     * silently — the events it does emit are exact.
+     */
+    emit?: RunEventSink;
+}
+/**
+ * What an engine returns.
+ *
+ * `text` is the run's prose — the one thing every engine has. `emissions` is
+ * whatever else the run produced, and the kernel **never inspects it**: what a
+ * run may emit is the application's vocabulary, not the kernel's.
+ *
+ * This used to be `knowledge: KnowledgeEntry[]` and `issues: IssueEntry[]` —
+ * one application's run protocol, in the kernel's own return type, which the
+ * comment here admitted was wrong and named this as the intended end state. The
+ * in-process engines left them empty and only the out-of-process engine filled
+ * them, so the fields cost every engine a shape they had no use for.
+ *
+ * Opaque means opaque: the kernel does not parse, validate, or default it. An
+ * engine that has nothing to hand back omits it, and a caller casts it to
+ * whatever its own capability surface agreed to write.
+ */
+export interface EngineResult {
+    /** Final assistant prose for the run; the caller writes it as the run artifact. */
+    text: string;
+    /** Anything else the run produced, in the application's own shape. */
+    emissions?: unknown;
+}
+/** The outcome of an engine's capability check for a given run. */
+export type EngineSupport = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * A pluggable agent harness. Implementations: the in-process native tool-use
+ * loop, and (as adapters) Claude Code / Codex. An engine drives the agent to
+ * completion against {@link RunSpec.workdir} and returns prose plus whatever
+ * else the run emitted; file changes land on disk and are captured by the
+ * caller's change-set diff.
+ */
+export interface AgentEngine {
+    readonly name: string;
+    /** Whether this engine can honour the run's hard requirements (capabilities,
+     *  isolation). A false result fails the run rather than degrading silently. */
+    supports(spec: RunSpec): EngineSupport;
+    run(spec: RunSpec, ctx: EngineContext): Promise<EngineResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/engines/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/engines/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAEnF;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,OAAO;IACtB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,MAAM,CAAA;IACpB,0EAA0E;IAC1E,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B;sFACkF;IAClF,OAAO,EAAE,MAAM,CAAA;IACf,kFAAkF;IAClF,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,WAAW,CAAA;IACxB,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,+DAA+D;IAC/D,UAAU,EAAE,eAAe,EAAE,CAAA;IAC7B,6DAA6D;IAC7D,QAAQ,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,GAAG,iBAAiB,CAAA;IAC3D,8EAA8E;IAC9E,MAAM,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CACvD;AAED,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3B;;;;;;;;;;;;;OAaG;IACH,IAAI,CAAC,EAAE,YAAY,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,YAAY;IAC3B,mFAAmF;IACnF,IAAI,EAAE,MAAM,CAAA;IACZ,sEAAsE;IACtE,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB;AAED,mEAAmE;AACnE,MAAM,MAAM,aAAa,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAExE;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;mFAC+E;IAC/E,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,aAAa,CAAA;IACtC,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAAA;CAC9D"}

package/dist/engines/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/engines/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/engines/types.ts"],"names":[],"mappings":""}

package/dist/events.d.ts

@@ -0,0 +1,211 @@
+/**
+ * The run event stream: a structured, ordered record of what happened inside a
+ * run, alongside the human-readable `log` line callback that predates it.
+ *
+ * **The kernel EMITS the stream; it never STORES it.** There is no session
+ * store, no resume, no fork and no replay in here — those need persistence and
+ * a schema, which is exactly the infrastructure a kernel must not ship. What
+ * the kernel owes an application is a faithful, ordered, machine-readable
+ * account of the run; what the application does with it (append to a log,
+ * project into a UI, compute a rollback plan) is policy and lives above.
+ *
+ * This is the same split the rest of the kernel already makes: `ToolMetadata`
+ * declares that a tool is `reversible` without implementing undo, and
+ * `requiresConfirmation` without implementing a confirmation flow. The events
+ * here are the missing half of that bargain — the metadata says a tool *can* be
+ * undone, and the stream is what records that it *was called*, so an
+ * application has something concrete to undo.
+ *
+ * Two properties are deliberate and load-bearing:
+ *
+ *   - **Ordered.** Every event carries a monotonic `seq` from a single counter
+ *     per run. A consumer that receives events out of band can still sort them,
+ *     and a gap in the sequence is detectable — a dropped event is not allowed
+ *     to look like an event that never happened.
+ *   - **Non-fatal.** A sink that throws is reported through `log` and skipped;
+ *     it never fails the run. Observability that can take production down is
+ *     worse than no observability, and the kernel already applies this rule to
+ *     context providers.
+ */
+/** Every event kind the loop emits. */
+export type RunEventType = "run.started" | "model.turn" | "tool.called" | "tool.succeeded" | "tool.failed" | "run.budget_exhausted" | "run.finished";
+/**
+ * Fields common to every event.
+ *
+ * `seq` is per-run and starts at 0. `at` is epoch milliseconds rather than a
+ * formatted string: a consumer that wants a locale-formatted timestamp can make
+ * one, but a consumer handed a formatted string cannot reliably get the instant
+ * back.
+ */
+export interface RunEventBase {
+    seq: number;
+    at: number;
+}
+/** Why a run stopped. `failed` means the loop threw — the error propagates to
+ *  the caller unchanged, but the stream is closed first so a persistent
+ *  consumer can tell a crashed run from one that is still going. */
+export type RunOutcome = "completed" | "steps_exhausted" | "timed_out" | "failed";
+/** Which budget ran out. */
+export type BudgetKind = "steps" | "duration";
+/** The loop is about to take its first turn. Carries the resolved budgets and
+ *  the tool surface actually handed to the model — which is the projected
+ *  surface, after metadata scoping, not everything the caller passed in. */
+export interface RunStartedEvent extends RunEventBase {
+    type: "run.started";
+    maxSteps: number;
+    maxDurationMs: number;
+    tools: string[];
+}
+/** One assistant turn: its prose and the tool calls it requested. */
+export interface ModelTurnEvent extends RunEventBase {
+    type: "model.turn";
+    step: number;
+    text: string;
+    toolCalls: {
+        id: string;
+        name: string;
+    }[];
+}
+/**
+ * A tool is about to execute. Emitted before the call so a crash mid-tool still
+ * leaves evidence that the effect may have started — which is precisely the
+ * case a rollback consumer must not miss.
+ *
+ * It carries the same reversibility fields as {@link ToolSucceededEvent}, and
+ * that duplication is the point: a tool that half-applies its effect and then
+ * throws produces `tool.called` + `tool.failed`, so if undo metadata appeared
+ * only on success the one case this event exists for would be the one case a
+ * consumer could not act on.
+ *
+ * `input` is a detached copy, never the object handed to the tool — see the
+ * note in the loop. **It is also the raw tool arguments**: anything a model
+ * passed as an argument, including a secret or PII it was given, now reaches
+ * every attached sink. Nothing outside the model conversation captured these
+ * before, so a sink that persists or forwards events is a new place for that
+ * data to land and should redact accordingly.
+ */
+export interface ToolCalledEvent extends RunEventBase {
+    type: "tool.called";
+    step: number;
+    callId: string;
+    name: string;
+    input: Record<string, unknown>;
+    reversible?: boolean;
+    undoToolName?: string | null;
+    undoWindowSeconds?: number | null;
+}
+/**
+ * A tool executed successfully.
+ *
+ * The reversibility fields are copied from the tool's own {@link ToolMetadata}
+ * at call time, not looked up later: the tool set can differ between runs and
+ * between steps, so a consumer reading the stream after the fact must not have
+ * to reconstruct which registry was in play. `reversible` absent means the tool
+ * declared nothing, which per the metadata contract means "no restriction" —
+ * and here specifically means "makes no claim", never "safe to undo".
+ */
+export interface ToolSucceededEvent extends RunEventBase {
+    type: "tool.succeeded";
+    step: number;
+    callId: string;
+    name: string;
+    /** UTF-8 byte length of the model-facing string, before truncation. Bytes
+     *  rather than `String.length`, which counts UTF-16 code units and
+     *  under-reports anything outside the BMP. */
+    bytes: number;
+    reversible?: boolean;
+    undoToolName?: string | null;
+    undoWindowSeconds?: number | null;
+}
+/** A tool call did not produce a result. `unknown_tool` is separated from
+ *  `threw` because they mean different things to a consumer: one is a model
+ *  hallucinating a name, the other is a real effect that may have partially
+ *  landed. */
+export interface ToolFailedEvent extends RunEventBase {
+    type: "tool.failed";
+    step: number;
+    callId: string;
+    name: string;
+    reason: "threw" | "unknown_tool";
+    error: string;
+}
+/** A budget was exhausted. Emitted at the moment the loop notices, which for
+ *  `duration` is between steps — see the overshoot note on the loop itself. */
+export interface RunBudgetExhaustedEvent extends RunEventBase {
+    type: "run.budget_exhausted";
+    kind: BudgetKind;
+    step: number;
+}
+/**
+ * The run is over. Always the last event, whatever the outcome — including when
+ * the loop throws, in which case it is emitted before the error propagates.
+ *
+ * `steps` and `text` are optional because on the failure path they are genuinely
+ * unknown: the loop threw and never returned a result, so any number here would
+ * be **invented**. They are omitted rather than zeroed — a wrong number is worse
+ * than an absent one, and the `model.turn` events already in the stream are the
+ * authoritative record of how far the run got. On every other outcome both are
+ * present.
+ */
+export interface RunFinishedEvent extends RunEventBase {
+    type: "run.finished";
+    outcome: RunOutcome;
+    steps?: number;
+    text?: string;
+    /** Present only when `outcome` is `failed`. */
+    error?: string;
+}
+export type RunEvent = RunStartedEvent | ModelTurnEvent | ToolCalledEvent | ToolSucceededEvent | ToolFailedEvent | RunBudgetExhaustedEvent | RunFinishedEvent;
+/** Where events go. Synchronous and returning void on purpose: a sink that
+ *  needs to do I/O should buffer and flush on its own schedule rather than make
+ *  the loop await it. */
+export type RunEventSink = (event: RunEvent) => void;
+/** The per-event fields a caller supplies; `seq` and `at` are the emitter's. */
+export type RunEventInput = Omit<RunStartedEvent, keyof RunEventBase> | Omit<ModelTurnEvent, keyof RunEventBase> | Omit<ToolCalledEvent, keyof RunEventBase> | Omit<ToolSucceededEvent, keyof RunEventBase> | Omit<ToolFailedEvent, keyof RunEventBase> | Omit<RunBudgetExhaustedEvent, keyof RunEventBase> | Omit<RunFinishedEvent, keyof RunEventBase>;
+/**
+ * The events a {@link Loop} may emit: everything except the bookends.
+ *
+ * `run.started` and `run.finished` belong to `runWithEvents`, which brackets
+ * whichever loop runs. A loop that emitted its own would produce a duplicate
+ * start, or a premature terminal event that a consumer stops reading at — and
+ * a loop migrated from the older API, where loops DID own their stream, is
+ * exactly the code that would try. Excluding them from the type means that
+ * migration fails to compile instead of producing a subtly wrong stream.
+ */
+export type LoopEventInput = Exclude<RunEventInput, {
+    type: "run.started";
+} | {
+    type: "run.finished";
+}>;
+/** Stamps `seq`/`at` and delivers to a sink, isolating sink failures. */
+export interface LoopEventEmitter {
+    emit(event: LoopEventInput): void;
+    readonly count: number;
+}
+export interface RunEventEmitter {
+    emit(event: RunEventInput): void;
+    /** How many events have been stamped. Lets a caller close a run with the
+     *  step/event count without threading a second counter through the loop. */
+    readonly count: number;
+}
+/**
+ * Build an emitter over an optional sink.
+ *
+ * With no sink this is a functioning no-op — the counter still advances, so
+ * turning the sink on later cannot change the sequence numbering. Callers
+ * therefore never branch on whether events are wanted.
+ */
+export declare function runEventEmitter(sink?: RunEventSink, log?: (line: string) => void): RunEventEmitter;
+/**
+ * An in-memory append-only recorder — the smallest possible session log, and
+ * the reference shape for a persistent one.
+ *
+ * Provided because a caller should not have to write an array-push to test that
+ * a run emitted what it should. It is explicitly NOT a session store: it has no
+ * persistence, no identity and no bound on growth.
+ */
+export declare function recordRunEvents(): {
+    sink: RunEventSink;
+    events: RunEvent[];
+};
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

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

package/dist/events.js

@@ -0,0 +1,69 @@
+/**
+ * The run event stream: a structured, ordered record of what happened inside a
+ * run, alongside the human-readable `log` line callback that predates it.
+ *
+ * **The kernel EMITS the stream; it never STORES it.** There is no session
+ * store, no resume, no fork and no replay in here — those need persistence and
+ * a schema, which is exactly the infrastructure a kernel must not ship. What
+ * the kernel owes an application is a faithful, ordered, machine-readable
+ * account of the run; what the application does with it (append to a log,
+ * project into a UI, compute a rollback plan) is policy and lives above.
+ *
+ * This is the same split the rest of the kernel already makes: `ToolMetadata`
+ * declares that a tool is `reversible` without implementing undo, and
+ * `requiresConfirmation` without implementing a confirmation flow. The events
+ * here are the missing half of that bargain — the metadata says a tool *can* be
+ * undone, and the stream is what records that it *was called*, so an
+ * application has something concrete to undo.
+ *
+ * Two properties are deliberate and load-bearing:
+ *
+ *   - **Ordered.** Every event carries a monotonic `seq` from a single counter
+ *     per run. A consumer that receives events out of band can still sort them,
+ *     and a gap in the sequence is detectable — a dropped event is not allowed
+ *     to look like an event that never happened.
+ *   - **Non-fatal.** A sink that throws is reported through `log` and skipped;
+ *     it never fails the run. Observability that can take production down is
+ *     worse than no observability, and the kernel already applies this rule to
+ *     context providers.
+ */
+/**
+ * Build an emitter over an optional sink.
+ *
+ * With no sink this is a functioning no-op — the counter still advances, so
+ * turning the sink on later cannot change the sequence numbering. Callers
+ * therefore never branch on whether events are wanted.
+ */
+export function runEventEmitter(sink, log = () => { }) {
+    let seq = 0;
+    return {
+        emit(event) {
+            const stamped = { ...event, seq: seq++, at: Date.now() };
+            if (!sink)
+                return;
+            try {
+                sink(stamped);
+            }
+            catch (err) {
+                // Never fail a run because its observability failed.
+                log(`event sink threw on ${stamped.type}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        get count() {
+            return seq;
+        },
+    };
+}
+/**
+ * An in-memory append-only recorder — the smallest possible session log, and
+ * the reference shape for a persistent one.
+ *
+ * Provided because a caller should not have to write an array-push to test that
+ * a run emitted what it should. It is explicitly NOT a session store: it has no
+ * persistence, no identity and no bound on growth.
+ */
+export function recordRunEvents() {
+    const events = [];
+    return { sink: (event) => void events.push(event), events };
+}
+//# sourceMappingURL=events.js.map

package/dist/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAqMH;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAC7B,IAAmB,EACnB,MAA8B,GAAG,EAAE,GAAE,CAAC;IAEtC,IAAI,GAAG,GAAG,CAAC,CAAA;IACX,OAAO;QACL,IAAI,CAAC,KAAoB;YACvB,MAAM,OAAO,GAAa,EAAE,GAAG,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAA;YAClE,IAAI,CAAC,IAAI;gBAAE,OAAM;YACjB,IAAI,CAAC;gBACH,IAAI,CAAC,OAAO,CAAC,CAAA;YACf,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,qDAAqD;gBACrD,GAAG,CACD,uBAAuB,OAAO,CAAC,IAAI,KAAK,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAC3F,CAAA;YACH,CAAC;QACH,CAAC;QACD,IAAI,KAAK;YACP,OAAO,GAAG,CAAA;QACZ,CAAC;KACF,CAAA;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe;IAC7B,MAAM,MAAM,GAAe,EAAE,CAAA;IAC7B,OAAO,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;AAC7D,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,63 @@
+export type { ConnectorConfig, Permissions, WorkflowDefinition } from "./types.js";
+export { selectProvider } from "./providers/index.js";
+export type { ProviderSelection } from "./providers/index.js";
+export type { Provider, CompletionRequest, ConverseRequest, ConverseResult, AgentMessage, ToolSpec, ToolCall, ToolResult, } from "./providers/types.js";
+export { AnthropicProvider } from "./providers/anthropic.js";
+export { OpenAIProvider, OpenAICompatibleProvider } from "./providers/openai.js";
+export type { OpenAICompatibleOptions } from "./providers/openai.js";
+export { OpenRouterProvider } from "./providers/openrouter.js";
+export type { OpenRouterAttribution } from "./providers/openrouter.js";
+export { MockProvider } from "./providers/mock.js";
+export { emitCompleteToolCall, invokeStreaming, modelIdentity, requireCapability, CapabilityError, } from "./models/types.js";
+export type { ModelInvocation, ModelKind, ModelCaps, ModelIdentity, ModelResult, InvokeContext, StreamSink, Usage, TokenUsage, UnitUsage, Health, HealthStatus, } from "./models/types.js";
+export { chatModel, asChatModel, isChatModel, chatRequest, CHAT_KIND } from "./models/chat.js";
+export type { ChatModel, ChatRequest, ChatResponse, ChatPart, BinaryRef } from "./models/chat.js";
+export { ModelRegistry, UnknownModelError } from "./models/registry.js";
+export type { ModelRef, ModelFactory, ModelSupport } from "./models/registry.js";
+export { withMiddleware, correlationMiddleware, loggingMiddleware, healthTrackingMiddleware, errorRedactionMiddleware, HealthTracker, } from "./models/middleware.js";
+export type { Middleware, Invoker, StreamInvoker } from "./models/middleware.js";
+export { StaticRouteResolver } from "./routing/staticResolver.js";
+export { UnknownCapabilityError } from "./routing/types.js";
+export type { RouteResolver, RouteContext, RouteLimits, CapabilityDefinition, ResolvedRoute, } from "./routing/types.js";
+export { assembleContext, renderContext } from "./context/types.js";
+export type { ContextProvider, ContextFragment, ContextSpec } from "./context/types.js";
+export { runAgent, maxToolResultBytes, resolveLoopLimits } from "./agent.js";
+export type { RunAgentOptions } from "./agent.js";
+export { nativeLoop, runWithEvents } from "./loop.js";
+export type { Loop, LoopRequest, LoopContext, RunContext, LoopResult } from "./loop.js";
+export { runEventEmitter, recordRunEvents } from "./events.js";
+export type { RunEvent, RunEventType, RunEventBase, RunEventInput, RunEventSink, RunEventEmitter, LoopEventInput, LoopEventEmitter, RunOutcome, BudgetKind, RunStartedEvent, ModelTurnEvent, ToolCalledEvent, ToolSucceededEvent, ToolFailedEvent, RunBudgetExhaustedEvent, RunFinishedEvent, } from "./events.js";
+export { primitiveTools, connectorTools, executeTool } from "./tools/registry.js";
+export type { Tool, ToolOutput } from "./tools/registry.js";
+export { selectTools, isToolVisible, toToolSpecs, toolsRequiringConfirmation, undoToolFor, } from "./tools/metadata.js";
+export type { ToolMetadata, ToolSelection, InvocationMode, ResultRetention, ClientResultVisibility, } from "./tools/metadata.js";
+export { modelAsTool } from "./tools/modelTool.js";
+export type { ModelToolOptions } from "./tools/modelTool.js";
+export { runCode } from "./primitives/codeExec.js";
+export type { RunCodeOptions, RunCodeResult } from "./primitives/codeExec.js";
+export { readFileSafe, listFiles } from "./primitives/fs.js";
+export { httpFetch } from "./primitives/http.js";
+export type { HttpFetchOptions, HttpResponse } from "./primitives/http.js";
+export { downloadToFile } from "./primitives/download.js";
+export type { DownloadOptions } from "./primitives/download.js";
+export { connectMcp, MCP_CLIENT_NAME } from "./connectors/mcpClient.js";
+export type { McpConnection } from "./connectors/mcpClient.js";
+export { selectEngine } from "./engines/index.js";
+export type { EngineSelection } from "./engines/index.js";
+export type { AgentEngine, EngineContext, EngineResult, EngineSupport, RunSpec, } from "./engines/types.js";
+export { NativeEngine } from "./engines/native.js";
+export type { NativeEngineOptions, DomainToolFactory } from "./engines/native.js";
+export { ClaudeCodeEngine } from "./engines/claudeCode.js";
+export type { ClaudeCodeOptions, ClaudeCodeDriver } from "./engines/claudeCode.js";
+export { CodexEngine } from "./engines/codex.js";
+export type { CodexOptions, CodexDriver } from "./engines/codex.js";
+export { writeFileCapability, denyCrossWorkspace, resolveWithin } from "./engines/capability.js";
+export type { CapabilityContext, CapabilityResult, CapabilityTool } from "./engines/capability.js";
+export { defaultCapabilityTools } from "./engines/claudeCode.js";
+export type { CapabilityToolFactory } from "./engines/claudeCode.js";
+export { capabilitySdkServer, capabilityToolIds, CAPABILITY_SERVER_NAME, } from "./engines/capabilityMcp.js";
+export { buildCapabilityStdioServer, serveCapability, capabilityStdioConfigFromEnv, } from "./engines/capabilityStdio.js";
+export type { CapabilityStdioOptions, CapabilityStdioConfig } from "./engines/capabilityStdio.js";
+export { readEmissions, writeEmissions } from "./engines/capabilityEmissions.js";
+export { secretsToEnv } from "./secrets.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -0,0 +1,82 @@
+// The kernel's public API. Anything not re-exported here is internal and may
+// change without notice — adding an export is a compatibility commitment, so do
+// it deliberately.
+// ---------------------------------------------------------------------------
+// Providers — the model adapters and their selection
+// ---------------------------------------------------------------------------
+export { selectProvider } from "./providers/index.js";
+export { AnthropicProvider } from "./providers/anthropic.js";
+export { OpenAIProvider, OpenAICompatibleProvider } from "./providers/openai.js";
+export { OpenRouterProvider } from "./providers/openrouter.js";
+export { MockProvider } from "./providers/mock.js";
+// ---------------------------------------------------------------------------
+// The model seam — the neutral arrow every model kind is invoked through
+// ---------------------------------------------------------------------------
+export { emitCompleteToolCall, invokeStreaming, modelIdentity, requireCapability, CapabilityError, } from "./models/types.js";
+// The chat kind, and the adapter that puts an existing Provider on the seam.
+export { chatModel, asChatModel, isChatModel, chatRequest, CHAT_KIND } from "./models/chat.js";
+// Extension point 1 — bind kind+id to a concrete invocation.
+export { ModelRegistry, UnknownModelError } from "./models/registry.js";
+// Extension point 3 — cross-cutting concerns over every kind, uniformly.
+export { withMiddleware, correlationMiddleware, loggingMiddleware, healthTrackingMiddleware, errorRedactionMiddleware, HealthTracker, } from "./models/middleware.js";
+// ---------------------------------------------------------------------------
+// Extension point 2 — route resolution (capability → model + prompt + tools)
+// ---------------------------------------------------------------------------
+export { StaticRouteResolver } from "./routing/staticResolver.js";
+export { UnknownCapabilityError } from "./routing/types.js";
+// ---------------------------------------------------------------------------
+// Extension point 5 — pluggable context assembly
+// ---------------------------------------------------------------------------
+export { assembleContext, renderContext } from "./context/types.js";
+// ---------------------------------------------------------------------------
+// The tool-use loop
+// ---------------------------------------------------------------------------
+export { runAgent, maxToolResultBytes, resolveLoopLimits } from "./agent.js";
+// Extension point 7 — the control loop itself. The kernel ships exactly one
+// (`nativeLoop`, the loop `runAgent` has always run); this is the interface
+// around it, so an application can change control flow without forking.
+export { nativeLoop, runWithEvents } from "./loop.js";
+// The run event stream. The kernel emits it; storing, resuming or replaying it
+// is the application's, because that needs persistence a kernel must not ship.
+export { runEventEmitter, recordRunEvents } from "./events.js";
+// ---------------------------------------------------------------------------
+// Extension point 6 — tools: generic primitives, injectable domain emissions,
+// MCP connectors, rich metadata + projections, and models-as-tools
+// ---------------------------------------------------------------------------
+export { primitiveTools, connectorTools, executeTool } from "./tools/registry.js";
+export { selectTools, isToolVisible, toToolSpecs, toolsRequiringConfirmation, undoToolFor, } from "./tools/metadata.js";
+export { modelAsTool } from "./tools/modelTool.js";
+// ---------------------------------------------------------------------------
+// Sandbox primitives (the executors the tools are built on)
+// ---------------------------------------------------------------------------
+export { runCode } from "./primitives/codeExec.js";
+export { readFileSafe, listFiles } from "./primitives/fs.js";
+export { httpFetch } from "./primitives/http.js";
+export { downloadToFile } from "./primitives/download.js";
+// ---------------------------------------------------------------------------
+// MCP connectors
+// ---------------------------------------------------------------------------
+export { connectMcp, MCP_CLIENT_NAME } from "./connectors/mcpClient.js";
+// ---------------------------------------------------------------------------
+// Engines — the pluggable-harness seam
+// ---------------------------------------------------------------------------
+export { selectEngine } from "./engines/index.js";
+export { NativeEngine } from "./engines/native.js";
+export { ClaudeCodeEngine } from "./engines/claudeCode.js";
+export { CodexEngine } from "./engines/codex.js";
+// The capability mechanism. The kernel supplies the workspace-scope guards, the
+// one capability with no product semantics (write_file), and the two transports
+// that expose a surface to an external engine. WHICH capabilities a run gets is
+// the application's decision, injected via the seams above.
+export { writeFileCapability, denyCrossWorkspace, resolveWithin } from "./engines/capability.js";
+export { defaultCapabilityTools } from "./engines/claudeCode.js";
+export { capabilitySdkServer, capabilityToolIds, CAPABILITY_SERVER_NAME, } from "./engines/capabilityMcp.js";
+export { buildCapabilityStdioServer, serveCapability, capabilityStdioConfigFromEnv, } from "./engines/capabilityStdio.js";
+// The emissions file: the generic seam for getting state back out of an
+// out-of-process engine, which cannot share memory with the run that spawned it.
+export { readEmissions, writeEmissions } from "./engines/capabilityEmissions.js";
+// ---------------------------------------------------------------------------
+// Secrets
+// ---------------------------------------------------------------------------
+export { secretsToEnv } from "./secrets.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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