@nylorun/runtime 0.26.0-beta → 0.27.0-beta

package/dist/tenant/module.js

@@ -1,10 +1,7 @@
 import { openError, TenantOpenError } from "./cause.js";
 import { TimeoutError, withTimeout } from "./pool.js";
+import { hostTuning } from "../tuning.js";
 import { TenantUnavailableError, } from "./types.js";
-const OPEN_TIMEOUT_MS = 30_000;
-/** Retries of an open that failed outside the Tenant: from 1 s, doubling, at most 30 s apart. */
-const RETRY_FIRST_MS = 1_000;
-const RETRY_MAX_MS = 30_000;
 /**
  * Deep Tenant module (§8): the Host's one Tenant over an injected opener (tenancy.md §5).
  *
@@ -15,11 +12,15 @@ const RETRY_MAX_MS = 30_000;
  * with backoff, and by the next request, which gets 503 meanwhile.
  */
 export function createTenantModule(options) {
-    const { logger, openTimeoutMs = OPEN_TIMEOUT_MS } = options;
+    const tuning = hostTuning().tenant;
+    const { logger, openTimeoutMs = tuning.openTimeoutMs } = options;
+    // Retries of an open that failed outside the Tenant: from `openRetry.minMs`, doubling, at most
+    // `openRetry.maxMs` apart.
+    const { minMs: firstRetryMs, maxMs: maxRetryMs } = tuning.openRetry;
     let state = { kind: "idle" };
     let opening;
     let retry;
-    let nextDelayMs = RETRY_FIRST_MS;
+    let nextDelayMs = firstRetryMs;
     const current = () => state;
     async function openOnce() {
         let handle;
@@ -64,7 +65,7 @@ export function createTenantModule(options) {
             return;
         }
         state = { kind: "open", handle };
-        nextDelayMs = RETRY_FIRST_MS;
+        nextDelayMs = firstRetryMs;
         logger.info("tenant opened", { tenantId: handle.envelope.id });
         try {
             await options.onOpen?.(handle);
@@ -92,7 +93,7 @@ export function createTenantModule(options) {
         if (retry)
             return;
         const delayMs = nextDelayMs;
-        nextDelayMs = Math.min(delayMs * 2, RETRY_MAX_MS);
+        nextDelayMs = Math.min(delayMs * 2, maxRetryMs);
         retry = setTimeout(() => {
             retry = undefined;
             void load();

package/dist/tenant/outbound.d.ts

@@ -30,8 +30,6 @@ export type OutboundResult = {
     code: string;
     message: string;
 };
-/** The largest answer read from an endpoint. */
-export declare const MAX_RESPONSE_BYTES: number;
 /** True when `address` is private, loopback, link-local or unspecified (IPv4-mapped included). */
 export declare function isPrivateAddress(address: string): boolean;
 /** Why the Host refuses `url`, or `undefined` when it may be called. */
@@ -44,7 +42,8 @@ export declare function refusal(url: URL, policy: OutboundPolicy): string | unde
 export declare function send(target: string, body: string | undefined, headers: Record<string, string>, options: {
     policy: OutboundPolicy;
     signal: AbortSignal;
-    maxResponseBytes?: number;
+    /** The largest answer read: the Tenant's Runtime limit `toolAnswerBytes` for an HTTP tool. */
+    maxResponseBytes: number;
     method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
 }): Promise<OutboundResult>;
 /**
@@ -71,23 +70,21 @@ export declare class OutboundFailed extends Error {
      */
     sent?: boolean);
 }
-/** The largest answer `guardedFetch` reads. */
-export declare const MAX_FETCH_RESPONSE_BYTES: number;
-/** How long a `guardedFetch` request may take without a signal of its own. */
-export declare const FETCH_TIMEOUT_MS = 30000;
 /**
  * A `fetch` under the Host's address policy (F9 C2): the literal-IP and DNS checks of `post`
  * on the address actually connected to, `localhost` rewritten for the local stack, no
- * redirects (`redirect: "error"`; a 3xx answer rejects), a bounded answer and a 30 s timeout
- * unless the caller passes a signal. A refused URL or address rejects with `OutboundRefused`,
- * any other failure with `OutboundFailed`.
+ * redirects (`redirect: "error"`; a 3xx answer rejects), an answer of at most `maxResponseBytes`
+ * and a `timeoutMs` timeout unless the caller passes a signal, both the caller's (a Tenant's
+ * Runtime limits). A refused URL or address rejects with `OutboundRefused`, any other failure
+ * with `OutboundFailed`.
  *
  * `stream`: the Response resolves once the headers arrive and its body streams, unbounded and
  * with no timeout but the caller's signal: remote MCP servers, whose answers and event streams
  * stay open (`mcp/connect.ts`).
  */
-export declare function guardedFetch(policy: OutboundPolicy, options?: {
-    maxResponseBytes?: number;
-    timeoutMs?: number;
-    stream?: boolean;
+export declare function guardedFetch(policy: OutboundPolicy, options: {
+    maxResponseBytes: number;
+    timeoutMs: number;
+} | {
+    stream: true;
 }): typeof fetch;

package/dist/tenant/outbound.js

@@ -13,8 +13,6 @@ import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
 import { BlockList, isIP } from "node:net";
 import { Readable } from "node:stream";
-/** The largest answer read from an endpoint. */
-export const MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
 const PRIVATE = new BlockList();
 for (const [network, prefix] of [
     ["0.0.0.0", 8],
@@ -82,7 +80,7 @@ function guardedLookup(policy) {
  */
 export async function send(target, body, headers, options) {
     const { policy, signal } = options;
-    const limit = options.maxResponseBytes ?? MAX_RESPONSE_BYTES;
+    const limit = options.maxResponseBytes;
     const url = new URL(target);
     const refused = refusal(url, policy);
     if (refused)
@@ -168,25 +166,22 @@ export class OutboundFailed extends Error {
         this.name = "OutboundFailed";
     }
 }
-/** The largest answer `guardedFetch` reads. */
-export const MAX_FETCH_RESPONSE_BYTES = 1024 * 1024;
-/** How long a `guardedFetch` request may take without a signal of its own. */
-export const FETCH_TIMEOUT_MS = 30_000;
 /**
  * A `fetch` under the Host's address policy (F9 C2): the literal-IP and DNS checks of `post`
  * on the address actually connected to, `localhost` rewritten for the local stack, no
- * redirects (`redirect: "error"`; a 3xx answer rejects), a bounded answer and a 30 s timeout
- * unless the caller passes a signal. A refused URL or address rejects with `OutboundRefused`,
- * any other failure with `OutboundFailed`.
+ * redirects (`redirect: "error"`; a 3xx answer rejects), an answer of at most `maxResponseBytes`
+ * and a `timeoutMs` timeout unless the caller passes a signal, both the caller's (a Tenant's
+ * Runtime limits). A refused URL or address rejects with `OutboundRefused`, any other failure
+ * with `OutboundFailed`.
  *
  * `stream`: the Response resolves once the headers arrive and its body streams, unbounded and
  * with no timeout but the caller's signal: remote MCP servers, whose answers and event streams
  * stay open (`mcp/connect.ts`).
  */
-export function guardedFetch(policy, options = {}) {
-    const limit = options.maxResponseBytes ?? MAX_FETCH_RESPONSE_BYTES;
-    const timeoutMs = options.timeoutMs ?? FETCH_TIMEOUT_MS;
-    const stream = options.stream === true;
+export function guardedFetch(policy, options) {
+    const stream = "stream" in options;
+    const limit = "stream" in options ? Infinity : options.maxResponseBytes;
+    const timeoutMs = "stream" in options ? undefined : options.timeoutMs;
     const lookup = guardedLookup(policy);
     const guarded = async (input, init = {}) => {
         const request = input instanceof Request ? input : undefined;
@@ -217,7 +212,7 @@ export function guardedFetch(policy, options = {}) {
         }
         const originalHost = url.host;
         dockerHost(url, policy);
-        const signal = init.signal ?? request?.signal ?? (stream ? undefined : AbortSignal.timeout(timeoutMs));
+        const signal = init.signal ?? request?.signal ?? (timeoutMs === undefined ? undefined : AbortSignal.timeout(timeoutMs));
         const outgoing = { host: originalHost };
         for (const [name, value] of headers)
             outgoing[name] = value;

package/dist/tenant/run-grants.js

@@ -1,4 +1,5 @@
-import { mintRunToken, RUN_TOKEN_RENEW_SECONDS } from "./run-token.js";
+import { mintRunToken } from "./run-token.js";
+import { hostTuning } from "../tuning.js";
 export function createRunGrants() {
     const grants = new Map();
     return {
@@ -50,7 +51,7 @@ export async function renewRunGrant(ctx, lease, run, active = () => true) {
     const held = ctx.runGrants.get(lease.sessionId);
     if (held && held.claims.epoch !== lease.epoch)
         return;
-    if (held && held.claims.expiresAt - Date.now() > RUN_TOKEN_RENEW_SECONDS * 1000)
+    if (held && held.claims.expiresAt - Date.now() > hostTuning().keys.runTokenRenewSeconds * 1000)
         return;
     const grant = await mintRunToken(ctx, lease, held ? { agentId: held.claims.agentId, activeTurnId: held.claims.turnId } : run);
     if (active())

package/dist/tenant/run-token.d.ts

@@ -4,10 +4,6 @@ import type { SessionStore } from "../store/types.js";
 import type { Lease } from "./context.js";
 export declare const RUN_TOKEN_TYP = "nylorun-run+jwt";
 export declare const RUN_TOKEN_AUD = "nylorun-gates";
-/** How long a run token lives. */
-export declare const RUN_TOKEN_TTL_SECONDS: number;
-/** The lease heartbeat re-mints a token with less than this left. */
-export declare const RUN_TOKEN_RENEW_SECONDS: number;
 /** What a verified run token says: one lease of one session's turn. */
 export interface RunClaims {
     readonly tenantId: string;

package/dist/tenant/run-token.js

@@ -6,7 +6,7 @@
  *
  * Signed by the keys service with the Tenant's current signing key, like capability links,
  * and told apart from them by `typ` and `aud`. Internal: not in `openapi.json`. A token lives
- * `RUN_TOKEN_TTL_SECONDS`, no longer than `TOKEN_TTL_MAX_SECONDS`, so a key rotation never
+ * `keys.runTokenTtlSeconds` (Host tuning), no longer than `keys.tokenTtlMaxSeconds`, so a key rotation never
  * revokes a live one (`signing-keys.ts`).
  *
  * ```text
@@ -18,15 +18,10 @@
 import { randomUUID } from "node:crypto";
 import { errors, importJWK, jwtVerify } from "jose";
 import { tenantTokenIssuer } from "@nylorun/core/contracts";
-import { CLOCK_TOLERANCE_SECONDS, tokenKeyId } from "./jwt.js";
+import { clockToleranceSeconds, tokenKeyId } from "./jwt.js";
+import { hostTuning } from "../tuning.js";
 export const RUN_TOKEN_TYP = "nylorun-run+jwt";
 export const RUN_TOKEN_AUD = "nylorun-gates";
-/** How long a run token lives. */
-export const RUN_TOKEN_TTL_SECONDS = 15 * 60;
-/** The lease heartbeat re-mints a token with less than this left. */
-export const RUN_TOKEN_RENEW_SECONDS = 5 * 60;
-/** Allowed spread between `iat` and `exp` beyond the lifetime. */
-const LIFETIME_SLACK_SECONDS = 60;
 /**
  * Mints the run token of `lease` over `session`'s active turn. Throws when the session has
  * no active turn: there is no run to name.
@@ -37,7 +32,7 @@ export async function mintRunToken(signer, lease, session) {
         throw new Error(`Session ${lease.sessionId} has no active turn to mint a run token for`);
     const tenantId = signer.config.tenantId;
     const iat = Math.floor(Date.now() / 1000);
-    const exp = iat + RUN_TOKEN_TTL_SECONDS;
+    const exp = iat + hostTuning().keys.runTokenTtlSeconds;
     // Signed by the keys service (F4.2): this process never holds the private key.
     const { token } = await signer.keys.sign({
         typ: RUN_TOKEN_TYP,
@@ -92,7 +87,7 @@ export async function verifyRunToken(store, tenantId, raw, cache = new Map()) {
             issuer: tenantTokenIssuer(tenantId),
             audience: RUN_TOKEN_AUD,
             typ: RUN_TOKEN_TYP,
-            clockTolerance: CLOCK_TOLERANCE_SECONDS,
+            clockTolerance: clockToleranceSeconds(),
             requiredClaims: ["sub", "iat", "exp", "jti"],
         });
         payload = verified.payload;
@@ -112,7 +107,7 @@ export async function verifyRunToken(store, tenantId, raw, cache = new Map()) {
         typeof epc !== "number" ||
         !Number.isSafeInteger(epc) ||
         epc < 1 ||
-        exp - iat > RUN_TOKEN_TTL_SECONDS + LIFETIME_SLACK_SECONDS)
+        exp - iat > hostTuning().keys.runTokenTtlSeconds + hostTuning().keys.tokenLifetimeSlackSeconds)
         return refused("claims");
     return {
         ok: true,

package/dist/tenant/runtime-limits.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The Tenant's Runtime limits (harness boundary S0), stored as Tenant setting `limits.config`
+ * (`GET`/`PUT /v1/tenant/limits`): what one record entry, model call, model file, tool answer,
+ * custom harness state and Harness API chunk may hold. Unset limits take their defaults
+ * (`RUNTIME_LIMIT_DEFAULTS`); none may pass its ceiling (`runtimeLimitIssues`), which the route
+ * checks before it writes.
+ *
+ * Read from Postgres where a limit is checked, never kept: the Record seam, the store's event
+ * write, the gates and the segment's `turn.start` each read it in their own transaction.
+ */
+import { type RuntimeLimits, type TenantLimitsConfig } from "@nylorun/core/contracts";
+export declare const LIMITS_CONFIG_SETTING = "limits.config";
+interface SettingsReader {
+    getSetting(key: string): Promise<string | undefined>;
+}
+interface SettingsWriter extends SettingsReader {
+    putSetting(key: string, value: string): Promise<void>;
+}
+/** The Tenant's stored limits; a stored value that does not parse counts as none set. */
+export declare function readLimitsConfig(t: SettingsReader): Promise<TenantLimitsConfig>;
+/** The Runtime limits in force: the Tenant's, with the default for each it leaves out. */
+export declare function readRuntimeLimits(t: SettingsReader): Promise<RuntimeLimits>;
+export declare function writeLimitsConfig(t: SettingsWriter, config: TenantLimitsConfig): Promise<void>;
+export {};

package/dist/tenant/runtime-limits.js

@@ -0,0 +1,27 @@
+/**
+ * The Tenant's Runtime limits (harness boundary S0), stored as Tenant setting `limits.config`
+ * (`GET`/`PUT /v1/tenant/limits`): what one record entry, model call, model file, tool answer,
+ * custom harness state and Harness API chunk may hold. Unset limits take their defaults
+ * (`RUNTIME_LIMIT_DEFAULTS`); none may pass its ceiling (`runtimeLimitIssues`), which the route
+ * checks before it writes.
+ *
+ * Read from Postgres where a limit is checked, never kept: the Record seam, the store's event
+ * write, the gates and the segment's `turn.start` each read it in their own transaction.
+ */
+import { TenantLimitsConfigSchema, runtimeLimitsOf, } from "@nylorun/core/contracts";
+export const LIMITS_CONFIG_SETTING = "limits.config";
+/** The Tenant's stored limits; a stored value that does not parse counts as none set. */
+export async function readLimitsConfig(t) {
+    const raw = await t.getSetting(LIMITS_CONFIG_SETTING);
+    if (raw === undefined)
+        return {};
+    const parsed = TenantLimitsConfigSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : {};
+}
+/** The Runtime limits in force: the Tenant's, with the default for each it leaves out. */
+export async function readRuntimeLimits(t) {
+    return runtimeLimitsOf((await readLimitsConfig(t)).limits);
+}
+export async function writeLimitsConfig(t, config) {
+    await t.putSetting(LIMITS_CONFIG_SETTING, JSON.stringify(TenantLimitsConfigSchema.parse(config)));
+}

package/dist/tenant/runtime.js

@@ -1,9 +1,9 @@
 import { mkdirSync } from "node:fs";
-import { resolveFlowLimits } from "../core/limits.js";
 import { scriptedModel, toolFixtureModel, } from "../core/provider.js";
 import { tenantModelGate } from "../gates/in-process.js";
 import { createKekFile, readVaultKek } from "../vault/kek.js";
 import { SigningKeys } from "./signing-keys.js";
+import { readRuntimeLimits } from "./runtime-limits.js";
 import { VaultService } from "../vault/service.js";
 import { McpPool } from "../mcp/pool.js";
 import { SandboxManager } from "../sandbox/manager.js";
@@ -20,7 +20,8 @@ import { advance } from "./advance.js";
 import { sweep } from "./sweep.js";
 import { TenantWorkers, WORKER_ID, } from "./worker.js";
 import { authorize } from "./effects.js";
-import { inProcessToolGate } from "../gates/tool-gate.js";
+import { inProcessToolGate, openMcpThrough } from "../gates/tool-gate.js";
+import { providerModelGate } from "../gates/provider-gate.js";
 import { inProcessKeys } from "../keys/keys.js";
 import { tenantApi } from "../api/http/app.js";
 import { createFsBlobStore } from "../blob/index.js";
@@ -31,24 +32,16 @@ import { localWorkspace, remoteWorkspace, withPodWorkspaces, } from "../harness-
 import { hostAuthority } from "../sandbox/join.js";
 import { harnessOfToken } from "./harness-tokens.js";
 import { reconcileSandbox } from "../sandbox/pods/reconcile.js";
-import { sandboxWorkspaceReader } from "../artifacts/workspace.js";
-import { readDefinitionFile } from "./definition-files.js";
-/** Default ownership lease of an advance; the heartbeat renews it every third. */
-const DEFAULT_OWNER_LEASE_MS = 30_000;
+import { hostTuning } from "../tuning.js";
 function validateConfig(config) {
     for (const key of ["leaseMs", "ownerLeaseMs", "sweepIntervalMs"]) {
         const value = config[key];
         if (value !== undefined && (!Number.isFinite(value) || value <= 0))
             throw new Error(`${key} must be finite and positive`);
     }
-    const flowLimits = resolveFlowLimits({
-        flow: config.flow,
-        env: config.flowEnv,
-    });
     if ((config.model.kind === "fixture" || config.model.kind === "scripted") &&
         config.mode === "shared")
         throw new Error("fixture/scripted models require ephemeral or test mode");
-    return flowLimits;
 }
 export class TenantRuntime {
     ctx;
@@ -81,7 +74,7 @@ export class TenantRuntime {
     }
     static async open(config, hooks) {
         const envelope = hooks.envelope;
-        const flowLimits = validateConfig(config);
+        validateConfig(config);
         const paths = config.paths;
         mkdirSync(paths.root, { recursive: true });
         mkdirSync(paths.home, { recursive: true });
@@ -128,6 +121,7 @@ export class TenantRuntime {
                 inProcessToolGate(config.delivery ?? {}, {
                     session: (sessionId) => opened.tx((t) => t.get("sessions", sessionId)),
                     authorize: (sessionId, request) => authorize(ctx, sessionId, request),
+                    limits: () => opened.tx((t) => readRuntimeLimits(t)),
                     logger: config.logger,
                 });
             const signingKeys = new SigningKeys({ tenantId: config.tenantId, kek: ensureKek });
@@ -144,13 +138,9 @@ export class TenantRuntime {
             const preference = seededBackend ?? config.sandbox.backend;
             // With a harness in this process, the Tenant's MCP pool and SandboxManager are its
             // executors; otherwise the harness holds both (F6.2).
-            const mcp = inProcess
-                ? new McpPool({
-                    authorize: (sessionId, request) => authorize(ctx, sessionId, request),
-                    policy: config.delivery ?? {},
-                    ...(toolGate.openMcp ? { openRemote: (server) => toolGate.openMcp(server) } : {}),
-                })
-                : undefined;
+            // The pool opens every server through the Tool Gate: core never authorizes an MCP
+            // connection outside a gate (protocol 15).
+            const mcp = inProcess ? new McpPool({ openRemote: openMcpThrough(toolGate) }) : undefined;
             const ephemeral = config.mode === "ephemeral";
             const manager = inProcess
                 ? new SandboxManager({
@@ -160,12 +150,6 @@ export class TenantRuntime {
                         defaultSandboxBackends({ root: paths.sandboxes }),
                     preference,
                     ephemeral,
-                    definitionFile: async (sha256) => {
-                        const bytes = await readDefinitionFile(blobs, sha256);
-                        if (!bytes)
-                            throw new Error(`The Object store has no bytes for ${sha256}`);
-                        return bytes;
-                    },
                     emit: async (sessionId, turnId, type, payload) => {
                         if (ctx.closed)
                             return;
@@ -201,9 +185,13 @@ export class TenantRuntime {
                     isPod: async (sandboxId) => (await opened.tx((t) => t.environment(sandboxId)))?.kind === "pod",
                 })
                 : workspaces;
-            const useVaultModel = config.model.kind === "vault";
+            // A model that is not the vault's (scripted, the fixture, an embedder's provider) is
+            // served by a gate over it, metered like any (protocol 15): no harness calls a provider.
+            const scripted = config.model.kind !== "vault";
             let modelProvider;
-            if (hooks.modelProvider)
+            if (!scripted)
+                modelProvider = undefined;
+            else if (hooks.modelProvider)
                 modelProvider = hooks.modelProvider;
             else if (config.model.kind === "scripted")
                 modelProvider = scriptedModel(config.model.output);
@@ -214,21 +202,23 @@ export class TenantRuntime {
             const blobs = hooks.blobs ?? createFsBlobStore({ root: paths.blobs });
             // With the gates service the loop never reads a model credential: only a Runtime
             // without one (embedding, the ephemeral Runtime, tests) reads it here.
-            const modelGate = hooks.modelGate ??
-                tenantModelGate({
-                    store: opened,
-                    kek: ensureKek,
-                    root: paths.home,
-                    logger: config.logger,
-                    blobs,
-                    ...(config.modelCall ? { settings: config.modelCall } : {}),
-                });
+            const modelGate = modelProvider
+                ? providerModelGate(modelProvider, { store: opened, logger: config.logger })
+                : (hooks.modelGate ??
+                    tenantModelGate({
+                        store: opened,
+                        kek: ensureKek,
+                        root: paths.home,
+                        logger: config.logger,
+                        blobs,
+                    }));
             const sessionStreams = createSessionStreams();
             const workers = hooks.execution?.workers ?? new TenantWorkers();
             const local = hooks.execution
                 ? undefined
                 : new MemoryExecution({
-                    sweepIntervalMs: config.sweepIntervalMs ?? Math.min(config.leaseMs ?? 30_000, 5000),
+                    sweepIntervalMs: config.sweepIntervalMs ??
+                        Math.min(config.leaseMs ?? Infinity, hostTuning().sweep.intervalMs),
                     // Close's `detach` step waits no longer for running work than for its advances.
                     stopGraceMs: workers.graceMs,
                     onError: (error) => config.logger.error("tenant execution failed", {
@@ -245,9 +235,7 @@ export class TenantRuntime {
                 vault,
                 ...(mcp ? { mcp } : {}),
                 sandbox,
-                flowLimits,
-                modelProvider,
-                useVaultModel,
+                scriptedModel: scripted,
                 modelGate,
                 toolGate,
                 get harness() {
@@ -260,11 +248,10 @@ export class TenantRuntime {
                 signingKeys,
                 keys,
                 blobs,
-                workspaces: sandboxWorkspaceReader(sandbox),
                 ...(hooks.traces ? { traces: hooks.traces } : {}),
                 ...(hooks.runGrants ? { runGrants: hooks.runGrants } : {}),
                 workerId: hooks.workerId ?? WORKER_ID,
-                ownerLeaseMs: config.ownerLeaseMs ?? DEFAULT_OWNER_LEASE_MS,
+                ownerLeaseMs: config.ownerLeaseMs ?? hostTuning().tenant.ownerLeaseMs,
                 wake: async (sessionId, wake) => {
                     if (ctx.closing || ctx.closed)
                         return false;
@@ -372,7 +359,7 @@ export class TenantRuntime {
             harness: harnessStatusOf(this.ctx),
         };
     }
-    drain(activeWork, timeoutMs = 30_000) {
+    drain(activeWork, timeoutMs = hostTuning().tenant.drainTimeoutMs) {
         return drain(this.ctx, activeWork, timeoutMs);
     }
     /**

package/dist/tenant/session-streams.js

@@ -21,6 +21,7 @@
 import { historyCursor, historyResume } from "../reads/cursor.js";
 import { decodeCursor, encodeCursor } from "../record/index.js";
 import { sleep } from "../retry.js";
+import { hostTuning } from "../tuning.js";
 import { basinOf } from "../streams/basin.js";
 import { sessionStream, } from "../streams/types.js";
 import { fail } from "./http.js";
@@ -33,8 +34,6 @@ export function streamHolderOf(scope) {
 export function createSessionStreams() {
     return { wiring: undefined, generation: 0, sessions: new Map() };
 }
-const RETRY_MIN_MS = 100;
-const RETRY_MAX_MS = 2000;
 function frame(event) {
     return `id: ${event.cursor}\nevent: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`;
 }
@@ -66,7 +65,7 @@ export function openSse(request, response, onClose) {
         "x-accel-buffering": "no",
     });
     response.flushHeaders();
-    const timer = setInterval(() => send(response, ": keepalive\n\n"), 15000);
+    const timer = setInterval(() => send(response, ": keepalive\n\n"), hostTuning().api.eventStreamKeepaliveMs);
     timer.unref();
     request.on("close", () => {
         clearInterval(timer);
@@ -313,7 +312,9 @@ function runFeed(ctx, feed) {
     const read = feed.read;
     const signal = read.signal;
     void (async () => {
-        let delay = RETRY_MIN_MS;
+        // A failed read is retried after `streams.retry` (Host tuning), doubling.
+        const { minMs: retryMinMs, maxMs: retryMaxMs } = hostTuning().streams.retry;
+        let delay = retryMinMs;
         while (!signal.aborted) {
             const streams = ctx.sessionStreams.wiring?.streams;
             if (!streams)
@@ -326,7 +327,7 @@ function runFeed(ctx, feed) {
                     if (record.seq < feed.next)
                         continue;
                     feed.next = record.seq + 1;
-                    delay = RETRY_MIN_MS;
+                    delay = retryMinMs;
                     for (const observer of feed.observers)
                         deliver(observer, record);
                 }
@@ -345,7 +346,7 @@ function runFeed(ctx, feed) {
             if (!(await stillCurrent(ctx, feed)))
                 break;
             await sleep(delay, signal);
-            delay = Math.min(delay * 2, RETRY_MAX_MS);
+            delay = Math.min(delay * 2, retryMaxMs);
         }
         if (signal.aborted || feed.read !== read)
             return;

package/dist/tenant/session.d.ts

@@ -9,7 +9,7 @@
 import type { AgentManifest } from "@nylorun/core/define";
 import type { TurnManifestStore } from "../core/turn-manifest.js";
 import type { Session } from "./context.js";
-export { manifestFor, sessionToolsOf } from "../mcp/snapshot.js";
+export { manifestFor } from "../mcp/snapshot.js";
 /** Turn-manifest store backed by the session's `variants` map (no schema change). */
 export declare function variantStore(session: Session): TurnManifestStore;
 /** Manifest this turn's checkpoint is pinned to (session pin or a stored variant). */

package/dist/tenant/session.js

@@ -1,4 +1,4 @@
-export { manifestFor, sessionToolsOf } from "../mcp/snapshot.js";
+export { manifestFor } from "../mcp/snapshot.js";
 /** Turn-manifest store backed by the session's `variants` map (no schema change). */
 export function variantStore(session) {
     return {