@nylorun/runtime 0.26.0-beta → 0.28.0-beta

package/dist/harness/service.d.ts

@@ -1,10 +1,9 @@
 import type { HarnessOptions } from "@nylorun/harness/api";
-import type { ModelProvider } from "../core/provider.js";
 import type { ModelGate } from "../gates/model-gate.js";
-import type { ToolGate } from "../gates/tool-gate.js";
-import { McpPool } from "../mcp/pool.js";
+import { type ToolGate } from "../gates/tool-gate.js";
 import type { SandboxBackend } from "../sandbox/types.js";
 import { type HarnessClient, type HarnessClientOptions } from "./ws-client.js";
+import { type EngineTuning } from "../tuning.js";
 export interface HarnessServiceOptions {
     readonly url: string;
     readonly token: HarnessClientOptions["token"];
@@ -12,24 +11,23 @@ export interface HarnessServiceOptions {
     readonly paths: {
         readonly sandboxes: string;
     };
-    /** Vault-backed model calls (the gates service's client). */
+    /** Every model call (the gates service's client; a scripted model's gate in tests). */
     readonly modelGate: ModelGate;
-    /** Models served without the vault; a harness process has none (`useVaultModel`). */
-    readonly modelProvider?: ModelProvider;
-    readonly useVaultModel: boolean;
-    /** Remote MCP servers (`openMcp`) and keyed cancels; the gates service's client. */
-    readonly toolGate: Pick<ToolGate, "recovers" | "cancel" | "openMcp" | "callHttp">;
     /**
-     * Authorizes a remote MCP server opened in this process. A harness process has no vault: it
-     * opens remote servers through the Tool Gate, and refuses them without one.
+     * Remote MCP servers (`openMcp`), HTTP tools and keyed cancels: the gates service's client. A
+     * harness process has no vault: it opens MCP servers only through the Tool Gate.
      */
-    readonly authorize?: ConstructorParameters<typeof McpPool>[0]["authorize"];
-    /** How remote MCP servers opened in this process are reached (`TenantConfig.delivery`). */
-    readonly delivery?: ConstructorParameters<typeof McpPool>[0]["policy"];
+    readonly toolGate: Pick<ToolGate, "recovers" | "cancel" | "openMcp" | "callHttp">;
     /** Default: the virtual backend under `paths.sandboxes`. */
     readonly sandboxBackends?: readonly SandboxBackend[];
     /** Delete the workspaces on stop (an ephemeral Runtime's loopback harness). */
     readonly ephemeral?: boolean;
+    /**
+     * The sandbox tools' limits: what our engine's schemas name and what this harness runs them
+     * with. Default the Host tuning's `engine.sandboxTools`; each left out is its default
+     * (`DEFAULT_SANDBOX_TOOL_LIMITS`).
+     */
+    readonly sandboxTools?: HarnessOptions["sandboxTools"];
     readonly logger: HarnessClientOptions["logger"];
     readonly version?: string;
     readonly onGrant?: HarnessOptions["onGrant"];
@@ -41,4 +39,9 @@ export interface HarnessService {
     /** Stops leasing and gives runs back (at most `waitMs`), then closes MCP and sandboxes. */
     stop(waitMs?: number): Promise<void>;
 }
+/**
+ * The options of `createHarness` the Host tuning's `engine` group sets (`tuning.ts`): only the
+ * ones set, so the engine keeps its own default for the rest.
+ */
+export declare function engineOptionsOf(engine: EngineTuning): Pick<HarnessOptions, keyof EngineTuning>;
 export declare function startHarnessService(options: HarnessServiceOptions): HarnessService;

package/dist/harness/service.js

@@ -12,12 +12,14 @@
 import { fromWireOp, toWireAnswer } from "../sandbox/disk-fs.js";
 import { join } from "node:path";
 import { DEFAULT_HARNESS, HarnessApiError, } from "@nylorun/core/harness-api";
+import { openMcpThrough } from "../gates/tool-gate.js";
 import { McpPool } from "../mcp/pool.js";
 import { SandboxManager } from "../sandbox/manager.js";
 import { fileSandboxRecords, workspacePrefix } from "../sandbox/records.js";
 import { defaultSandboxBackends } from "../sandbox/select.js";
 import { harnessExecutors } from "./executors.js";
 import { connectHarness } from "./ws-client.js";
+import { hostTuning } from "../tuning.js";
 /** Which request runs each sandbox tool. */
 const METHODS = {
     bash: "workspace.exec",
@@ -27,8 +29,15 @@ const METHODS = {
     write: "workspace.write",
     edit: "workspace.write",
 };
-/** How often the harness closes MCP connections idle past their timeout. */
-const MCP_SWEEP_MS = 60_000;
+/**
+ * The options of `createHarness` the Host tuning's `engine` group sets (`tuning.ts`): only the
+ * ones set, so the engine keeps its own default for the rest.
+ */
+export function engineOptionsOf(engine) {
+    // Every key of the group is an option of `createHarness`, with a type it takes.
+    const options = engine;
+    return Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined));
+}
 /** The SandboxManager's view of the session a workspace request acts for. */
 function refOf(session) {
     return {
@@ -37,9 +46,6 @@ function refOf(session) {
         ...(session.environmentId === undefined ? {} : { environmentId: session.environmentId }),
     };
 }
-const noModel = async () => {
-    throw new Error("This harness calls models only through the gates service");
-};
 export function startHarnessService(options) {
     const { logger } = options;
     const backends = options.sandboxBackends ?? defaultSandboxBackends({ root: options.paths.sandboxes });
@@ -51,28 +57,25 @@ export function startHarnessService(options) {
             throw new HarnessApiError("unavailable", "The harness has not said hello yet");
         return manager;
     };
-    const pool = new McpPool({
-        authorize: options.authorize ??
-            (async () => {
-                throw new Error("This harness opens remote MCP servers only through the gates service");
-            }),
-        ...(options.delivery ? { policy: options.delivery } : {}),
-        ...(options.toolGate.openMcp ? { openRemote: (server) => options.toolGate.openMcp(server) } : {}),
-    });
-    const sweep = setInterval(() => void pool.sweep().catch(() => undefined), MCP_SWEEP_MS);
+    const pool = new McpPool({ openRemote: openMcpThrough(options.toolGate) });
+    // How often the harness closes MCP connections idle past their timeout.
+    const sweep = setInterval(() => void pool.sweep().catch(() => undefined), hostTuning().harness.mcpSweepMs);
     sweep.unref();
+    // Our engine's settings from the Host tuning (`engine`): the executors run the sandbox tools
+    // with the limits the engine writes into their schemas.
+    const engine = engineOptionsOf(hostTuning().engine);
+    const sandboxTools = options.sandboxTools ?? engine.sandboxTools;
     const executors = harnessExecutors({
         model: {
             get tenantId() {
                 return tenantId;
             },
             modelGate: options.modelGate,
-            modelProvider: options.modelProvider ?? noModel,
-            useVaultModel: options.useVaultModel,
         },
         toolGate: options.toolGate,
         mcp: pool,
         sandbox,
+        ...(sandboxTools ? { sandboxTools } : {}),
     });
     const serve = async (method, params, signal) => {
         switch (method) {
@@ -85,17 +88,6 @@ export function startHarnessService(options) {
                     const answer = await sandbox().disk(refOf(call.session), call.spec, fromWireOp(call.disk), signal);
                     return "code" in answer ? answer : toWireAnswer(answer);
                 }
-                if (method === "workspace.read" && "list" in params) {
-                    const call = params;
-                    return sandbox().listFiles(refOf(call.session), call.spec, call.list.dir, call.list.maxEntries, signal);
-                }
-                if (method === "workspace.read" && "bytes" in params) {
-                    const call = params;
-                    const read = await sandbox().readBytes(refOf(call.session), call.spec, call.bytes.path, call.bytes.maxBytes, signal);
-                    return read.kind === "read"
-                        ? { kind: "read", path: read.path, base64: Buffer.from(read.bytes).toString("base64") }
-                        : read;
-                }
                 const call = params;
                 if (METHODS[call.tool] !== method)
                     throw new HarnessApiError("invalid", `${method} does not run ${call.tool}`);
@@ -139,6 +131,8 @@ export function startHarnessService(options) {
         name: DEFAULT_HARNESS,
         ...(options.version ? { version: options.version } : {}),
         features: { workspace: { backends: backends.map((backend) => backend.name) } },
+        ...engine,
+        ...(sandboxTools ? { sandboxTools } : {}),
         onHello(answer) {
             tenantId = answer.tenantId;
             manager ??= new SandboxManager({
@@ -147,14 +141,6 @@ export function startHarnessService(options) {
                 backends,
                 preference: answer.sandbox.backend ?? "auto",
                 ephemeral: options.ephemeral === true,
-                // A skill file's bytes come from core, for the run that made the call.
-                definitionFile: async (sha256, session) => {
-                    const channel = client.channel();
-                    if (!channel || session.claim === undefined)
-                        throw new Error(`No run to fetch ${sha256} for`);
-                    const { base64 } = await channel.request("definition.file", { runId: session.claim, sha256 });
-                    return new Uint8Array(Buffer.from(base64, "base64"));
-                },
                 // A claim core refuses (its run ended, the session is gone) is dropped, as core's own
                 // SandboxManager drops an event it cannot write.
                 emit: async (sessionId, turnId, type, payload, meta) => {

package/dist/harness/setup.d.ts

@@ -1,7 +1,5 @@
 import type { ExecRequest, ExecResult } from "../sandbox/types.js";
 import type { PodHost } from "./pod.js";
-/** How often a failed setup asks whether to run again. */
-export declare const SETUP_RETRY_POLL_MS = 5000;
 export interface DiskSetupOptions {
     readonly host: Pick<PodHost, "setup" | "setupState" | "reportSetup" | "setupFile"> & {
         /** The volume starts from a disk version (R2d step 3): it holds what setup made. */

package/dist/harness/setup.js

@@ -1,9 +1,10 @@
 /**
  * The disk's setup in a pod Environment's engine (R2d step 2): after it joins and before it takes
  * any turn, the engine copies the recipe's input files and runs its setup commands, once per
- * volume. A marker on the volume (`/harness/setup.json`, `{ volumeId, recipeVersion, status }`)
- * says it was done: a resume finds it and skips, a reset (a new volume, a new volume id) runs it
- * again. Commands run as the sandbox tools' do (`localExec`): `/bin/sh -c` in `cwd`, with the
+ * volume. A marker on the volume (`/harness/setup.json`, `{ volumeId, recipeVersion, setupHash,
+ * status }`) says it was done: a resume finds it and skips, a reset (a new volume, a new volume
+ * id) runs it again, and so does a start on a new version whose setup differs (`setupHash`,
+ * track T3). A marker without a hash (written before T3) counts as this setup's. Commands run as the sandbox tools' do (`localExec`): `/bin/sh -c` in `cwd`, with the
  * Environment's variables and secrets (as the sentinel) and egress through egress-gate.
  *
  * A failure is reported to core, which fails the pod and the turn waiting for it; the engine then
@@ -16,12 +17,16 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { dirname, posix } from "node:path";
-/** How often a failed setup asks whether to run again. */
-export const SETUP_RETRY_POLL_MS = 5_000;
-/** How often a fork's setup asks whether its disk version is written (Q17). */
-const AFTER_SEED_POLL_MS = 1_000;
-/** The end of a failed command's output kept in its report. */
-const REPORT_TAIL = 4 * 1024;
+import { hostTuning } from "../tuning.js";
+/** The marker of `setup` done on volume `volumeId`. */
+function markerOf(volumeId, setup) {
+    return {
+        volumeId,
+        recipeVersion: setup?.recipeVersion ?? 0,
+        ...(setup?.setupHash === undefined ? {} : { setupHash: setup.setupHash }),
+        status: "ok",
+    };
+}
 async function readText(path) {
     try {
         return (await readFile(path, "utf8")).trim();
@@ -83,7 +88,7 @@ async function runOnce(options, setup) {
         }
         if (result.exitCode !== 0) {
             const output = `${result.stdout}${result.stderr ? `\n${result.stderr}` : ""}${result.timedOut ? "\n[timed out]" : ""}`;
-            return { status: "failed", index, exitCode: result.exitCode, output: output.slice(-REPORT_TAIL) };
+            return { status: "failed", index, exitCode: result.exitCode, output: output.slice(-hostTuning().harness.setupReportTailChars) };
         }
     }
     return { status: "ok" };
@@ -105,7 +110,7 @@ export async function prepareDisk(options) {
                 setup = state.setup;
                 break;
             }
-            await new Promise((resolve) => setTimeout(resolve, options.pollMs ?? AFTER_SEED_POLL_MS));
+            await new Promise((resolve) => setTimeout(resolve, options.pollMs ?? hostTuning().harness.setupAfterSeedPollMs));
         }
         if (!setup) {
             // Nothing to run: say so, so the fork's turns may start.
@@ -116,7 +121,7 @@ export async function prepareDisk(options) {
     else if (options.host.seeded) {
         // A volume seeded from a disk version: the version holds what setup made, so mark it done.
         if (volumeId) {
-            const done = { volumeId, recipeVersion: setup?.recipeVersion ?? 0, status: "ok" };
+            const done = markerOf(volumeId, setup);
             await writeAtomic(options.markerFile, new TextEncoder().encode(`${JSON.stringify(done)}\n`));
         }
         options.logger.info("environment_setup_skipped", { reason: "seeded" });
@@ -128,7 +133,8 @@ export async function prepareDisk(options) {
     if (marker && volumeId) {
         try {
             const done = JSON.parse(marker);
-            if (done.volumeId === volumeId && done.status === "ok")
+            const same = done.setupHash === undefined || setup.setupHash === undefined || done.setupHash === setup.setupHash;
+            if (done.volumeId === volumeId && done.status === "ok" && same)
                 return;
         }
         catch {
@@ -142,7 +148,7 @@ export async function prepareDisk(options) {
         const report = await runOnce(options, setup);
         if (report.status === "ok") {
             if (volumeId) {
-                const done = { volumeId, recipeVersion: setup.recipeVersion, status: "ok" };
+                const done = markerOf(volumeId, setup);
                 await writeAtomic(options.markerFile, new TextEncoder().encode(`${JSON.stringify(done)}\n`));
             }
             await options.host.reportSetup(report).catch((error) => options.logger.warn("environment_setup_report_failed", {
@@ -157,7 +163,7 @@ export async function prepareDisk(options) {
         for (;;) {
             if (!reported)
                 reported = await options.host.reportSetup(report).then(() => true, () => false);
-            await new Promise((resolve) => setTimeout(resolve, options.pollMs ?? SETUP_RETRY_POLL_MS));
+            await new Promise((resolve) => setTimeout(resolve, options.pollMs ?? hostTuning().harness.setupRetryPollMs));
             if (options.signal?.aborted)
                 return;
             if (!reported)

package/dist/harness/ws-client.d.ts

@@ -4,7 +4,7 @@
  * header. Each connection runs one `createHarness`: it says `hello`, leases runs, and answers
  * core's `workspace.*` requests (`serve`). When the connection is lost its runs stop (core gives
  * their segments to the next advance, which resumes them by replay) and the client connects
- * again after a jittered backoff of 0.5 to 10 s.
+ * again after a jittered backoff (`harness.reconnect` in the Host tuning, 0.5 to 10 s).
  */
 import { type HarnessChannel, type RequestHandler } from "@nylorun/core/harness-api";
 import { type HarnessOptions } from "@nylorun/harness/api";
@@ -23,7 +23,7 @@ export interface HarnessClientOptions extends Omit<HarnessOptions, "channel" | "
     };
     /** Answers core's requests (`workspace.*`). */
     readonly serve?: RequestHandler;
-    /** Reconnect backoff bounds. Default 500 ms to 10 s. */
+    /** Reconnect backoff bounds. Default `harness.reconnect` (Host tuning, 500 ms to 10 s). */
     readonly backoff?: {
         readonly minMs: number;
         readonly maxMs: number;

package/dist/harness/ws-client.js

@@ -4,16 +4,18 @@
  * header. Each connection runs one `createHarness`: it says `hello`, leases runs, and answers
  * core's `workspace.*` requests (`serve`). When the connection is lost its runs stop (core gives
  * their segments to the next advance, which resumes them by replay) and the client connects
- * again after a jittered backoff of 0.5 to 10 s.
+ * again after a jittered backoff (`harness.reconnect` in the Host tuning, 0.5 to 10 s).
  */
 import { createChannel } from "@nylorun/core/harness-api";
 import { createHarness } from "@nylorun/harness/api";
 import { WebSocket } from "ws";
 import { HARNESS_API_HEADER, HARNESS_API_TRANSPORT, HARNESS_MAX_PAYLOAD } from "@nylorun/core/harness-api";
 import { wsPort } from "./ws-port.js";
+import { hostTuning } from "../tuning.js";
 export function connectHarness(options) {
     const { logger } = options;
-    const backoff = options.backoff ?? { minMs: 500, maxMs: 10_000 };
+    const tuning = hostTuning().harness;
+    const backoff = options.backoff ?? tuning.reconnect;
     let stopped = false;
     let connected = false;
     let current;
@@ -26,7 +28,7 @@ export function connectHarness(options) {
             const socket = new WebSocket(options.url, {
                 headers: { authorization: `Bearer ${token}`, [HARNESS_API_HEADER]: HARNESS_API_TRANSPORT },
                 maxPayload: HARNESS_MAX_PAYLOAD,
-                handshakeTimeout: 10_000,
+                handshakeTimeout: tuning.handshakeTimeoutMs,
             });
             socket.once("open", () => {
                 socket.removeAllListeners("error");
@@ -74,7 +76,7 @@ export function connectHarness(options) {
             connected = false;
             // The connection is gone: its runs were aborted with it; let them wind down.
             if (!stopped)
-                await harness.stop(5_000);
+                await harness.stop(tuning.reconnectStopMs);
             channel.close("reconnecting");
             current = undefined;
         }
@@ -109,7 +111,7 @@ export function connectHarness(options) {
             return connected;
         },
         channel: () => current?.channel,
-        async stop(waitMs = 10_000) {
+        async stop(waitMs = tuning.stopMs) {
             stopped = true;
             wake?.();
             const live = current;

package/dist/harness/ws-port.d.ts

@@ -1,14 +1,13 @@
 /**
  * The Harness API over a WebSocket (F6.2): one JSON text message per frame. Either end watches
- * the connection: core pings every `pingMs` (30 s), the harness answers (`ws` does it), and an
- * end that hears nothing from the other for `silenceMs` (90 s) drops the connection. A message
+ * the connection: core pings every `pingMs` (Host tuning `harness.pingMs`, 30 s), the harness
+ * answers (`ws` does it), and an end that hears nothing from the other for `silenceMs`
+ * (`harness.silenceMs`, 90 s) drops the connection. A message
  * that is not JSON closes it (1007); `createChannel({ validate: true })` checks the rest.
  */
 import type { Port } from "@nylorun/core/harness-api";
 import { WebSocket } from "ws";
 export { HARNESS_API_HEADER, HARNESS_API_PATH, HARNESS_API_TRANSPORT, HARNESS_MAX_PAYLOAD, } from "@nylorun/core/harness-api";
-export declare const DEFAULT_PING_MS = 30000;
-export declare const DEFAULT_SILENCE_MS = 90000;
 export interface WsPortOptions {
     /** Send pings (core's end). */
     readonly ping?: boolean;

package/dist/harness/ws-port.js

@@ -1,11 +1,10 @@
 import { WebSocket } from "ws";
+import { hostTuning } from "../tuning.js";
 export { HARNESS_API_HEADER, HARNESS_API_PATH, HARNESS_API_TRANSPORT, HARNESS_MAX_PAYLOAD, } from "@nylorun/core/harness-api";
-export const DEFAULT_PING_MS = 30_000;
-export const DEFAULT_SILENCE_MS = 90_000;
 export function wsPort(socket, options = {}) {
     const frames = [];
     const closes = [];
-    const silenceMs = options.silenceMs ?? DEFAULT_SILENCE_MS;
+    const silenceMs = options.silenceMs ?? hostTuning().harness.silenceMs;
     let lastHeard = Date.now();
     let closed = false;
     let reason = "closed";
@@ -19,7 +18,7 @@ export function wsPort(socket, options = {}) {
         }
         else if (options.ping && socket.readyState === WebSocket.OPEN)
             socket.ping();
-    }, Math.min(options.pingMs ?? DEFAULT_PING_MS, silenceMs));
+    }, Math.min(options.pingMs ?? hostTuning().harness.pingMs, silenceMs));
     watch.unref();
     socket.on("ping", heard);
     socket.on("pong", heard);

package/dist/harness-api/artifacts.d.ts

@@ -0,0 +1,20 @@
+import { type ParamsOf, type ResultOf } from "@nylorun/core/harness-api";
+import { type HarnessLimits } from "@nylorun/core/contracts";
+import type { TenantContext } from "../tenant/context.js";
+/** The run an artifact request is for, as the server holds it. */
+export interface ArtifactScope {
+    readonly runId: string;
+    readonly sessionId: string;
+    readonly turnId: string;
+    /** The Runtime limits of the run's `turn.start`. */
+    readonly limits: HarnessLimits;
+    /** Core's abort of the advance: it stops the run's uploads. */
+    readonly runSignal: AbortSignal;
+}
+export interface ArtifactSeam {
+    read(scope: ArtifactScope, params: ParamsOf<"artifact.read">, signal: AbortSignal): Promise<ResultOf<"artifact.read">>;
+    write(scope: ArtifactScope, params: ParamsOf<"artifact.write">, signal: AbortSignal): Promise<ResultOf<"artifact.write">>;
+    /** The run ended: its open uploads stop, and nothing of them commits. */
+    endRun(runId: string): void;
+}
+export declare function createArtifactSeam(ctx: TenantContext): ArtifactSeam;