@nylorun/runtime 0.1.1-beta → 0.2.0-beta

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.2.0-beta
+
+### Minor Changes
+
+- 4badb5b: Move model execution to session startup, provide Runtime as a mountable Hono router, and generate Hono-first projects with supervised application and Studio development. Studio now resolves root-relative Runtime endpoints correctly for custom mount paths.
+
+## 0.1.2-beta
+
+### Patch Changes
+
+- d27242c: Show stopped guardrail and failed model requests as errors in Studio. Runtime now emits a terminal AG-UI error instead of marking failed requests successful, and Studio displays the reported message. The guardrails example also checks text content parts sent by Studio, including mixed media input, before invoking the model.
+- d27242c: Preserve opaque provider continuation metadata through assistant conversation history. Gemini tool calls now retain thought signatures when sending tool results back to the model, including signed empty text and reasoning blocks. Only the originating provider and model receive their signatures.
+
 ## 0.1.1-beta
 
 ### Patch Changes

package/README.md

@@ -1,44 +1,34 @@
 # @nylorun/runtime
 
-Portable agent hosting, pi-ai model providers, and the `nylorun` CLI. Runtime has no Harness dependency. Studio is loaded from the application only when requested.
+Portable agent lifecycle, a mountable Hono protocol router, pi-ai model providers, and the `nylorun` CLI. Runtime has no Harness dependency.
 
 ```ts
-import { defineRuntime } from "@nylorun/runtime";
-import { agents } from "./agent/registry.js";
-export default defineRuntime({ agents });
-```
-
-Applications install their engine and Runtime directly, with Studio as a development dependency. An agent may bind Runtime's `piModel()` through its engine's model interface. `piModel({ media })` uses the explicitly supplied media adapter to resolve opaque image references. It never fetches arbitrary media URLs.
-
-## Commands
-
-Run from the directory containing `nylorun.config.ts`:
-
-- `nylorun dev [--no-studio] [--no-open] [--port 4111] [--host 127.0.0.1] [--allowed-hosts a,b]`
-- `nylorun studio --agent-url http://127.0.0.1:4111 [--port 3000] [--no-open]`
-- `nylorun configure`
-- `nylorun inspect`
-- `nylorun build`
-- `nylorun start [--port 4111] [--host 127.0.0.1] [--allowed-hosts a,b]`
+import { Runtime, serveAgents } from "@nylorun/runtime";
 
-`PORT`, `HOST` and `ALLOWED_HOSTS` environment variables supply the same settings. By default the host binds to loopback and answers only to `localhost`, `127.0.0.1` and `[::1]` on the chosen port, so changing `--port` needs no other setup and Studio connects to whatever address is printed. To publish, bind with `--host 0.0.0.0` (every Host header is then served) or keep the loopback bind behind a reverse proxy and list the public names in `--allowed-hosts`; `*` accepts any Host header. Development retains existing sessions across reloads; new sessions use the latest definitions. A failed reload leaves the previous runtime active. Studio attachment does not start or own the remote runtime.
-
-Build emits `dist/nylorun.config.js` and application assets under `dist/agent/`. Deploy `dist/`, your package manifest and lockfile, installed production dependencies, and private configuration. Production startup does not import Studio. Use `projectAsset("agent/skills/catalog")` for assets that must resolve in source and built deployments.
+const runtime = new Runtime();
+app.route("/agents", serveAgents({ agents, runtime }));
+```
 
-## Configuration and adapters
+`Runtime` is the primitive stack: model adapter (`piModel` by default), observer (`jsonlObserver` per session by default), and durability (`localJsonl` by default). Session files live together under `.data/sessions/<agent>/<session>/` as `events.jsonl` and `observe.jsonl`. Agents bind only when served.
 
-The default host uses in-memory history and text input. Add `persistence: localJsonl()` and `media: localMedia()` explicitly for local storage under `.data/sessions` and `.data/media`. Share the same media adapter with `piModel({ media })` and domain tools. Persistence preserves history across restarts; archived sessions cannot resume execution and require a new conversation.
+The application owns Hono composition, authentication, CORS, logging, process lifecycle, and deployment. Runtime owns agent sessions, durability, media, and AG-UI/session protocol routes. Graceful shutdown is optional: if the application installs signal handlers and wants to drain live sessions, flush pending journal writes, and run optional agent cleanup, it should await `runtime.close()`. An application that does not install handlers exits normally on its host's shutdown policy; `runtime.close()` does not run on crash, OOM, or SIGKILL.
 
-The creator runs `nylorun configure` after installation and before development unless `--skip-config` is passed. Standalone configuration also supports scripted input. EOF fails setup; Ctrl-C/SIGTERM cancels prompts and authentication with exit status 130/143. A cancelled setup does not proceed to development.
+Runtime publishes root-relative discovery and endpoint URLs. Mounting below root requires the matching public prefix, so Studio and other clients can resolve those URLs against any configured agent-server URL:
 
-`nylorun configure` stores provider credentials in `.env/auth.json` and selection in `config/model.json`. Agents can be imported before setup; provider authentication is resolved when the model is called. Optional integration environment variables are loaded from `.env/integrations.env`. Existing flat `.env` files must be relocated before creating the vault; never commit credentials. Image-editing and external coding integrations may use their own credentials independently.
+```ts
+app.route(
+  "/api/agents",
+  serveAgents({ agents, runtime, basePath: "/api/agents" })
+);
+```
 
-## Portable contracts
+`getActor(context)` supplies an optional actor id and session context for newly created sessions. `getRequestMetadata(context)` supplies JSON-safe metadata for inbound messages. Application middleware remains responsible for authorizing every agent route.
 
-`RuntimeAgent` supplies `id`, `name`, a matching `manifest`, and `run({ id })`. Its session supplies `input`, `stream`, `observe`, and `stop`. An input handle's `completed` promise settles after that input's execution or pause, with ordered lifecycle events and a status. Runtime uses completion events for terminal output and interactions, and observation events for optional diagnostics. Engines need not emit model/tool diagnostics or middleware metadata. Runtime records input before execution and flushes persistence before returning an HTTP reply. `stop()` releases session resources; optional agent `close()` runs after session shutdown. Shutdown is idempotent.
+## Commands
 
-`RuntimeModelAdapter` accepts ordered prompt items, tools, model controls, opaque media references, and an abort signal, returning portable text/reasoning/tool-call outputs. It has no engine import. Integration tests in the creator check assignment in both directions with Harness without casts. Runtime's own tests use an independent engine.
+- `nylorun configure`
+- `nylorun studio --agent-url http://localhost:3000/agents [--port 4161] [--no-open]`
 
-Discovery and manifest documents use protocol version 2. The agent's manifest is under `manifest`; no engine-branded envelope is required. Existing agent-scoped HTTP endpoint paths remain unchanged. Studio also understands legacy version-1 `harness.manifest` documents.
+Studio attaches to an application you run. Use your own TypeScript/build tooling and a Node adapter such as `@hono/node-server` when applicable. `projectAsset("agents/skills/catalog")` resolves bundled application assets from source or a compiled `dist/` deployment.
 
-Repository development: [contributing](../CONTRIBUTING.md). Package publication: [releasing](../RELEASING.md).
+Provider credentials are stored in `.env/auth.json`, and selection in `config/model.json`. `nylorun configure` can run before an agent graph is importable.

package/dist/adapters/journal.d.ts

@@ -12,24 +12,24 @@ export type SessionSummary = Readonly<{
     startedAt: number;
     endedAt?: number;
 }>;
-/** Explicit local-only JSONL persistence. Raw provider payloads never enter this service. */
+/** Explicit local-only JSONL durability. Raw provider payloads never enter this service. */
 export declare class JsonlJournal {
     private readonly root;
     private readonly secrets;
     constructor(root: string, secrets: readonly string[]);
-    append(agent: string, event: CanonicalEvent): Promise<void>;
-    events(agent: string, session: string): Promise<readonly CanonicalEvent[]>;
-    list(agent: string): Promise<readonly SessionSummary[]>;
+    append(agentId: string, event: CanonicalEvent): Promise<void>;
+    events(agentId: string, sessionId: string): Promise<readonly CanonicalEvent[]>;
+    list(agentId: string): Promise<readonly SessionSummary[]>;
     private file;
 }
 export declare function scrub(value: unknown, secrets: readonly string[]): unknown;
-export interface RuntimePersistence {
-    append(agent: string, event: CanonicalEvent): Promise<void>;
-    events(agent: string, session: string): Promise<readonly CanonicalEvent[]>;
-    list(agent: string): Promise<readonly SessionSummary[]>;
+export interface RuntimeDurability {
+    append(agentId: string, event: CanonicalEvent): Promise<void>;
+    events(agentId: string, sessionId: string): Promise<readonly CanonicalEvent[]>;
+    list(agentId: string): Promise<readonly SessionSummary[]>;
 }
 export declare function localJsonl(options?: {
     root?: string;
     secrets?: readonly string[];
-}): RuntimePersistence;
-export declare function memoryHistory(): RuntimePersistence;
+}): RuntimeDurability;
+export declare function memoryHistory(): RuntimeDurability;

package/dist/adapters/journal.js

@@ -1,6 +1,6 @@
 import { appendFile, mkdir, readFile, readdir } from "node:fs/promises";
 import { join } from "node:path";
-/** Explicit local-only JSONL persistence. Raw provider payloads never enter this service. */
+/** Explicit local-only JSONL durability. Raw provider payloads never enter this service. */
 export class JsonlJournal {
     root;
     secrets;
@@ -8,14 +8,14 @@ export class JsonlJournal {
         this.root = root;
         this.secrets = secrets;
     }
-    async append(agent, event) {
-        const file = this.file(agent, event.session);
-        await mkdir(join(this.root, agent, event.session), { recursive: true });
+    async append(agentId, event) {
+        const file = this.file(agentId, event.session);
+        await mkdir(join(this.root, agentId, event.session), { recursive: true });
         await appendFile(file, `${JSON.stringify(scrub(event, this.secrets))}\n`);
     }
-    async events(agent, session) {
+    async events(agentId, sessionId) {
         try {
-            return Object.freeze((await readFile(this.file(agent, session), "utf8"))
+            return Object.freeze((await readFile(this.file(agentId, sessionId), "utf8"))
                 .split("\n")
                 .filter(Boolean)
                 .flatMap((line) => {
@@ -31,15 +31,15 @@ export class JsonlJournal {
             return Object.freeze([]);
         }
     }
-    async list(agent) {
+    async list(agentId) {
         try {
-            const ids = await readdir(join(this.root, agent));
-            const summaries = await Promise.all(ids.map(async (session) => {
-                const events = await this.events(agent, session);
+            const ids = await readdir(join(this.root, agentId));
+            const summaries = await Promise.all(ids.map(async (sessionId) => {
+                const events = await this.events(agentId, sessionId);
                 const final = events.findLast((event) => event.type === "final");
                 const title = sessionTitle(events);
                 return {
-                    session,
+                    session: sessionId,
                     ...(title === undefined ? {} : { title }),
                     status: sessionStatus(events),
                     startedAt: events[0] ? Date.parse(events[0].ts) : 0,
@@ -52,8 +52,8 @@ export class JsonlJournal {
             return Object.freeze([]);
         }
     }
-    file(agent, session) {
-        return join(this.root, safe(agent), safe(session), "events.jsonl");
+    file(agentId, sessionId) {
+        return join(this.root, safe(agentId), safe(sessionId), "events.jsonl");
     }
 }
 function sessionTitle(events) {
@@ -106,18 +106,18 @@ export function localJsonl(options = {}) {
 export function memoryHistory() {
     const agents = new Map();
     return {
-        async append(agent, event) {
-            const sessions = agents.get(agent) ?? new Map();
-            agents.set(agent, sessions);
+        async append(agentId, event) {
+            const sessions = agents.get(agentId) ?? new Map();
+            agents.set(agentId, sessions);
             const events = sessions.get(event.session) ?? [];
             events.push(event);
             sessions.set(event.session, events);
         },
-        async events(agent, session) {
-            return agents.get(agent)?.get(session) ?? [];
+        async events(agentId, sessionId) {
+            return agents.get(agentId)?.get(sessionId) ?? [];
         },
-        async list(agent) {
-            return [...(agents.get(agent) ?? [])]
+        async list(agentId) {
+            return [...(agents.get(agentId) ?? [])]
                 .map(([session, events]) => ({
                 session,
                 title: sessionTitle(events),

package/dist/adapters/observe.d.ts

@@ -0,0 +1,10 @@
+/** Local JSONL observer. Writes raw engine events beside session durability files. */
+export declare function jsonlObserver(options: {
+    readonly agentId: string;
+    readonly sessionId: string;
+    readonly root?: string;
+}): {
+    (event: {
+        readonly type: string;
+    }): void;
+};

package/dist/adapters/observe.js

@@ -0,0 +1,23 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { scrub } from "./journal.js";
+import { projectSecrets } from "../model/settings.js";
+/** Local JSONL observer. Writes raw engine events beside session durability files. */
+export function jsonlObserver(options) {
+    const root = options.root ?? join(process.cwd(), ".data", "sessions");
+    const directory = join(root, safe(options.agentId), safe(options.sessionId));
+    const file = join(directory, "observe.jsonl");
+    const secrets = projectSecrets();
+    return (event) => {
+        const line = `${JSON.stringify(scrub(event, secrets))}\n`;
+        void mkdir(directory, { recursive: true })
+            .then(() => appendFile(file, line))
+            .catch(() => { });
+    };
+}
+function safe(value) {
+    if (value === "." || value === ".." || !/^[a-zA-Z0-9._-]+$/u.test(value)) {
+        throw new Error("Refusing a path-shaped ID.");
+    }
+    return value;
+}

package/dist/cli.js

@@ -1,319 +1,84 @@
 #!/usr/bin/env node
 import { existsSync } from "node:fs";
 import { loadEnvFile } from "node:process";
-import { cp, mkdir } from "node:fs/promises";
-import { createRequire } from "node:module";
-import { resolve, join, relative, isAbsolute, sep } from "node:path";
+import { join } from "node:path";
 import { pathToFileURL } from "node:url";
-import { serve } from "@hono/node-server";
-import { build, createServer } from "vite";
-import { defineRuntime } from "./config.js";
-import { allowedHost, createRuntime, loopbackHosts } from "./server/host.js";
-import { configureProvider, ConfigurationCancelled, } from "./model/configure.js";
-import { modelSelection } from "./model/settings.js";
-import { modelsFor } from "./model/models.js";
-import { ProjectCredentialStore } from "./model/auth-store.js";
-const usage = `nylorun <dev|studio|configure|inspect|build|start>
-  dev [--no-studio] [--no-open] [--port <n>] [--host <address>] [--allowed-hosts <list>]
-  studio --agent-url <http(s)-url> [--port <n>] [--no-open]
-  start [--port <n>] [--host <address>] [--allowed-hosts <list>]
-Run from the directory containing nylorun.config.ts.
-PORT, HOST and ALLOWED_HOSTS environment variables supply the same settings.`;
-async function studio(agentServerUrl, open, port) {
+import { createRequire } from "node:module";
+import { ConfigurationCancelled, configureProvider } from "./model/configure.js";
+const usage = `nylorun <configure|studio>
+  configure
+  studio --agent-url <http(s)-url> [--port <n>] [--no-open]`;
+async function startStudio(agentServerUrl, open, port) {
     let entry;
     try {
         entry = createRequire(join(process.cwd(), "package.json")).resolve("@nylorun/studio");
     }
     catch {
-        throw new Error("Install @nylorun/studio in this project, or run nylorun dev --no-studio.");
+        throw new Error("Install @nylorun/studio to use the Studio dashboard.");
     }
-    const module = await import(pathToFileURL(entry).href);
-    return module.startStudio({
-        agentServerUrl,
-        open,
-        ...(port === undefined ? {} : { port }),
-    });
-}
-function port(value, fallback) {
-    const result = value === undefined ? fallback : Number(value);
-    if (!Number.isInteger(result) || result < 1 || result > 65535)
-        throw new Error("Port must be an integer between 1 and 65535.");
-    return result;
+    const studio = await import(pathToFileURL(entry).href);
+    return studio.startStudio({ agentServerUrl, open, ...(port === undefined ? {} : { port }) });
 }
-/**
- * Loopback binds answer only to their own address on the chosen port, so
- * development needs no setup. A published bind or an explicit allowed-host
- * list is the deployment decision; "*" accepts any Host header.
- */
-function bindAddress(host, allowed, hostPort) {
-    const hostname = (host?.trim() || "127.0.0.1").replace(/^\[(.*)\]$/u, "$1");
-    const loopback = ["127.0.0.1", "localhost", "::1"].includes(hostname);
-    const configured = (allowed ?? "")
-        .split(",")
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-    const hosts = configured.length
-        ? [...(loopback ? loopbackHosts(hostPort) : []), ...configured]
-        : loopback
-            ? loopbackHosts(hostPort)
-            : ["*"];
-    const unspecified = ["0.0.0.0", "::"].includes(hostname);
-    const reachable = unspecified
-        ? "127.0.0.1"
-        : hostname.includes(":")
-            ? `[${hostname}]`
-            : hostname;
-    return { hostname, reachable, loopback, hosts };
-}
-async function sourceLoader() {
-    const vite = await createServer({
-        configFile: false,
-        appType: "custom",
-        optimizeDeps: { noDiscovery: true, include: [] },
-        server: { middlewareMode: true, hmr: false, ws: false },
-        ssr: { external: true },
-    });
-    return {
-        vite,
-        async load() {
-            const module = await vite.ssrLoadModule("/nylorun.config.ts");
-            return defineRuntime(module.default);
-        },
-    };
+function parsePort(value) {
+    if (value === undefined)
+        return undefined;
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        throw new Error("--port must be an integer between 1 and 65535.");
+    return port;
 }
 async function main() {
     const [command, ...args] = process.argv.slice(2);
-    if (!command || command === "--help" || command === "-h") {
-        console.log(usage);
-        return;
-    }
-    const allowed = {
-        dev: ["--no-studio", "--no-open", "--port", "--host", "--allowed-hosts"],
-        studio: ["--agent-url", "--port", "--no-open"],
-        start: ["--port", "--host", "--allowed-hosts"],
-        configure: [],
-        inspect: [],
-        build: [],
-    };
-    if (!(command in allowed))
-        throw new Error(usage);
-    const flags = new Map();
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!allowed[command].includes(arg) || flags.has(arg))
-            throw new Error(`Invalid option ${arg}\n${usage}`);
-        if (["--port", "--agent-url", "--host", "--allowed-hosts"].includes(arg)) {
-            const value = args[++i];
-            if (!value || value.startsWith("--"))
-                throw new Error(`${arg} requires a value.`);
-            flags.set(arg, value);
-        }
-        else
-            flags.set(arg, true);
-    }
-    const requestedPort = flags.get("--port");
+    if (!command || command === "--help" || command === "-h")
+        return void console.log(usage);
     if (command === "configure") {
+        if (args.length)
+            throw new Error(usage);
         const controller = new AbortController();
-        const onInt = () => controller.abort(new ConfigurationCancelled("SIGINT"));
-        const onTerm = () => controller.abort(new ConfigurationCancelled("SIGTERM"));
-        process.on("SIGINT", onInt);
-        process.on("SIGTERM", onTerm);
-        try {
-            const integrations = join(process.cwd(), ".env", "integrations.env");
-            if (existsSync(integrations))
-                loadEnvFile(integrations);
-            await configureProvider({ signal: controller.signal });
-        }
-        finally {
-            process.removeListener("SIGINT", onInt);
-            process.removeListener("SIGTERM", onTerm);
-        }
-        return;
-    }
-    let stopping = false;
-    const shutdown = [];
-    const stop = async () => {
-        if (stopping)
-            return;
-        stopping = true;
-        const results = await Promise.allSettled(shutdown.map((close) => close()));
-        if (results.some((result) => result.status === "rejected"))
-            process.exitCode = 1;
-    };
-    process.once("SIGINT", () => void stop());
-    process.once("SIGTERM", () => void stop());
-    try {
+        const cancel = (signal) => controller.abort(new ConfigurationCancelled(signal));
+        process.once("SIGINT", () => cancel("SIGINT"));
+        process.once("SIGTERM", () => cancel("SIGTERM"));
         const integrations = join(process.cwd(), ".env", "integrations.env");
         if (existsSync(integrations))
             loadEnvFile(integrations);
-        if (command === "studio") {
-            const url = flags.get("--agent-url");
-            if (typeof url !== "string")
-                throw new Error("--agent-url is required.");
-            const dashboard = await studio(url, !flags.has("--no-open"), requestedPort ? port(requestedPort, 0) : undefined);
-            shutdown.push(() => dashboard.close());
-            console.log(`Studio on ${dashboard.address}`);
-            return;
-        }
-        if (command === "build") {
-            await build({
-                configFile: false,
-                build: {
-                    target: "node22",
-                    ssr: "nylorun.config.ts",
-                    outDir: "dist",
-                    rollupOptions: { output: { entryFileNames: "nylorun.config.js" } },
-                },
-                ssr: { external: true },
-            });
-            if (existsSync("agent")) {
-                await mkdir("dist/agent", { recursive: true });
-                await cp("agent", "dist/agent", {
-                    recursive: true,
-                    filter: (source) => !source.split(/[\\/]/).includes("node_modules"),
-                });
-            }
-            return;
-        }
-        let loader;
-        let config;
-        if (command === "start")
-            config = defineRuntime((await import(pathToFileURL(resolve("dist/nylorun.config.js")).href))
-                .default);
-        else {
-            loader = await sourceLoader();
-            shutdown.push(() => loader.vite.close());
-            config = await loader.load();
-        }
-        if (command === "inspect") {
-            let setup = "required";
-            try {
-                const selected = modelSelection();
-                setup = (await modelsFor(selected, new ProjectCredentialStore()).checkAuth(selected.provider))
-                    ? "ready"
-                    : "required";
-            }
-            catch {
-                /* Unconfigured is a valid inspection state. */
-            }
-            console.log(JSON.stringify({ agents: config.agents.map((agent) => agent.manifest), setup }, null, 2));
-            await stop();
-            return;
-        }
-        let current = await createRuntime(config);
-        const retained = [current];
-        shutdown.push(async () => {
-            await Promise.all(retained.map((runtime) => runtime.close()));
-        });
-        const fetch = async (request) => {
-            const path = new URL(request.url).pathname;
-            const collection = path.match(/^\/agents\/([^/]+)\/v1\/sessions$/);
-            if (request.method === "GET" && collection && retained.length > 1) {
-                const response = await current.app.fetch(request);
-                if (!response.ok)
-                    return response;
-                const agentId = collection[1];
-                const document = (await response.json());
-                const summaries = new Map(document.sessions.map((item) => [item.session, item]));
-                // A journal may be shared across reloads, but only the owning runtime
-                // knows whether a retained session is still running or waiting.
-                for (const runtime of retained) {
-                    if (runtime === current)
-                        continue;
-                    const previous = await runtime.app.fetch(request.clone());
-                    if (!previous.ok)
-                        continue;
-                    const history = (await previous.json());
-                    for (const summary of history.sessions) {
-                        if (runtime.hasSession(agentId, summary.session) ||
-                            !summaries.has(summary.session))
-                            summaries.set(summary.session, summary);
-                    }
-                }
-                return new Response(JSON.stringify({
-                    sessions: [...summaries.values()].sort((a, b) => b.startedAt - a.startedAt),
-                }), { status: response.status, headers: response.headers });
-            }
-            const match = path.match(/^\/agents\/([^/]+)\/v1\/(?:sessions|ag-ui\/sessions|media)\/([^/]+)/);
-            let agentId = match?.[1];
-            let sessionId = match?.[2];
-            if (!match && request.method === "POST" && path.endsWith("/v1/ag-ui")) {
-                agentId = path.split("/")[2];
-                const body = await request
-                    .clone()
-                    .json()
-                    .catch(() => ({}));
-                sessionId =
-                    typeof body.threadId === "string" ? body.threadId : undefined;
-            }
-            const runtime = agentId && sessionId
-                ? [...retained]
-                    .reverse()
-                    .find((item) => item.hasSession(agentId, sessionId)) ?? current
-                : current;
-            return runtime.app.fetch(request);
-        };
-        const hostPort = port(requestedPort ?? process.env.PORT, 4111);
-        const binding = bindAddress(flags.get("--host") ?? process.env.HOST, flags.get("--allowed-hosts") ??
-            process.env.ALLOWED_HOSTS, hostPort);
-        const guarded = async (request) => allowedHost(request.headers.get("host") ?? undefined, binding.hosts)
-            ? fetch(request)
-            : Response.json({
-                error: "Host header is not allowed. Set --allowed-hosts or ALLOWED_HOSTS.",
-            }, { status: 421 });
-        const server = serve({
-            fetch: guarded,
-            hostname: binding.hostname,
-            port: hostPort,
-        });
-        shutdown.push(() => new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve()))));
-        await new Promise((resolve, reject) => {
-            server.once("listening", resolve);
-            server.once("error", reject);
-        });
-        const address = `http://${binding.reachable}:${hostPort}`;
-        console.log(`Agent runtime on ${address}`);
-        if (!binding.loopback)
-            console.log(binding.hosts.includes("*")
-                ? "Serving every Host header; add TLS and access control at the network boundary."
-                : `Serving Host headers: ${binding.hosts.join(", ")}`);
-        if (command === "dev" && !flags.has("--no-studio")) {
-            const dashboard = await studio(address, !flags.has("--no-open"));
-            shutdown.push(() => dashboard.close());
-            console.log(`Studio on ${dashboard.address}`);
+        await configureProvider({ signal: controller.signal });
+        return;
+    }
+    if (command !== "studio")
+        throw new Error(usage);
+    let agentUrl;
+    let port;
+    let open = true;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--agent-url") {
+            if (agentUrl !== undefined)
+                throw new Error("--agent-url may only be supplied once.");
+            agentUrl = args[++index];
+            if (!agentUrl || agentUrl.startsWith("--"))
+                throw new Error("--agent-url requires a value.");
         }
-        if (loader) {
-            let reload = Promise.resolve();
-            loader.vite.watcher.on("all", (event, file) => {
-                const path = relative(process.cwd(), file).split(sep).join("/");
-                if (stopping ||
-                    !["add", "change", "unlink"].includes(event) ||
-                    isAbsolute(path) ||
-                    path.startsWith("..") ||
-                    !(path === "nylorun.config.ts" || path.startsWith("agent/")))
-                    return;
-                reload = reload.then(async () => {
-                    try {
-                        loader.vite.moduleGraph.invalidateAll();
-                        const replacement = await createRuntime(await loader.load());
-                        current = replacement;
-                        retained.push(replacement);
-                        console.log(`Reloaded ${path}`);
-                    }
-                    catch (error) {
-                        console.error(`Reload failed; existing agents remain active: ${error instanceof Error ? error.message : String(error)}`);
-                    }
-                });
-            });
+        else if (arg === "--port") {
+            if (port !== undefined)
+                throw new Error("--port may only be supplied once.");
+            port = parsePort(args[++index]);
         }
+        else if (arg === "--no-open" && open)
+            open = false;
+        else
+            throw new Error(usage);
     }
-    catch (error) {
-        await stop();
-        throw error;
-    }
+    if (!agentUrl)
+        throw new Error("--agent-url is required.");
+    const dashboard = await startStudio(agentUrl, open, port);
+    console.log(`Studio on ${dashboard.address}`);
+    await new Promise((resolve, reject) => {
+        const close = () => void dashboard.close().then(resolve, reject);
+        process.once("SIGINT", close);
+        process.once("SIGTERM", close);
+    });
 }
 void main().catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
-    process.exitCode =
-        error instanceof ConfigurationCancelled ? error.exitCode : 1;
+    process.exitCode = error instanceof ConfigurationCancelled ? error.exitCode : 1;
 });

package/dist/config.d.ts

@@ -1,10 +1,13 @@
-import type { RuntimeAgent } from "./contracts.js";
-import type { RuntimePersistence } from "./adapters/journal.js";
+import type { RuntimeModelAdapter } from "./contracts.js";
+import type { RuntimeDurability } from "./adapters/journal.js";
 import type { RuntimeMedia } from "./adapters/media.js";
 export interface RuntimeConfig {
-    readonly agents: readonly RuntimeAgent[];
-    readonly persistence?: RuntimePersistence;
+    readonly onModelCall?: RuntimeModelAdapter;
+    readonly observer?: {
+        (event: {
+            readonly type: string;
+        }): void | Promise<void>;
+    };
+    readonly durability?: RuntimeDurability;
     readonly media?: RuntimeMedia;
-    readonly origins?: readonly string[];
 }
-export declare function defineRuntime(config: RuntimeConfig): RuntimeConfig;