@nylorun/runtime 0.26.0-beta → 0.28.0-beta

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.d.ts

@@ -81,7 +81,7 @@ export type TenantOpenHooks = {
     harnessTap?: MemoryPortsOptions["tap"];
     /**
      * Sandbox pods (F7.2): the sandboxes service (`NYLORUN_SANDBOXES_URL`) and the Runtime image
-     * pods copy the engine from. Without it, kind `pod` is `environment_unavailable`.
+     * pods copy the engine from. Without it, kind `pod` is `agent_unavailable`.
      */
     pods?: TenantPods;
     /** How the trace route makes spans (R7.5): the Host's `OTEL_*` resource and content opt-ins. */

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,17 @@ 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 { fireTimer } from "./triggers.js";
+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 +75,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 +122,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 +139,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 +151,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 +186,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 +203,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 +236,7 @@ export class TenantRuntime {
                 vault,
                 ...(mcp ? { mcp } : {}),
                 sandbox,
-                flowLimits,
-                modelProvider,
-                useVaultModel,
+                scriptedModel: scripted,
                 modelGate,
                 toolGate,
                 get harness() {
@@ -260,11 +249,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;
@@ -279,6 +267,12 @@ export class TenantRuntime {
                     await execution.sandbox?.(config.tenantId, sandboxId, signal);
                     return true;
                 },
+                timer: async (key, at) => {
+                    if (ctx.closing || ctx.closed)
+                        return false;
+                    await execution.timer(config.tenantId, key, at);
+                    return true;
+                },
                 send: (request) => request.kind === "wake"
                     ? ctx.wake(request.sessionId, request.wake)
                     : ctx.sandboxSignal(request.sandboxId, request.signal),
@@ -335,6 +329,7 @@ export class TenantRuntime {
                 advance: (sessionId, signal) => advance(ctx, sessionId, signal),
                 sweep: () => sweep(ctx),
                 sandbox: (sandboxId, trigger) => reconcileSandbox(ctx, sandboxId, trigger),
+                fire: (key) => fireTimer(ctx, key),
             };
             const unregister = workers.register(config.tenantId, worker);
             detach = async () => {
@@ -372,7 +367,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 {

package/dist/tenant/sessions.d.ts

@@ -1,42 +1,16 @@
 /**
- * Session and definition resources: `PUT/GET /v1/agents`, `PUT /v1/sessions/:id` (create, or
- * find an identical one), the session list and the session view. Reads use the store's typed
- * queries; `PUT /v1/sessions/:id` runs in one transaction with the Environment's checks.
+ * Session resources: `PUT /v1/sessions/:id` (create, or find an identical one), the session list
+ * and the session view. A session runs on one Agent (protocol 16) and pins the manifest version
+ * the Agent runs when it opens; each turn takes the version the Agent runs then
+ * (`agent-versions.ts`). Reads use the store's typed queries; `PUT /v1/sessions/:id` runs in
+ * one transaction with the Agent's checks.
  */
-import { type PutAgentRequest, type PutSessionRequest } from "@nylorun/core/contracts";
+import { type PutSessionRequest } from "@nylorun/core/contracts";
 import type { Tx } from "../store/types.js";
 import { type Session, type SessionAccess, type TenantContext } from "./context.js";
-export declare function listDefinitions(ctx: TenantContext): Promise<{
-    agents: {
-        agentId: any;
-        manifest: any;
-        manifestHash: string;
-        implementationVersion: string;
-    }[];
-}>;
-/**
- * The agents a token caller may see: id, name and description only, never
- * instructions, tools or MCP servers, and only the agents allowed.
- */
-export declare function listAgentsPublic(ctx: TenantContext, agents: ReadonlySet<string> | "*"): Promise<{
-    agents: {
-        agentId: string;
-        name?: any;
-        description?: any;
-    }[];
-}>;
-export declare function putDefinition(ctx: TenantContext, agentId: string, body: PutAgentRequest, options?: {
-    /** Run every check and save nothing (`?dryRun=true`, protocol 14). */
-    dryRun?: boolean;
-}): Promise<{
-    agentId: string;
-    manifestHash: string;
-    implementationVersion: string;
-    dryRun?: boolean | undefined;
-}>;
 /**
- * `access`, when the request acts for a person, limits the list to that person's sessions of
- * the agents they may use.
+ * `access`, when the request acts for a person, limits the list to that person's sessions on
+ * the Agents they may use.
  */
 export declare function listSessions(ctx: TenantContext, agentId: string | null, access?: SessionAccess): Promise<{
     sessions: {
@@ -48,26 +22,35 @@ export declare function listSessions(ctx: TenantContext, agentId: string | null,
     }[];
 }>;
 /**
- * Create a session from its definition, or find an identical one. `access`, when the request
- * acts for a subject, must be the session's owner: another owner's session id is the 404 of a
- * missing one (not the 409 of a mismatch), and so is an Environment whose owner guard names
- * another owner.
+ * Create a session on an Agent, or find an identical one. `access`, when the request acts for a
+ * subject, must be the session's owner: another owner's session id is the 404 of a missing one
+ * (not the 409 of a mismatch), and so is an Agent whose owner guard names another owner.
  *
- * The session's Environment is fixed for its life: its sandbox (kinds `virtual` and `pod`) is
- * the session's, with the spec of the Environment's applied recipe pinned now, and its vault
- * holds the session's credentials. Without one the session has no sandbox and no credentials.
+ * The session runs on its Agent for its life: the Agent's sandbox (kinds `virtual` and `pod`) is
+ * the session's, with the spec of what the Agent runs pinned now, and the Agent's vault holds the
+ * session's credentials. It pins the manifest version the Agent runs (`definition`), as the loop
+ * manifest that version's harness section makes, and the harness that section names (`pinOf`);
+ * a turn's first segment pins the version the Agent runs then (`repinTurn`).
  */
 export declare function putSession(ctx: TenantContext, id: string, body: PutSessionRequest, access?: SessionAccess, options?: {
     /**
      * Create the session if it is missing and otherwise leave it as it is (an AG-UI thread's
-     * session): an existing one must have the same owner and agent, or it is a 404.
+     * session): an existing one must have the same owner and Agent, or it is a 404.
      */
     createOnly?: boolean;
     /**
-     * The Environments the caller reaches (a token caller's grants, `environmentGrantsOf`);
-     * undefined reaches every one. `environment` must name one of them.
+     * The Agents the caller reaches (a token caller's grants, `agentGrantsOf`); undefined
+     * reaches every one. `agent` must name one of them.
      */
-    environmentGrants?: readonly string[];
+    agentGrants?: readonly string[];
+}): Promise<Session>;
+/**
+ * `putSession`'s work in transaction `t`: also how a trigger's first run opens the session it
+ * names (track T4), in the run's transaction.
+ */
+export declare function openSessionIn(ctx: TenantContext, t: Tx, id: string, body: PutSessionRequest, access?: SessionAccess, options?: {
+    createOnly?: boolean;
+    agentGrants?: readonly string[];
 }): Promise<Session>;
 /** The session resource returned by `GET`/`PUT /v1/sessions/:id`. */
 export declare function sessionView(t: Tx, s: Session): Promise<unknown>;