@nylorun/cli 0.2.1-beta → 0.3.0-beta

package/dist/dev.d.ts

@@ -1,6 +1,47 @@
+export interface DevelopOptions {
+    entry?: string;
+    flags?: readonly string[];
+    projectRoot?: string;
+    home?: string;
+}
+export type DevelopmentPreflight = {
+    tsx: string;
+    entry: string;
+    ephemeral: boolean;
+    localUi: boolean;
+    studio: boolean;
+    open: boolean;
+};
 /**
- * Everything that can be checked without contacting the host, so a project that cannot run
- * never causes a Runtime to be started on its behalf.
+ * Everything that can be checked without contacting the Host, so a Project that
+ * cannot run never causes a Runtime Host to be started on its behalf.
  */
-export declare function developmentPreflight(args: readonly string[]): string;
-export declare function develop(args: readonly string[]): Promise<number>;
+export declare function developmentPreflight(args?: readonly string[]): DevelopmentPreflight;
+/**
+ * Resolve `@nylorun/studio` from the Project and call `startStudio`.
+ * Used by `nylorun studio` and `nylorun dev --local-ui`.
+ */
+export declare function startStudio(options: {
+    runtimeUrl: string;
+    serverKey: string;
+    tenant: {
+        id: string;
+        name: string;
+    };
+    open: boolean;
+    port?: number;
+    /** When true, force local UI. When false/omit, use startStudio default (hosted). */
+    localUi?: boolean;
+    cacheDir?: string;
+    projectRoot?: string;
+}): Promise<{
+    address: string;
+    launchUrl: string;
+    close(): Promise<void>;
+}>;
+/**
+ * `nylorun dev [entry]` — D§12 steps 1–4.
+ * Spawns `tsx watch <entry>` with the three Project environment variables.
+ * `--local-ui` also starts the Studio proxy with a local dashboard.
+ */
+export declare function develop(options?: DevelopOptions): Promise<number>;

package/dist/dev.js

@@ -1,15 +1,41 @@
 import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { basename, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { loadProjectEnvironment } from "./environment.js";
+import { attachProject } from "./project/attach.js";
+import { seedTenantFromProject } from "./project/seed.js";
+import { requireProjectRoot } from "./project/root.js";
+import { resolveHome } from "./runtime/launcher.js";
+const DEV_FLAGS = ["--ephemeral", "--local-ui", "--no-studio", "--no-open"];
 /**
- * Everything that can be checked without contacting the host, so a project that cannot run
- * never causes a Runtime to be started on its behalf.
+ * Everything that can be checked without contacting the Host, so a Project that
+ * cannot run never causes a Runtime Host to be started on its behalf.
  */
-export function developmentPreflight(args) {
-    if (new Set(args).size !== args.length ||
-        args.some((arg) => !["--no-studio", "--no-open", "--no-autostart"].includes(arg)))
-        throw new Error("Usage: nylorun dev [--no-studio] [--no-open] [--no-autostart]");
+export function developmentPreflight(args = []) {
+    const flags = [];
+    let entry;
+    for (const arg of args) {
+        if (DEV_FLAGS.includes(arg)) {
+            flags.push(arg);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error("Usage: nylorun dev [entry] [--ephemeral] [--local-ui] [--no-studio] [--no-open]\nDefault entry: src/main.ts");
+        }
+        if (entry !== undefined) {
+            throw new Error("Usage: nylorun dev [entry] [--ephemeral] [--local-ui] [--no-studio] [--no-open]\nDefault entry: src/main.ts");
+        }
+        entry = arg;
+    }
+    if (new Set(flags).size !== flags.length) {
+        throw new Error("Usage: nylorun dev [entry] [--ephemeral] [--local-ui] [--no-studio] [--no-open]\nDefault entry: src/main.ts");
+    }
+    const localUi = flags.includes("--local-ui");
+    const noStudio = flags.includes("--no-studio");
+    if (localUi && noStudio) {
+        throw new Error("--local-ui cannot be combined with --no-studio.");
+    }
     const require = createRequire(join(process.cwd(), "package.json"));
     let tsx;
     try {
@@ -18,48 +44,235 @@ export function developmentPreflight(args) {
     catch {
         throw new Error("Install tsx to use nylorun dev");
     }
-    if (!args.includes("--no-studio"))
+    if (localUi) {
         try {
             require.resolve("@nylorun/studio");
         }
         catch {
-            throw new Error("Install @nylorun/studio or use --no-studio");
+            throw new Error("Install @nylorun/studio to use the Studio dashboard.");
         }
-    return tsx;
-}
-export async function develop(args) {
-    const tsx = developmentPreflight(args);
-    const child = spawn(process.execPath, [
+    }
+    return {
         tsx,
-        "watch",
-        "--clear-screen=false",
-        fileURLToPath(new URL("./dev-entry.js", import.meta.url)),
-        ...args,
-    ], 
-    // Deliver terminal shutdown once, through the supervisor, instead of twice through the terminal group.
-    {
-        stdio: "inherit",
-        env: process.env,
-        detached: process.platform !== "win32",
+        entry: entry ?? "src/main.ts",
+        ephemeral: flags.includes("--ephemeral"),
+        localUi,
+        studio: localUi,
+        open: !flags.includes("--no-open"),
+    };
+}
+/**
+ * Resolve `@nylorun/studio` from the Project and call `startStudio`.
+ * Used by `nylorun studio` and `nylorun dev --local-ui`.
+ */
+export async function startStudio(options) {
+    const projectRoot = options.projectRoot ?? process.cwd();
+    let entry;
+    try {
+        entry = createRequire(join(projectRoot, "package.json")).resolve("@nylorun/studio");
+    }
+    catch {
+        throw new Error("Install @nylorun/studio to use the Studio dashboard.");
+    }
+    const studio = await import(pathToFileURL(entry).href);
+    const cacheDir = options.cacheDir ?? resolveHome();
+    const ui = options.localUi ? "local" : undefined;
+    return studio.startStudio({
+        runtimeUrl: options.runtimeUrl,
+        serverKey: options.serverKey,
+        tenant: options.tenant,
+        open: options.open,
+        cacheDir,
+        ...(ui === undefined ? {} : { ui }),
+        ...(options.port === undefined ? {} : { port: options.port }),
     });
-    let stopping = false;
+}
+/**
+ * `nylorun dev [entry]` — D§12 steps 1–4.
+ * Spawns `tsx watch <entry>` with the three Project environment variables.
+ * `--local-ui` also starts the Studio proxy with a local dashboard.
+ */
+export async function develop(options = {}) {
+    const normalized = options;
+    const projectRoot = normalized.projectRoot ?? requireProjectRoot();
+    const previous = process.cwd();
+    process.chdir(projectRoot);
+    let preflight;
+    try {
+        preflight = developmentPreflight([
+            ...(normalized.entry ? [normalized.entry] : []),
+            ...(normalized.flags ?? []),
+        ]);
+    }
+    finally {
+        process.chdir(previous);
+    }
+    if (preflight.ephemeral) {
+        const { startEphemeral } = await import("./runtime/ephemeral.js");
+        const { writeLink } = await import("./project/link.js");
+        const { writeCredentials } = await import("./project/credentials.js");
+        const ephemeral = await startEphemeral({
+            name: basename(projectRoot),
+        });
+        try {
+            await writeCredentials(projectRoot, {
+                applicationKey: ephemeral.applicationKey,
+                principalId: "pr_ephemeral",
+            });
+            await writeLink(projectRoot, {
+                hostUrl: ephemeral.url,
+                hostId: ephemeral.hostId,
+                tenantId: ephemeral.tenant.id,
+            });
+            const envMap = loadProjectEnvironment(projectRoot);
+            await seedTenantFromProject({
+                hostUrl: ephemeral.url,
+                tenantId: ephemeral.tenant.id,
+                applicationKey: ephemeral.applicationKey,
+                projectRoot,
+                env: envMap,
+            });
+            return await spawnWatcher({
+                projectRoot,
+                entry: preflight.entry,
+                tsx: preflight.tsx,
+                envMap,
+                hostUrl: ephemeral.url,
+                tenantId: ephemeral.tenant.id,
+                applicationKey: ephemeral.applicationKey,
+                tenantName: ephemeral.tenant.name,
+                hostStarted: true,
+                ephemeral: true,
+                localUi: preflight.localUi,
+                openStudio: preflight.open,
+                home: normalized.home,
+            });
+        }
+        finally {
+            await ephemeral.close();
+        }
+    }
+    const attached = await attachProject({
+        projectRoot,
+        ...(normalized.home ? { home: normalized.home } : {}),
+    });
+    const envMap = loadProjectEnvironment(projectRoot);
+    await seedTenantFromProject({
+        hostUrl: attached.link.hostUrl,
+        tenantId: attached.link.tenantId,
+        applicationKey: attached.credentials.applicationKey,
+        projectRoot,
+        env: envMap,
+    });
+    return spawnWatcher({
+        projectRoot,
+        entry: preflight.entry,
+        tsx: preflight.tsx,
+        envMap,
+        hostUrl: attached.link.hostUrl,
+        tenantId: attached.link.tenantId,
+        applicationKey: attached.credentials.applicationKey,
+        tenantName: attached.tenantName,
+        hostStarted: attached.hostStarted,
+        ephemeral: false,
+        localUi: preflight.localUi,
+        openStudio: preflight.open,
+        home: normalized.home ?? attached.home,
+    });
+}
+async function spawnWatcher(options) {
+    const entryPath = resolve(options.projectRoot, options.entry);
+    const childEnv = {
+        ...process.env,
+        ...options.envMap,
+        NYLORUN_RUNTIME_URL: options.hostUrl,
+        NYLORUN_TENANT: options.tenantId,
+        NYLORUN_SERVER_KEY: options.applicationKey,
+    };
+    let studio;
+    let studioMode;
+    if (options.localUi) {
+        studio = await startStudio({
+            runtimeUrl: options.hostUrl,
+            serverKey: options.applicationKey,
+            tenant: { id: options.tenantId, name: options.tenantName },
+            open: options.openStudio,
+            localUi: true,
+            cacheDir: resolveHome(options.home),
+            projectRoot: options.projectRoot,
+        });
+        studioMode = "local";
+    }
+    // Handle signals before the banner: a supervisor may stop us as soon as it
+    // reads it, and an unhandled SIGTERM would kill this process and orphan the
+    // detached watcher.
+    let child;
+    let stopping;
     const stop = (signal) => {
         if (stopping)
             return;
-        stopping = true;
-        child.kill(signal);
+        stopping = signal;
+        child?.kill(signal);
     };
-    const interrupt = () => stop("SIGINT"), terminate = () => stop("SIGTERM");
+    const interrupt = () => stop("SIGINT");
+    const terminate = () => stop("SIGTERM");
     process.on("SIGINT", interrupt);
     process.on("SIGTERM", terminate);
     try {
-        return await new Promise((resolve, reject) => {
-            child.once("error", reject);
-            child.once("exit", (code, signal) => resolve(code ?? (signal === "SIGINT" ? 130 : 143)));
+        printBanner({
+            hostUrl: options.hostUrl,
+            hostStarted: options.hostStarted,
+            ephemeral: options.ephemeral,
+            tenantName: options.tenantName,
+            tenantId: options.tenantId,
+            entry: options.entry,
+            studioLaunchUrl: studio?.launchUrl,
+            studioMode,
+        });
+        if (stopping)
+            return stopping === "SIGINT" ? 130 : 143;
+        const watcher = spawn(process.execPath, [options.tsx, "watch", "--clear-screen=false", entryPath], {
+            cwd: options.projectRoot,
+            stdio: "inherit",
+            env: childEnv,
+            detached: process.platform !== "win32",
+        });
+        child = watcher;
+        return await new Promise((resolvePromise, reject) => {
+            watcher.once("error", reject);
+            watcher.once("exit", (code, signal) => resolvePromise(code ?? (signal === "SIGINT" ? 130 : 143)));
         });
     }
     finally {
         process.removeListener("SIGINT", interrupt);
         process.removeListener("SIGTERM", terminate);
+        await studio?.close().catch(() => { });
+    }
+}
+function printBanner(options) {
+    const hostNote = options.ephemeral
+        ? "(ephemeral; removed on exit)"
+        : options.hostStarted
+            ? "(started; stays running)"
+            : "(already running)";
+    const short = options.tenantId.length > 12
+        ? `${options.tenantId.slice(0, 12)}…`
+        : options.tenantId;
+    console.log(`Host          ${options.hostUrl}  ${hostNote}`);
+    console.log(`Tenant        ${options.tenantName}  ${short}`);
+    console.log(`Entry         ${options.entry}`);
+    if (options.studioLaunchUrl) {
+        console.log(`Studio        ${options.studioLaunchUrl}`);
+        if (options.studioMode === "hosted") {
+            console.log(`Safari or offline: nylorun studio --local-ui`);
+        }
+    }
+    else {
+        console.log(`Studio: npm run studio`);
+    }
+    console.log("");
+    console.log("Ctrl-C stops this Project only.");
+    if (!options.ephemeral) {
+        console.log("nylorun runtime down  stops the Host.");
     }
 }

package/dist/doctor.d.ts

@@ -1,7 +1,29 @@
-import type { AgentManifest } from "@nylorun/agents";
-/** `nylorun doctor sandbox`: what this machine offers and what a Runtime here would pick. */
+import { type AgentManifest } from "@nylorun/agents";
+export type SandboxReport = {
+    preference: string;
+    backend: string | null;
+    isolation?: string;
+    reason?: string;
+    probes: {
+        name: string;
+        isolation: string;
+        available: boolean;
+        reason?: string;
+        version?: string;
+    }[];
+    defaultImage?: string;
+};
+/**
+ * `nylorun doctor runtime`: check the two prerequisites (Node 24+ and an
+ * installed `@nylorun/runtime`) and print the fix for each one that fails.
+ * Exits 1 when a prerequisite is missing; installs nothing.
+ */
+export declare function doctorRuntime(options: {
+    json: boolean;
+}): Promise<void>;
+/** `nylorun doctor sandbox`: Tenant sandbox report via the Tenant API (F2-4). */
 export declare function doctorSandbox(options: {
     json: boolean;
 }): Promise<void>;
 /** One line for the dev banner, or undefined when no connected agent declares a sandbox. */
-export declare function sandboxBanner(runtimeUrl: string, serverKey: string, manifests: readonly AgentManifest[]): Promise<string | undefined>;
+export declare function sandboxBanner(runtimeUrl: string, serverKey: string, manifests: readonly AgentManifest[], tenantId: string): Promise<string | undefined>;

package/dist/doctor.js

@@ -1,24 +1,110 @@
 import { release } from "node:os";
-import { probeSandboxBackends, } from "@nylorun/runtime/node";
+import { PROTOCOL_HEADER, PROTOCOL_VERSION, TENANT_HEADER, createClient, resolveConnection, } from "@nylorun/agents";
+import { CliError } from "./errors.js";
+import { launcher, resolveHome, runtimeInstallCommand } from "./runtime/launcher.js";
+/** Oldest Node the Runtime runs on (it needs node:sqlite). */
+const MIN_NODE_MAJOR = 24;
 const LABEL = {
     microsandbox: "microsandbox VM",
     virtual: "virtual shell",
 };
-/** `nylorun doctor sandbox`: what this machine offers and what a Runtime here would pick. */
+function platformLine() {
+    const os = process.platform === "darwin"
+        ? "macOS"
+        : process.platform === "win32"
+            ? "Windows"
+            : process.platform;
+    return `${os} (kernel ${release()}) · ${process.arch}`;
+}
+async function fetchSandboxReport(options) {
+    const connection = await resolveConnection(options);
+    const client = createClient({
+        url: connection.url,
+        key: connection.key,
+        tenant: connection.tenant,
+    });
+    return client.transport.json("/v1/tenant/sandbox", "GET", undefined);
+}
+/**
+ * `nylorun doctor runtime`: check the two prerequisites (Node 24+ and an
+ * installed `@nylorun/runtime`) and print the fix for each one that fails.
+ * Exits 1 when a prerequisite is missing; installs nothing.
+ */
+export async function doctorRuntime(options) {
+    const nodeOk = Number(process.versions.node.split(".")[0]) >= MIN_NODE_MAJOR;
+    let runtime;
+    try {
+        const handle = await launcher(resolveHome());
+        runtime = { ok: true, ...handle.runtime };
+    }
+    catch (error) {
+        runtime = {
+            ok: false,
+            problem: error instanceof Error ? error.message : String(error),
+        };
+    }
+    if (options.json) {
+        console.log(JSON.stringify({
+            node: { version: process.versions.node, ok: nodeOk },
+            runtime,
+            install: runtimeInstallCommand(),
+        }, null, 2));
+    }
+    else {
+        const rows = [
+            [
+                "node",
+                nodeOk
+                    ? `✓ ${process.versions.node}`
+                    : `✗ ${process.versions.node}: install Node ${MIN_NODE_MAJOR} or newer`,
+            ],
+            [
+                "runtime",
+                runtime.ok
+                    ? `✓ ${runtime.version} · ${runtime.bin}`
+                    : `✗ ${runtime.problem.split("\n")[0]}\n    ${runtimeInstallCommand()}`,
+            ],
+        ];
+        const width = Math.max(...rows.map(([key]) => key.length)) + 2;
+        for (const [key, value] of rows)
+            console.log(`  ${key.padEnd(width)}${value}`);
+    }
+    if (!nodeOk || !runtime.ok)
+        process.exitCode = 1;
+}
+/** `nylorun doctor sandbox`: Tenant sandbox report via the Tenant API (F2-4). */
 export async function doctorSandbox(options) {
-    const report = await probeSandboxBackends();
+    let report;
+    try {
+        report = await fetchSandboxReport();
+    }
+    catch (error) {
+        throw new CliError(error instanceof Error
+            ? error.message
+            : `Could not read Tenant sandbox status: ${String(error)}`, 1);
+    }
     if (options.json) {
-        console.log(JSON.stringify({ platform: platform(), ...report }, null, 2));
+        console.log(JSON.stringify({ platform: platformLine(), ...report }, null, 2));
         return;
     }
-    const rows = [["platform", platform()]];
+    const rows = [["platform", platformLine()]];
     for (const probe of report.probes)
         rows.push([
             probe.name,
             `${probe.available ? "✓" : "✗"} ${probe.reason ?? ""}${probe.version ? ` · ${probe.version}` : ""}`,
         ]);
-    rows.push(["preference", report.preference === "auto" ? "auto (set NYLORUN_SANDBOX to force one)" : report.preference]);
-    rows.push(["selected", report.backend ? `${report.backend} (${report.isolation} isolation)` : `none: ${report.reason}`]);
+    rows.push([
+        "preference",
+        report.preference === "auto"
+            ? "auto (seed Tenant sandbox.backend via nylorun dev / .env NYLORUN_SANDBOX)"
+            : report.preference,
+    ]);
+    rows.push([
+        "selected",
+        report.backend
+            ? `${report.backend} (${report.isolation} isolation)`
+            : `none: ${report.reason}`,
+    ]);
     const width = Math.max(...rows.map(([key]) => key.length)) + 2;
     for (const [key, value] of rows)
         console.log(`  ${key.padEnd(width)}${value}`);
@@ -27,7 +113,7 @@ export async function doctorSandbox(options) {
             "  For hardware isolation use macOS on Apple Silicon or Linux with KVM.");
 }
 /** One line for the dev banner, or undefined when no connected agent declares a sandbox. */
-export async function sandboxBanner(runtimeUrl, serverKey, manifests) {
+export async function sandboxBanner(runtimeUrl, serverKey, manifests, tenantId) {
     const capability = manifests
         .flatMap((manifest) => manifest.capabilities)
         .find((item) => item.sandbox);
@@ -35,14 +121,20 @@ export async function sandboxBanner(runtimeUrl, serverKey, manifests) {
         return undefined;
     let report;
     try {
-        const response = await fetch(`${runtimeUrl}/v1/host/sandbox`, {
-            headers: { authorization: `Bearer ${serverKey}` },
+        const response = await fetch(`${runtimeUrl}/v1/tenant/sandbox`, {
+            headers: {
+                authorization: `Bearer ${serverKey}`,
+                [TENANT_HEADER]: tenantId,
+                [PROTOCOL_HEADER]: String(PROTOCOL_VERSION),
+            },
             signal: AbortSignal.timeout(10_000),
         });
         if (response.ok)
-            report = await response.json();
+            report = (await response.json());
+    }
+    catch {
+        /* ignore */
     }
-    catch { }
     if (!report)
         return undefined;
     const doctor = "run `npx nylorun doctor sandbox` for options";
@@ -55,7 +147,3 @@ export async function sandboxBanner(runtimeUrl, serverKey, manifests) {
         ? `sandbox: ${LABEL[report.backend] ?? report.backend} (${report.reason}) · ${doctor}`
         : `sandbox: ${LABEL[report.backend] ?? report.backend}${report.backend === "microsandbox" && image ? ` · image ${image}` : ""} · network: ${network}`;
 }
-function platform() {
-    const os = process.platform === "darwin" ? "macOS" : process.platform === "win32" ? "Windows" : process.platform;
-    return `${os} (kernel ${release()}) · ${process.arch}`;
-}

package/dist/environment.d.ts

@@ -1,2 +1,5 @@
-export declare function loadProjectEnvironment(root?: string): void;
+/**
+ * Read the Project `.env` into a value map. Does not mutate `process.env` (F3).
+ */
+export declare function loadProjectEnvironment(root?: string): Record<string, string>;
 export declare function saveEnvironment(root: string, updates: Record<string, string | undefined>, signal?: AbortSignal): Promise<void>;

package/dist/environment.js

@@ -2,7 +2,10 @@ import { readFileSync, statSync } from "node:fs";
 import { writeFile, rename, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
-import { loadEnvFile } from "node:process";
+import { parseEnv } from "node:util";
+/**
+ * Read the Project `.env` into a value map. Does not mutate `process.env` (F3).
+ */
 export function loadProjectEnvironment(root = process.cwd()) {
     const file = join(root, ".env");
     try {
@@ -11,10 +14,16 @@ export function loadProjectEnvironment(root = process.cwd()) {
     }
     catch (error) {
         if (error.code === "ENOENT")
-            return;
+            return {};
         throw error;
     }
-    loadEnvFile(file);
+    const parsed = parseEnv(readFileSync(file, "utf8"));
+    const result = {};
+    for (const [key, value] of Object.entries(parsed)) {
+        if (value !== undefined)
+            result[key] = value;
+    }
+    return result;
 }
 // Match complete dotenv assignments, including quoted multiline values.
 const assignment = /^(?:export\s+)?([\w]+)[\t ]*=[\t ]*(?:"[^"]*"|'[^']*'|`[^`]*`|[^#\r\n]*)([^\r\n]*)(?:\r?\n|$)/gm;

package/dist/launcher.d.ts

@@ -1,5 +1,5 @@
-import type { Scope } from "./scope.js";
-export declare function serve(entry?: string, options?: {
-    autostart?: boolean;
-    scope?: Scope;
-}): Promise<void>;
+/**
+ * `nylorun serve` was removed (D§12 / F2-5). Use `nylorun dev` in development
+ * and `node dist/src/main.js` (with the three environment variables) in production.
+ */
+export declare function serve(): Promise<never>;

package/dist/launcher.js

@@ -1,4 +1,7 @@
-import { runProject } from "./project-runner.js";
-export async function serve(entry = "dist/agents/index.js", options = {}) {
-    await runProject(entry, options);
+/**
+ * `nylorun serve` was removed (D§12 / F2-5). Use `nylorun dev` in development
+ * and `node dist/src/main.js` (with the three environment variables) in production.
+ */
+export async function serve() {
+    throw new Error("nylorun serve was removed. Use nylorun dev [entry] in development, or node dist/src/main.js with NYLORUN_RUNTIME_URL, NYLORUN_TENANT and NYLORUN_SERVER_KEY.");
 }

package/dist/model/configure.d.ts

@@ -11,9 +11,39 @@ export type PromptedModel = {
     baseUrl?: string;
     auth: Credential;
 };
+export type ModelCatalog = {
+    providers: {
+        id: string;
+        name: string;
+        models: {
+            id: string;
+            name: string;
+        }[];
+        auth?: {
+            apiKey?: unknown;
+            oauth?: unknown;
+        };
+    }[];
+};
+export type Selection = Readonly<{
+    provider: string;
+    model: string;
+    custom?: Readonly<{
+        baseUrl: string;
+    }>;
+}>;
+/** Fetch GET /v1/tenant/models when a connection is available. */
+export declare function fetchModelCatalog(options: {
+    url: string;
+    key: string;
+    tenantId: string;
+    fetchImpl?: typeof fetch;
+}): Promise<ModelCatalog>;
 export declare function configureProvider(options?: {
     signal?: AbortSignal;
     root?: string;
     input?: Readable;
     output?: Writable;
+    /** Tenant API catalog from GET /v1/tenant/models. */
+    catalog?: ModelCatalog;
 }): Promise<PromptedModel>;