@nylorun/runtime 0.10.0-beta → 0.12.0-beta

package/dist/tenant/routes.js

@@ -0,0 +1,151 @@
+import { PutAgentRequestSchema, PutSessionRequestSchema, RegisterExecutorsRequestSchema, SessionCommandSchema, } from "@nylorun/core/contracts";
+import { VaultError } from "../vault/error.js";
+import { SandboxRouteError, handleSessionSandboxTool, } from "../core/sandbox-routes.js";
+import { loadSession, sessionOf } from "./context.js";
+import { HttpError, OpaqueAuthError, fail, readBody, requestAborted, } from "./http.js";
+import { authenticate, authorize, ownerOf, requireApplication, requirePrincipal, } from "./auth.js";
+import { command } from "./commands.js";
+import { actionSandboxTool, deleteExecutor, listExecutors, listPendingActions, registerExecutors, sandboxRouteDeps, updateAction, } from "./actions.js";
+import { listDefinitions, listSessions, putDefinition, putSession, sessionView, } from "./sessions.js";
+import { readHistory, requestCursor, streamExecutorWork, streamSessionEvents, } from "./live.js";
+import { dispatchTenant, dispatchVault } from "./routes-tenant.js";
+export async function handle(ctx, request, response, _url) {
+    const json = (value, status = 200) => {
+        const payload = JSON.stringify(value);
+        response.writeHead(status, {
+            "content-type": "application/json",
+            "content-length": Buffer.byteLength(payload),
+        });
+        response.end(payload);
+    };
+    try {
+        const url = _url ?? new URL(request.url ?? "/", "http://runtime");
+        const path = url.pathname
+            .split("/")
+            .filter(Boolean)
+            .map(decodeURIComponent);
+        const method = request.method;
+        const scope = await authenticate(ctx, request);
+        if (path[0] !== "v1")
+            fail(404, "Route not found");
+        authorize(scope, method, path);
+        // Set when the request acts for a subject: only the subject's own sessions are reachable.
+        const owner = ownerOf(scope);
+        if (path[1] === "executors" && path[2] === "connect" && method === "GET") {
+            if (scope.kind !== "executor")
+                return fail(403, "Executor credential required");
+            streamExecutorWork(ctx.live, request, response, scope.executor.tokenHash);
+            return;
+        }
+        if (path[1] === "actions") {
+            if (scope.kind !== "executor")
+                return fail(403, "Executor credential required");
+            if (path.length === 2 && method === "GET")
+                return json(await listPendingActions(ctx, scope.executor));
+            const actionId = path[2];
+            if (!actionId)
+                fail(404, "Action not found");
+            if (method === "POST" &&
+                path[3] === "sandbox" &&
+                path[4] &&
+                path.length === 5)
+                return json(await actionSandboxTool(ctx, scope, actionId, path[4], request));
+            const body = await readBody(request);
+            return json(await updateAction(ctx, scope, actionId, method, path[3], body));
+        }
+        if (path[1] === "sessions" &&
+            path[2] &&
+            path[3] === "commands" &&
+            method === "POST")
+            return json(await command(ctx, path[2], SessionCommandSchema.parse(await readBody(request)), scope));
+        if (path[1] === "vaults")
+            return json(await dispatchVault(ctx, scope, method, path, url, request));
+        if (path[1] === "tenant")
+            return json(await dispatchTenant(ctx, scope, method, path, request));
+        const principalId = requirePrincipal(scope);
+        if (path[1] === "executors" && path.length === 2 && method === "GET")
+            return json(listExecutors(ctx));
+        // The length guard matters: the connect branch above only matches GET, so without it a
+        // PUT to /v1/executors/connect would register an agent literally named "connect".
+        if (path[1] === "executors" && path.length === 2 && method === "PUT")
+            return json(await registerExecutors(ctx, principalId, RegisterExecutorsRequestSchema.parse(await readBody(request))));
+        if (path[1] === "executors" &&
+            path.length === 3 &&
+            path[2] &&
+            method === "DELETE")
+            return json(await deleteExecutor(ctx, path[2]));
+        if (path[1] === "agents" && path.length === 2 && method === "GET")
+            return json(await listDefinitions(ctx));
+        if (path[1] === "sessions" && path.length === 2 && method === "GET")
+            return json(await listSessions(ctx, url.searchParams.get("agentId"), owner));
+        if (path[1] === "agents" &&
+            path[2] &&
+            path.length === 3 &&
+            method === "PUT")
+            return json(await putDefinition(ctx, path[2], PutAgentRequestSchema.parse(await readBody(request))));
+        if (path[1] === "sessions" && path[2]) {
+            const id = path[2];
+            if (method === "PUT" && path.length === 3) {
+                const body = PutSessionRequestSchema.parse(await readBody(request));
+                const session = await putSession(ctx, id, body, owner);
+                return json(await ctx.store.tx((t) => sessionView(t, session)));
+            }
+            if (method === "GET" && path.length === 3)
+                return json(await ctx.store.tx(async (t) => sessionView(t, await sessionOf(t, id, owner))));
+            // Every other session route needs the session to exist.
+            await loadSession(ctx, id, owner);
+            const cursor = requestCursor(request, url);
+            if (method === "GET" && path[3] === "items")
+                return json(await readHistory(ctx, id, cursor, url.searchParams.get("agent") ?? undefined));
+            if (method === "GET" && path[3] === "events") {
+                await streamSessionEvents(ctx, request, response, id, cursor);
+                return;
+            }
+            if (method === "POST" &&
+                path[3] === "sandbox" &&
+                path[4] &&
+                path.length === 5) {
+                requireApplication(scope);
+                try {
+                    const outcome = await handleSessionSandboxTool(sandboxRouteDeps(ctx), id, path[4], await readBody(request), requestAborted(request));
+                    return json(outcome);
+                }
+                catch (error) {
+                    if (error instanceof SandboxRouteError)
+                        fail(error.status, error.message);
+                    throw error;
+                }
+            }
+        }
+        fail(404, "Route not found");
+    }
+    catch (error) {
+        if (response.headersSent) {
+            response.end();
+            return;
+        }
+        if (error instanceof OpaqueAuthError) {
+            json(error.body, error.status);
+            return;
+        }
+        const status = error instanceof HttpError ||
+            error instanceof VaultError ||
+            error instanceof SandboxRouteError
+            ? error.status
+            : error?.name === "ZodError" ||
+                error?.message === "Invalid cursor"
+                ? 400
+                : 500;
+        const rejection = error instanceof HttpError ? error.rejection : {};
+        json({
+            status: "rejected",
+            code: status === 500
+                ? "internal_error"
+                : rejection.code ?? "request_rejected",
+            message: status === 500 ? "Runtime request failed" : error.message,
+            ...(rejection.details === undefined
+                ? {}
+                : { details: rejection.details }),
+        }, status);
+    }
+}

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>;