@nylorun/runtime 0.10.0-beta → 0.11.0-beta

package/dist/tenant/runtime.d.ts

@@ -1,80 +1,81 @@
-import { type ServerResponse, type IncomingMessage } from "node:http";
-import { type ModelProvider } from "../core/provider.js";
-import type { TenantConfig, TenantHandle, TenantSummary } from "./types.js";
+/**
+ * Composition root of an open Tenant: validates the config, opens the Session Store and the
+ * vault key, builds the services and the `TenantContext`, wires the seams, registers the
+ * Tenant's Worker handlers and arms its sweep, and implements `TenantHandle` (handle,
+ * summary, drain, close) by delegating to the Tenant modules.
+ *
+ * Seams wired here: `wireStreams()` connects the store's commits to Durable Streams (the
+ * relay, and the history, SSE, work and control readers); `wake` goes to the
+ * `DurableExecution`, whose handlers (`worker.ts`) call `advance` and `sweep`; `abortLocal`
+ * aborts an advance running on this process. The sweep also drains the outbox.
+ *
+ * Execution: the Host passes one `TenantExecution` for every Tenant it opens
+ * (`TenantOpenHooks.execution`); without one, the Tenant runs its own in-process
+ * `MemoryExecution`. No lock file: several processes may open a Tenant, and ownership of each
+ * session (§10.6) keeps its advances apart.
+ */
+import type { ServerResponse, IncomingMessage } from "node:http";
 import type { TenantEnvelope } from "@nylorun/core/contracts";
+import { type ModelProvider } from "../core/provider.js";
 import { type AuthorizeResult } from "../vault/service.js";
+import type { DurableStreams } from "../streams/types.js";
+import type { OpenedTenant, TenantConfig, TenantHandle, TenantSummary } from "./types.js";
+import { type StreamsStatus } from "./streams.js";
+import { type TenantExecution, type TenantWorker } from "./worker.js";
 /** TENANTS-CCR: test/injection hooks until TenantConfig gains them. */
 export type TenantOpenHooks = {
     modelProvider?: ModelProvider;
     vaultKek?: Buffer | string | null;
     /** When true, create the KEK file on first vault write (tests / new Tenants). */
     createKekIfMissing?: boolean;
-};
+    /**
+     * The Host's Durable Session Execution and the registry its handlers dispatch through.
+     * The Host starts it; the Tenant registers its worker and arms its sweep. Without one,
+     * the Tenant starts and stops its own in-process `MemoryExecution`.
+     */
+    execution?: TenantExecution;
+    /** The Worker id written as session owner. Defaults to this process's `WORKER_ID`. */
+    workerId?: string;
+    /**
+     * Durable Streams for this Tenant, owned by the caller (the Host's S2 streams). Without
+     * them the Tenant creates its own in-process `MemoryStreams`, whose history does not
+     * survive a restart (tests, and a Host without S2).
+     */
+    streams?: DurableStreams;
+} & OpenedTenant;
 export declare class TenantRuntime implements TenantHandle {
-    private readonly config;
-    private readonly store;
-    private readonly vault;
-    private kek;
-    private readonly kekPath;
-    private readonly running;
-    private readonly pending;
-    private readonly observers;
-    private readonly executorStreams;
-    private readonly registry;
-    private readonly mcp;
-    private readonly sandbox;
-    private closing;
-    private closed;
-    private readonly lockPath?;
-    private readonly timer;
-    private readonly modelProvider;
-    private readonly useVaultModel;
-    private readonly createKekIfMissing;
-    private readonly flowLimits;
+    private readonly ctx;
     readonly envelope: TenantEnvelope;
+    /** This Tenant's Worker handlers, as registered with the execution. */
+    readonly worker: TenantWorker;
+    private readonly detach;
+    /** How long close waits for running advances: the execution's advance grace period. */
+    private readonly closeGraceMs;
     private constructor();
-    static open(config: TenantConfig, hooks?: TenantOpenHooks): Promise<TenantRuntime>;
-    private session;
-    private publish;
-    private send;
-    private notify;
-    /**
-     * Manifest v4 replaced beforeModelCall/afterModelCall with scoped hooks. Turns started under
-     * an older manifest cannot continue, and their hook actions no longer parse, so end them.
-     */
-    private retireLegacyHooks;
-    private expireClaims;
-    private schedule;
-    private execute;
-    private invokeModel;
-    private resolveEffect;
-    /** Journal and dispatch a new flow effect (agent / tool node / fn / verify). */
-    private resolveNewFlowEffect;
-    private scope;
-    private scoped;
-    private requireApplication;
-    private sandboxRouteDeps;
-    private body;
-    private command;
-    private sse;
-    handle(request: IncomingMessage, response: ServerResponse, _url?: URL): Promise<void>;
-    private view;
-    private prepareMcp;
-    private callMcpTool;
-    private callSandboxTool;
+    static open(config: TenantConfig, hooks: TenantOpenHooks): Promise<TenantRuntime>;
+    handle(request: IncomingMessage, response: ServerResponse, url?: URL): Promise<void>;
     authorize(sessionId: string, request: {
         url: string;
         serverName?: string;
     }): Promise<AuthorizeResult>;
-    private ensureKek;
-    private dispatchTenant;
-    private dispatchVault;
-    summary(): TenantSummary;
+    summary(): Promise<TenantSummary>;
     drain(activeWork: "drain" | "cancel", timeoutMs?: number): Promise<void>;
+    /**
+     * Aborts the advance of `sessionId` if it runs on this process. Cancel calls it after
+     * committing `cancelled`; the control stream calls it for cancels made elsewhere.
+     */
+    abortLocal(sessionId: string): void;
+    /**
+     * The Durable Streams seam's status for Tenant status and readiness: S2 reachability, the
+     * basin, outbox depth and relay lag (`streamsStatus` in `tenant/streams.ts`).
+     */
+    streamsStatus(): Promise<StreamsStatus>;
+    /** Adds a callback to the Tenant sweep. Returns a function that removes it. */
+    onSweep(hook: () => Promise<void>): () => void;
     close(): Promise<void>;
 }
 /**
  * Open a Tenant Runtime from an explicit `TenantConfig`. No listen() (A1).
  * Implements `OpenTenantRuntime`.
  */
-export declare function openTenantRuntime(config: TenantConfig, hooks?: TenantOpenHooks): Promise<TenantHandle>;
+export declare function openTenantRuntime(config: TenantConfig, hooks: TenantOpenHooks): Promise<TenantHandle>;