@nylorun/runtime 0.1.2-beta → 0.2.1-beta

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.2.1-beta
+
+### Patch Changes
+
+- fd24b00: Flatten Runtime agent routes to `/:id/...` and pass matching `basePath` from the Hono mount so discovery, manifests, and AG-UI resolve at `/agents/:id/...` for Studio.
+
+## 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

package/README.md

@@ -1,52 +1,37 @@
 # @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.
-
-## Configuration and adapters
+const runtime = new Runtime();
+app.route(
+  "/agents",
+  serveAgents({ agents, runtime, basePath: "/agents" })
+);
+```
 
-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.
+`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 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.
+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.
 
-`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.
+Runtime publishes root-relative discovery and endpoint URLs. `basePath` must match the Hono mount path so advertised manifests and AG-UI endpoints resolve. Agent-scoped routes are `/:id/...` inside the router, so mounting at `/agents` with `basePath: "/agents"` yields `/agents/:id/...`. Pass the same prefix for other mounts:
 
-## Portable contracts
+```ts
+app.route(
+  "/api/agents",
+  serveAgents({ agents, runtime, basePath: "/api/agents" })
+);
+```
 
-`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, interactions, and failures, and observation events for optional diagnostics. Error or tripwire completions and rejected, cancelled, or stopped statuses produce a terminal AG-UI error; repeated diagnostic and completion reports do not duplicate the failure. 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.
+`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.
 
-`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.
+## Commands
 
-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.
+- `nylorun configure`
+- `nylorun studio --agent-url http://localhost:3000/agents [--port 4161] [--no-open]`
 
-Repository development: [contributing](../CONTRIBUTING.md). Package publication: [releasing](../RELEASING.md).
+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.
 
-Provider continuation state (for example Gemini thought signatures) travels as
-opaque JSON `providerMetadata` on assistant text, reasoning, and tool-call
-blocks. Engines integrating `piModel()` must preserve it on the corresponding
-assistant prompt parts, including empty signed blocks and their order. Runtime
-only reuses signatures with the originating provider and model. Middleware that
-rewrites a signed block must remove its metadata; signatures describe the
-original provider output. Unsigned reasoning remains diagnostic output.
+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;
 });