@nylorun/cli 0.5.0-beta → 0.6.0-beta

package/CHANGELOG.md

@@ -1,5 +1,137 @@
 # @nylorun/cli
 
+## 0.6.0-beta
+
+### Minor Changes
+
+- 4282d5f: **Breaking: executors are removed; protocol 3.** The Runtime delivers every Action (tool, hook, `fn`, `verify`) to the Action endpoint an agent registers. It no longer offers Actions for executors to claim. See `MIGRATION.md`, "Action endpoints replace executors".
+
+  - **Core.** `PROTOCOL_VERSION` is 3 and a Host serves only protocol 3. `action-endpoints` is a protocol feature instead of an optional Host feature. Removed:
+
+    - the executor, claim and Action-list schemas;
+    - `action_result` from `SessionCommandSchema`;
+    - the `claimed` Action status, `claimId` and `leaseExpiresAt`.
+
+    New: `ActionResultReceiptSchema`, the receipt of `POST /v1/actions/:id/result`, which is `AcceptedResponse` without `requestId`.
+
+  - **Runtime.** Removed:
+
+    - `PUT`/`GET /v1/executors`, `DELETE /v1/executors/:agentId`, `GET /v1/executors/connect`;
+    - `GET /v1/actions`, `POST /v1/actions/:id/claim`, and the executor form of `POST /v1/actions/:id/heartbeat`;
+    - the `tenant/work` stream;
+    - claim expiry;
+    - executor credentials.
+
+    `POST /v1/actions/:id/sandbox/:tool` takes the delivery token only. Tenant summaries report `inFlightDeliveries` instead of `connectedExecutors`. Tenant status lists each agent's endpoint and has an `endpoints` check instead of `executors`.
+
+    Postgres migration 6 drops the `executors` table. Actions an executor had claimed are handled like lost deliveries: a tool becomes `uncertain`, and a hook, `fn` or `verify` is delivered again.
+
+  - **Agents.** Removed: `connectAgents`, the `@nylorun/agents/executor` subpath, derived executor keys and `NYLORUN_EXECUTOR_KEY`. Serve agents with `createActionHandler` and call `register({ url })`.
+  - **CLI.** Executor keys are gone from Project credentials. `nylo tenant endpoints` shows each endpoint and its health.
+
+- 82d95ef: **Action endpoints: background tools, CLI and Studio.**
+
+  - **Background tools (core, agents).** `tool({ …, background: true })` marks a tool that runs longer than an endpoint's timeout. The option is code-only and never serialized into the manifest. `createActionHandler` answers its delivery at once with `202`, runs the tool, heartbeats on the deadline the Runtime returns (each time with the newest delivery token), and posts the outcome. A heartbeat answered `409` (cancelled, lost or sent again) aborts the tool's `ctx.signal`, and nothing is posted. The new `waitUntil` option hands the background work to platforms that end a request's work with its response.
+  - **CLI.** `nylo tenant endpoints [--json]` lists each agent's Action endpoint and how it is doing, and `nylo tenant endpoints ping <agent>` pings one through the Runtime.
+  - **Studio.** Shows `action.delivered` ("Action delivered") and `action.delivery_failed` ("Delivery failed", with the endpoint's error and when it retries).
+
+- 50d0fb5: **Browser access: web pages and apps call the Runtime with a publishable key.** A page ships a publishable key and gets subject tokens from its app server; the Runtime answers it directly, with CORS (optional Host feature `browser-access`).
+
+  - **Publishable keys.** `nr_pub_<tenantId>_…`, sent in `Nylorun-Key`, name the Tenant and one app, with an origin allowlist (exact origins, or `http://localhost:*` and `http://127.0.0.1:*` for development; none for native apps). `GET`/`POST /v1/access/publishable-keys`, `PUT`/`DELETE …/:id`. A key alone grants the policy's `anon` role, at most the public agent list, and reaches no session or vault. Postgres migration 4.
+  - **Host.** With browser access on, requests with an `Origin` reach Tenant routes; `/health`, `/ready` and admin routes still refuse them. Preflights for browser routes (agents, sessions, vaults, AG-UI, JWKS) are answered from the route alone and grant no credentials; the actual request must carry a publishable key whose allowlist names the origin, and only then do responses (JSON, errors, `401`, `429`, event streams) carry CORS headers. A disallowed origin or unknown key gets the opaque `404`. Tenant and executor keys sent with an `Origin` are refused before they are looked up. `Nylorun-Tenant` may be left out when `Nylorun-Key` names the Tenant; both must agree when both are sent. Browser access is on in the stack (`NYLORUN_BROWSER_ACCESS=off` turns it off) and off for a Host started from `host.json` unless `browserAccess` is true.
+  - **JWKS.** `GET /v1/access/jwks` is readable by any caller that reaches the Tenant.
+  - **Agents SDK.** `@nylorun/agents/browser`: `createBrowserClient({ url, publishableKey, token })` keeps subject tokens in memory, refreshes them a minute before expiry or after `401 token_expired`, one fetch at a time, and creates sessions and vaults owned by the token's subject; it loads no Node module. `createTokenEndpoint()` is the app server's token route. `client.access.publishableKeys` manages keys. The transport accepts a `token` source and a `publishableKey`, and event streams the Runtime ends at token expiry reconnect at once. The Tenant API client classes move to a module with no Node imports; `@nylorun/agents` and `/client` export the same names.
+  - **CLI.** `nylo access keys list|create|set-origins|revoke`.
+
+- 6ab4c59: **Long sessions on any model: compaction.** A session whose history outgrows the model's context window keeps going, on a 16k local model as on a 1M hosted one.
+
+  - **Compaction.**
+    - **When.** Before each model call the engine estimates the prompt: the last reported usage, plus about four characters per token for what came after. If the estimate would not leave room for the reply, the engine first compacts: it asks the model to summarize the older history, then keeps about the newest 20,000 tokens (at most 30% of the window) verbatim.
+    - **What it keeps.** The cut never separates a tool call from its result. The current turn's request is always kept. A later compaction merges with the earlier summary.
+    - **Overflow.** If a provider still reports a context overflow, the engine compacts once and asks again.
+    - **Storage.** The summary is a `compaction` transcript entry that replaces the older entries in the session state; the event log keeps the full history. The summary call is a journaled model effect, so replays are deterministic.
+    - **New event.** `context.compacted` (`trigger`, `tokensBefore`, `tokensAfter`).
+  - **Custom endpoints.**
+    - **Settings.** Model Settings take `settings: { contextWindow, maxTokens, reasoning, compat }` for a custom OpenAI-compatible provider (vLLM, SGLang, llama.cpp, Ollama, LM Studio). `compat` is passed to pi-ai: `thinkingFormat`, `thinkingTokenBudgetField`, `chatTemplateKwargs` and the rest.
+    - **Defaults.** Without settings, a custom endpoint is assumed to have a 32k window and an 8k output limit. They used to be 128k and 16k.
+    - **Where to set them.** `nylo configure` asks for the window and output limit. Studio's Model Settings shows all four fields.
+  - **Storage.**
+    - Model effects no longer journal the model request next to the call, so each call's prompt is stored once.
+    - When a turn ends, its model effects are slimmed to their identity and status; the transcript holds the answers.
+    - Session storage now grows with the window, not with the square of the session's length.
+  - **Core.**
+    - `TranscriptEntry` adds `compaction` (`TranscriptCompactionEntry`).
+    - `ModelAdapterContext.compaction` marks a summary call.
+    - `CustomModelSettings` / `CustomModelSettingsSchema` describe the custom endpoint settings.
+
+- 50d0fb5: **Subject tokens: a person's own credential for the Runtime.** An app server mints a short-lived token for one signed-in person, and their app calls the Runtime directly (optional Host feature `subject-tokens`). Requests with application keys and subject headers are unchanged.
+
+  - **Runtime.** `POST /v1/tokens` (application key only) mints an ES256 JWT for a subject and a role, valid 60–900 seconds. The Tenant API accepts it as a bearer and resolves its scopes and agents from the role on every request. Forged, foreign or malformed tokens get the opaque `404`; an expired token, a revoked subject, a revoked key or a removed role gets `401 token_expired` with `WWW-Authenticate`. Tokens carry only `agents:read`, `sessions:own` and `vaults:own`; they may not set session `info`, send `message.manifest` or store OAuth refresh credentials, and `GET /v1/agents` shows them `{ agentId, name, description }` of their role's agents only.
+  - **Access policy.** `GET`/`PUT /v1/access/policy`: roles with token scopes, an agent allowlist and limits (`turnsPerHour`, `concurrentTurns`, answered with `429 limit_exceeded` and `Retry-After`). Without roles nothing is minted.
+  - **Signing keys.** Per Tenant, the private key sealed with the vault KEK: `GET /v1/access/signing-keys`, `POST …/rotate` (refused while the previous key may still verify live tokens; `force` for incidents), `POST …/:kid/revoke`, `GET /v1/access/jwks`. A Tenant with signing keys and no KEK is quarantined `kek-missing`.
+  - **Revocation.** `POST /v1/access/revocations` ends a subject's tokens; their open event streams end with `event: nylorun.closed` on every process. A stream opened with a token also ends when the token expires.
+  - Postgres migration 3 adds `signing_keys`, `subject_epochs`, `subject_usage` and an index on the session owner and status. New error codes `token_expired` and `limit_exceeded`.
+  - **Agents SDK.** `client.tokens.create()`, `client.access.getPolicy()`/`putPolicy()`/`revokeSubject()`/`jwks()` and `client.access.signingKeys.list()`/`rotate()`/`revoke()`, each checking the Host feature first.
+  - **CLI.** `nylo access policy get|set|init`, `nylo access signing-keys list|rotate|revoke`, `nylo access revoke <subject>` and `nylo access token` for trying the API.
+
+### Patch Changes
+
+- f39b79f: **`nylo doctor sandbox` shows the Tenant's default sandbox**: `none`, `virtual`, or a Tenant sandbox that sessions naming no sandbox get.
+- 6ab4c59: **Model calls don't strand sessions.** A model provider failure is now a known outcome, not a lost call. The Runtime retries what can be retried, and otherwise fails the turn with `model.<code>`, so the session accepts the next message instead of sitting `uncertain` until it is cancelled.
+
+  - **Runtime.**
+
+    - **Upgrade.** The model adapter moves to pi-ai 0.99.1 and always streams.
+    - **Per-call settings.**
+      - Every call carries the session id, so OpenAI and other providers reuse the prompt cache and route to the same backend.
+      - Provider auth no longer reads the process environment.
+      - Rate limits, overloads, timeouts and transient errors are retried: 3 attempts with backoff, honouring `Retry-After`.
+      - A stream that produces nothing for 300 s is aborted and retried. `TenantConfig.modelCall` sets attempts, backoff, the idle timeout and the request timeout.
+    - **Failures.** Anything else fails the turn with one of these codes:
+
+      - `model.context_overflow`, `model.rate_limited`, `model.overloaded`, `model.timeout`, `model.transient`
+      - `model.content_policy`, `model.auth` (whose message says where to fix the credential)
+      - `model.invalid_request`, `model.invalid_output`
+
+      Only a call whose outcome was lost, such as a Worker dying mid-call, is still `uncertain`.
+
+    - **Structured output.** A structured final answer is repaired (control characters, a Markdown code fence) before it is parsed.
+    - **Model history.** Replayed history keeps the model that produced each message, so a model switch no longer sends one model's signatures or tool-call ids to another. Reasoning from OpenAI-compatible servers (`reasoning_content`, `reasoning`) is sent back only within the turn that produced it.
+
+  - **Events.**
+    - `message.assistant` adds `model` (`provider`, `model`), `finishReason` and `usage`.
+    - A new `model.failed` transcript event (`code`, `message`, `retryable`) is written instead of `message.assistant` when a call fails.
+  - **Core and harness.**
+    - New types and helpers: `ModelFailureOutcome`, `ModelFailureCode`, `MODEL_FAILURE_CODES`, `isModelFailureOutcome`, `ModelProducer`.
+    - `PromptItem` assistant messages may carry `producer`.
+    - `ModelUsage` adds `cacheWriteTokens`.
+    - A model adapter may return a failure outcome.
+    - The durable engine version is `hosted-3`: a turn that is running when the Runtime is upgraded fails once with `execution.incompatible`, and the next message works.
+  - **CLI.**
+    - `nylo configure` passes a stable installation id to OAuth logins that need one (OpenAI "Sign in with ChatGPT"), stored as `cli-installation-id` in the Host root.
+    - A custom OpenAI-compatible provider now prompts for its API key instead of failing.
+
+- Pin agents to the tested release.
+- Pin admin to the tested release.
+- Updated dependencies [c7614a4]
+- Updated dependencies [5f23047]
+- Updated dependencies [4282d5f]
+- Updated dependencies [82d95ef]
+- Updated dependencies [e28b8a9]
+- Updated dependencies [50d0fb5]
+- Updated dependencies [50d0fb5]
+- Updated dependencies [c121144]
+- Updated dependencies [50d0fb5]
+- Updated dependencies [c121144]
+- Updated dependencies [9546ac7]
+- Updated dependencies [9d52189]
+- Updated dependencies [9d52189]
+- Updated dependencies [50d0fb5]
+- Updated dependencies
+- Updated dependencies
+  - @nylorun/agents@0.10.0-beta
+  - @nylorun/admin@0.6.0-beta
+
 ## 0.5.0-beta
 
 ### Minor Changes

package/README.md

@@ -69,11 +69,10 @@ created), it keeps that key as `.nylorun/credentials.<tenantId>.json`, so
 A **Project** stores only:
 
 - `.nylorun/link.json`: `{ format, hostUrl, hostId, tenantId }`
-- `.nylorun/credentials.json`: application key and principal id (0600), no
-  executor tokens
+- `.nylorun/credentials.json`: application key and principal id (0600)
 - `.nylorun/.gitignore` containing `*`
 
-`connectAgents` in `@nylorun/agents` reads the link (or the three variables),
+`createActionHandler` and `createClient` in `@nylorun/agents` read the link (or the three variables),
 so the project's `npm run dev` and `npm start` need no Nylorun tool.
 
 ```sh

package/dist/access/commands.d.ts

@@ -0,0 +1,24 @@
+import { type AgentsClient } from "@nylorun/agents";
+export declare const accessUsage = "nylo access <policy|keys|signing-keys|revoke|token>\n\n  policy get                         print the access policy\n  policy set <file>                  replace it with a JSON file\n  policy init                        write a starter \"user\" role (sessions:own agents:read, every agent,\n                                     60 turns per hour, 2 at once)\n  signing-keys list                  list the signing keys\n  signing-keys rotate [--force]      rotate; --force signs outstanding tokens out\n  signing-keys revoke <kid>          revoke a previous or standby key\n  keys list                          list the publishable keys\n  keys create --name <n> [--origin <o>]\u2026\n                                     a publishable key for a web page or an app\n                                     (origins: https://app.example.com or http://localhost:*)\n  keys set-origins <id> [<o>\u2026]       replace a key's origins ([] for native apps only)\n  keys revoke <id>                   revoke a publishable key\n  revoke <subject>                   end a subject's tokens and open streams\n  token --subject <s> --role <r> [--ttl <seconds>]\n                                     mint a subject token (for trying the API with curl)";
+/** The starter policy `policy init` writes. */
+export declare const STARTER_POLICY: {
+    version: 1;
+    roles: {
+        user: {
+            scopes: ("agents:read" | "sessions:own")[];
+            agents: "*";
+            limits: {
+                turnsPerHour: number;
+                concurrentTurns: number;
+            };
+        };
+    };
+    anon: {
+        scopes: never[];
+        agents: never[];
+    };
+    tokens: {
+        maxTtlSeconds: number;
+    };
+};
+export declare function accessCommand(input: readonly string[], client?: () => Promise<AgentsClient>): Promise<void>;

package/dist/access/commands.js

@@ -0,0 +1,148 @@
+/**
+ * `nylo access`: the linked Tenant's access policy, signing keys and revocations, and a
+ * development command that mints a subject token (Host feature `subject-tokens`). Uses the
+ * Project's application key, like every other Tenant command.
+ */
+import { readFile } from "node:fs/promises";
+import { createClient, resolveConnection, } from "@nylorun/agents";
+import { CliError } from "../errors.js";
+export const accessUsage = `nylo access <policy|keys|signing-keys|revoke|token>
+
+  policy get                         print the access policy
+  policy set <file>                  replace it with a JSON file
+  policy init                        write a starter "user" role (sessions:own agents:read, every agent,
+                                     60 turns per hour, 2 at once)
+  signing-keys list                  list the signing keys
+  signing-keys rotate [--force]      rotate; --force signs outstanding tokens out
+  signing-keys revoke <kid>          revoke a previous or standby key
+  keys list                          list the publishable keys
+  keys create --name <n> [--origin <o>]…
+                                     a publishable key for a web page or an app
+                                     (origins: https://app.example.com or http://localhost:*)
+  keys set-origins <id> [<o>…]       replace a key's origins ([] for native apps only)
+  keys revoke <id>                   revoke a publishable key
+  revoke <subject>                   end a subject's tokens and open streams
+  token --subject <s> --role <r> [--ttl <seconds>]
+                                     mint a subject token (for trying the API with curl)`;
+/** The starter policy `policy init` writes. */
+export const STARTER_POLICY = {
+    version: 1,
+    roles: {
+        user: {
+            scopes: ["sessions:own", "agents:read"],
+            agents: "*",
+            limits: { turnsPerHour: 60, concurrentTurns: 2 },
+        },
+    },
+    anon: { scopes: [], agents: [] },
+    tokens: { maxTtlSeconds: 600 },
+};
+const usageError = (message = accessUsage) => new CliError(message, 2);
+async function linkedClient() {
+    let connection;
+    try {
+        connection = await resolveConnection();
+    }
+    catch (error) {
+        throw new CliError(error instanceof Error ? error.message : String(error), 1);
+    }
+    return createClient({
+        url: connection.url,
+        key: connection.key,
+        tenant: connection.tenant,
+    });
+}
+const print = (value) => console.log(JSON.stringify(value, null, 2));
+function option(args, name) {
+    const index = args.indexOf(name);
+    if (index === -1)
+        return undefined;
+    const value = args[index + 1];
+    if (!value || value.startsWith("--"))
+        throw usageError(`${name} requires a value.`);
+    args.splice(index, 2);
+    return value;
+}
+export async function accessCommand(input, client = linkedClient) {
+    const [topic, action, ...rest] = input;
+    const args = [...rest];
+    if (topic === "policy") {
+        if (action === "get" && args.length === 0)
+            return print(await (await client()).access.getPolicy());
+        if (action === "init" && args.length === 0)
+            return print(await (await client()).access.putPolicy(STARTER_POLICY));
+        if (action === "set" && args.length === 1) {
+            let parsed;
+            try {
+                parsed = JSON.parse(await readFile(args[0], "utf8"));
+            }
+            catch (error) {
+                throw new CliError(`Could not read ${args[0]}: ${error instanceof Error ? error.message : String(error)}`, 1);
+            }
+            // Accept the file as the policy itself or as `{ policy }`, as `policy get` prints it.
+            const candidate = parsed && typeof parsed === "object" && "policy" in parsed
+                ? parsed.policy
+                : parsed;
+            // The Runtime validates it and names what is wrong.
+            return print(await (await client()).access.putPolicy(candidate));
+        }
+        throw usageError();
+    }
+    if (topic === "signing-keys") {
+        const keys = async () => (await client()).access.signingKeys;
+        if (action === "list" && args.length === 0)
+            return print(await (await keys()).list());
+        if (action === "rotate") {
+            const force = args[0] === "--force";
+            if (args.length > (force ? 1 : 0))
+                throw usageError();
+            return print(await (await keys()).rotate({ force }));
+        }
+        if (action === "revoke" && args.length === 1)
+            return print(await (await keys()).revoke(args[0]));
+        throw usageError();
+    }
+    if (topic === "keys") {
+        const keys = async () => (await client()).access.publishableKeys;
+        if (action === "list" && args.length === 0)
+            return print(await (await keys()).list());
+        if (action === "create") {
+            const name = option(args, "--name");
+            const origins = [];
+            for (let origin = option(args, "--origin"); origin; origin = option(args, "--origin"))
+                origins.push(origin);
+            if (!name || args.length > 0)
+                throw usageError();
+            return print(await (await keys()).create({ name, origins }));
+        }
+        if (action === "set-origins" && args.length >= 1) {
+            const [keyId, ...origins] = args;
+            return print(await (await keys()).update(keyId, { origins }));
+        }
+        if (action === "revoke" && args.length === 1)
+            return print(await (await keys()).revoke(args[0]));
+        throw usageError();
+    }
+    if (topic === "revoke") {
+        if (!action || args.length > 0)
+            throw usageError();
+        return print(await (await client()).access.revokeSubject(action));
+    }
+    if (topic === "token") {
+        const all = [action, ...args].filter((arg) => arg !== undefined);
+        const subject = option(all, "--subject");
+        const role = option(all, "--role");
+        const ttl = option(all, "--ttl");
+        if (!subject || !role || all.length > 0)
+            throw usageError();
+        const ttlSeconds = ttl === undefined ? undefined : Number(ttl);
+        if (ttlSeconds !== undefined && !Number.isInteger(ttlSeconds))
+            throw usageError("--ttl must be a whole number of seconds.");
+        return print(await (await client()).tokens.create({
+            subject,
+            role,
+            ...(ttlSeconds === undefined ? {} : { ttlSeconds }),
+        }));
+    }
+    throw usageError();
+}

package/dist/cli.js

@@ -8,12 +8,18 @@ import { printLinkedEnvExports } from "./project/env.js";
 import { readLink as readProjectLink } from "./project/link.js";
 import { readCredentials as readProjectCredentials } from "./project/credentials.js";
 import { tenantCommand } from "./tenant/commands.js";
-const usage = `nylo <tenant|configure|env|doctor>
+import { accessCommand } from "./access/commands.js";
+const usage = `nylo <tenant|access|configure|env|doctor>
 
 Runtime client (the local stack's Runtime, or any Runtime by URL and key):
   tenant create [name]                    create a Tenant; in a Project, link it and seed it from .env
   tenant use <name-or-id>                 link this Project to a Tenant, e.g. one created in Studio
   tenant current|list [--json]|status [--json]|reset|delete
+  access policy get|set <file>|init       the access policy for subject tokens (nylo access --help)
+  access keys list|create|set-origins|revoke  publishable keys for web pages and apps
+  access signing-keys list|rotate|revoke  the Tenant's token signing keys
+  access revoke <subject>                 end a subject's tokens and open streams
+  access token --subject <s> --role <r>   mint a subject token for trying the API
   configure                               set the linked Tenant's model provider
   env                                     print the linked Project's NYLORUN_* variables as exports
   doctor sandbox [--json]                 show which sandbox backend this Tenant's Host offers
@@ -85,6 +91,13 @@ async function main() {
         throw new CliError("Nylorun does not run on native Windows. Use WSL2: install Node 24 and Docker (Docker Desktop's WSL integration) inside your WSL distribution and run nylorun there (https://learn.microsoft.com/windows/wsl/install).", 1);
     if (command === "tenant")
         return await tenantCommand(args);
+    if (command === "access") {
+        if (args[0] === "--help" || args[0] === "-h" || args.length === 0) {
+            const { accessUsage } = await import("./access/commands.js");
+            return void console.log(accessUsage);
+        }
+        return await accessCommand(args);
+    }
     if (command === "env") {
         if (args.length)
             throw usageError("Usage: nylo env");

package/dist/doctor.d.ts

@@ -11,6 +11,13 @@ export type SandboxReport = {
         version?: string;
     }[];
     defaultImage?: string;
+    /** The Tenant's sandbox configuration (Runtimes with Sandboxes v3). */
+    config?: {
+        default: "none" | "virtual" | Record<string, unknown>;
+        limits?: {
+            network?: readonly string[];
+        };
+    };
 };
 /** `nylo doctor sandbox`: Tenant sandbox report via the Tenant API (F2-4). */
 export declare function doctorSandbox(options: {

package/dist/doctor.js

@@ -45,6 +45,15 @@ export async function doctorSandbox(options) {
             ? "auto (seed Tenant sandbox.backend via nylo tenant create / .env NYLORUN_SANDBOX)"
             : report.preference,
     ]);
+    if (report.config)
+        rows.push([
+            "default",
+            report.config.default === "none"
+                ? "none: sessions get a sandbox only when opened with one (set a default with PUT /v1/tenant/sandbox)"
+                : report.config.default === "virtual"
+                    ? "virtual: sessions that name no sandbox get one"
+                    : "a Tenant sandbox: sessions that name no sandbox get it",
+        ]);
     rows.push([
         "selected",
         report.backend

package/dist/model/configure.d.ts

@@ -9,6 +9,11 @@ export type PromptedModel = {
     provider: string;
     model: string;
     baseUrl?: string;
+    /** A custom endpoint's context window and output limit, when given. */
+    settings?: {
+        contextWindow?: number;
+        maxTokens?: number;
+    };
     auth: Credential;
 };
 export type ModelCatalog = {
@@ -46,4 +51,11 @@ export declare function configureProvider(options?: {
     output?: Writable;
     /** Tenant API catalog from GET /v1/tenant/models. */
     catalog?: ModelCatalog;
+    /** This installation's stable id, for OAuth flows that need one (OpenAI). */
+    deviceId?: () => string;
 }): Promise<PromptedModel>;
+/**
+ * A stable id for this CLI installation, created on first use under the Host root.
+ * OpenAI's "Sign in with ChatGPT" sends it as the agent host id.
+ */
+export declare function installationId(home?: string): string;

package/dist/model/configure.js

@@ -1,7 +1,11 @@
 import { createInterface } from "node:readline/promises";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { builtinModels } from "@earendil-works/pi-ai/providers/all";
 import { createProvider, } from "@earendil-works/pi-ai";
 import { stream, streamSimple, } from "@earendil-works/pi-ai/api/openai-completions";
+import { resolveHome } from "../home.js";
 export class ConfigurationCancelled extends Error {
     signal;
     exitCode;
@@ -36,8 +40,14 @@ function modelsFor(selection, credentials, catalog) {
             baseUrl: selection.custom.baseUrl,
             auth: {
                 apiKey: {
-                    label: "Custom API key",
-                    schemas: [],
+                    name: "Custom API key",
+                    async login(interaction) {
+                        const key = await interaction.prompt({
+                            type: "secret",
+                            message: "API key",
+                        });
+                        return { type: "api_key", key: key.trim() };
+                    },
                     async resolve() {
                         const credential = await credentials.read("custom");
                         if (!credential || credential.type !== "api_key")
@@ -119,6 +129,7 @@ export async function fetchModelCatalog(options) {
 }
 // Internal options also allow isolated prompt tests without changing process globals.
 export async function configureProvider(options = {}) {
+    const login = { getDeviceId: options.deviceId ?? installationId };
     const output = options.output ?? process.stdout;
     const controller = new AbortController();
     const signal = controller.signal;
@@ -161,6 +172,16 @@ export async function configureProvider(options = {}) {
         signal.throwIfAborted();
         return prompt.question(message, { signal });
     }
+    /** A positive whole number of tokens, or undefined for the default. */
+    async function tokens(message) {
+        const answer = (await question(message)).trim();
+        if (!answer)
+            return undefined;
+        const value = Number(answer);
+        if (!Number.isInteger(value) || value < 1)
+            throw new Error(`${message.split(" (")[0]} must be a whole number of tokens.`);
+        return value;
+    }
     try {
         signal.throwIfAborted();
         output.write("0. Custom OpenAI-compatible provider\n");
@@ -173,6 +194,12 @@ export async function configureProvider(options = {}) {
             const model = (await question("Model id: ")).trim();
             if (!baseUrl || !model)
                 throw new Error("A base URL and model id are required.");
+            const contextWindow = await tokens("Context window in tokens (Enter for 32768): ");
+            const maxTokens = await tokens("Max output tokens (Enter for 8192): ");
+            const settings = {
+                ...(contextWindow ? { contextWindow } : {}),
+                ...(maxTokens ? { maxTokens } : {}),
+            };
             const selection = {
                 provider: "custom",
                 model,
@@ -180,8 +207,11 @@ export async function configureProvider(options = {}) {
             };
             const custom = modelsFor(selection, store, options.catalog);
             if (!(await custom.models.checkAuth("custom", { signal })))
-                await custom.models.login("custom", "api_key", interaction());
-            return prompted(selection);
+                await custom.models.login("custom", "api_key", interaction(), login);
+            return {
+                ...prompted(selection),
+                ...(Object.keys(settings).length ? { settings } : {}),
+            };
         }
         else {
             const chosen = providers[choice - 1];
@@ -203,7 +233,7 @@ export async function configureProvider(options = {}) {
                     if (answer === "2")
                         method = "oauth";
                 }
-                await registry.models.login(chosen.id, method, interaction());
+                await registry.models.login(chosen.id, method, interaction(), login);
             }
             return prompted({ provider: chosen.id, model: model.id });
         }
@@ -256,3 +286,22 @@ export async function configureProvider(options = {}) {
         };
     }
 }
+/**
+ * A stable id for this CLI installation, created on first use under the Host root.
+ * OpenAI's "Sign in with ChatGPT" sends it as the agent host id.
+ */
+export function installationId(home = resolveHome()) {
+    const file = join(home, "cli-installation-id");
+    try {
+        const existing = readFileSync(file, "utf8").trim();
+        if (existing)
+            return existing;
+    }
+    catch {
+        /* Created below on first use. */
+    }
+    const id = randomUUID();
+    mkdirSync(home, { recursive: true });
+    writeFileSync(file, `${id}\n`, { mode: 0o600 });
+    return id;
+}

package/dist/model/host-model.d.ts

@@ -8,6 +8,10 @@ type HostModelView = {
     readonly model: string;
     readonly authType: "api_key" | "oauth";
     readonly baseUrl?: string;
+    readonly settings?: {
+        contextWindow?: number;
+        maxTokens?: number;
+    };
 };
 export declare function getHostModel(runtimeUrl: string, serverKey: string, tenantId?: string): Promise<HostModelView>;
 export declare function putHostModel(runtimeUrl: string, serverKey: string, model: PromptedModel, tenantId?: string): Promise<HostModelView>;

package/dist/model/host-model.js

@@ -41,6 +41,7 @@ export async function putHostModel(runtimeUrl, serverKey, model, tenantId) {
             provider: model.provider,
             model: model.model,
             ...(model.baseUrl ? { baseUrl: model.baseUrl } : {}),
+            ...(model.settings ? { settings: model.settings } : {}),
             auth: model.auth,
         }),
     });

package/dist/project/credentials.d.ts

@@ -1,13 +1,11 @@
 /**
- * Project-local credentials (mode 0600). Format 1 drops `executors`.
- * Format 0 may still contain an executors map; readers ignore it (D§3.7).
+ * Project-local credentials (mode 0600): the application key and its principal. A format 0
+ * file may still carry a legacy `executors` map from before protocol 3; it is ignored.
  */
 export interface ProjectCredentials {
     format: 0 | 1;
     applicationKey: string;
     principalId: string;
-    /** Present only on format 0 files; ignored by version 1. */
-    executors?: Record<string, string>;
 }
 /** The Project's credentials, or with `tenantId` the key kept for that Tenant. */
 export declare function readCredentials(projectRoot: string, tenantId?: string): Promise<ProjectCredentials | undefined>;

package/dist/project/credentials.js

@@ -22,17 +22,10 @@ export async function readCredentials(projectRoot, tenantId) {
             throw new CliError(`Project credentials at ${path} have an unsupported format. Upgrade the CLI.`, 1);
         }
         await chmod(path, 0o600);
-        const executors = format === 0 &&
-            value.executors &&
-            typeof value.executors === "object" &&
-            !Array.isArray(value.executors)
-            ? value.executors
-            : undefined;
         return {
             format,
             applicationKey: value.applicationKey,
             principalId: value.principalId,
-            ...(executors ? { executors } : {}),
         };
     }
     catch (error) {
@@ -45,7 +38,7 @@ export async function writeCredentials(projectRoot, credentials, tenantId) {
     await ensureProjectNylorunDir(projectRoot);
     const path = credentialsPath(projectRoot, tenantId);
     const temporary = `${path}.${randomUUID()}.tmp`;
-    // Version 1 writes format 1 without executors (D§3.7).
+    // Version 1 writes format 1 with only the application key and principal (D§3.7).
     const body = `${JSON.stringify({
         format: credentials.format ?? 1,
         applicationKey: credentials.applicationKey,

package/dist/tenant/commands.d.ts

@@ -2,3 +2,17 @@ import { type AdminTenant } from "@nylorun/admin";
 /** Exact-and-unique name or id match. */
 export declare function matchTenant(tenants: readonly AdminTenant[], nameOrId: string): AdminTenant;
 export declare function tenantCommand(args: readonly string[]): Promise<void>;
+/** One line of `nylo tenant endpoints`: the agent, its URL and version, and how it is doing. */
+export declare function endpointLine(endpoint: {
+    agentId: string;
+    url: string;
+    implementationVersion: string;
+    health: {
+        consecutiveFailures: number;
+        lastSuccessAt?: string;
+        lastError?: {
+            code: string;
+            message: string;
+        };
+    };
+}): string;

package/dist/tenant/commands.js

@@ -83,7 +83,7 @@ async function createTenant(options) {
 export async function tenantCommand(args) {
     const [verb, ...rest] = args;
     if (!verb || verb === "--help" || verb === "-h") {
-        console.log(`nylo tenant create [name]|current|list [--json]|use <name-or-id>|status [--json]|reset [--sessions|--sandboxes|--all] [--yes]|delete <name-or-id> [--yes]`);
+        console.log(`nylo tenant create [name]|current|list [--json]|use <name-or-id>|status [--json]|endpoints [--json]|endpoints ping <agent>|reset [--sessions|--sandboxes|--all] [--yes]|delete <name-or-id> [--yes]`);
         return;
     }
     const home = resolveHome();
@@ -143,7 +143,7 @@ export async function tenantCommand(args) {
         }
         const tenants = await admin.listTenants();
         const selected = matchTenant(tenants, nameOrId);
-        console.warn("Sharing a Tenant shares executor registrations across Projects that link to it.");
+        console.warn("Sharing a Tenant shares Action endpoint registrations across Projects that link to it.");
         const authorizes = async (key) => {
             try {
                 await createClient({ url: admin.url, key, tenant: selected.id }).transport.json("/v1/tenant", "GET");
@@ -192,6 +192,10 @@ export async function tenantCommand(args) {
         console.log(`Linked to ${selected.name ?? selected.id}  ${selected.id}`);
         return;
     }
+    if (verb === "endpoints") {
+        await endpointsCommand(rest);
+        return;
+    }
     if (verb === "status") {
         const json = rest.includes("--json");
         if (rest.some((a) => a !== "--json")) {
@@ -343,3 +347,48 @@ async function confirmOrThrow(prompt) {
         rl.close();
     }
 }
+/** The Project's application client, from its link and credentials. */
+async function projectClient() {
+    const root = requireProjectRoot();
+    const link = await readLink(root);
+    const credentials = await readCredentials(root);
+    if (!link || !credentials)
+        throw new CliError("No Project link. Run nylo tenant create to create one.", 1);
+    return createClient({ url: link.hostUrl, key: credentials.applicationKey, tenant: link.tenantId });
+}
+/** `nylo tenant endpoints [--json]` and `nylo tenant endpoints ping <agent>`. */
+async function endpointsCommand(args) {
+    const client = await projectClient();
+    if (args[0] === "ping") {
+        const agentId = args[1];
+        if (!agentId || args.length > 2)
+            throw new CliError("Usage: nylo tenant endpoints ping <agent>", 2);
+        const answer = await client.transport.json(`/v1/endpoints/${encodeURIComponent(agentId)}/ping`, "POST");
+        console.log(`${answer.agentId}  serves ${answer.implementationVersion}${answer.manifestHash ? `  ${answer.manifestHash}` : ""}`);
+        return;
+    }
+    const json = args.includes("--json");
+    if (args.some((a) => a !== "--json"))
+        throw new CliError("Usage: nylo tenant endpoints [--json] | nylo tenant endpoints ping <agent>", 2);
+    const body = await client.transport.json("/v1/endpoints", "GET");
+    if (json) {
+        console.log(JSON.stringify(body, null, 2));
+        return;
+    }
+    if (body.endpoints.length === 0) {
+        console.log("No Action endpoints. Register one with createActionHandler(...).register({ url }).");
+        return;
+    }
+    for (const endpoint of body.endpoints)
+        console.log(endpointLine(endpoint));
+}
+/** One line of `nylo tenant endpoints`: the agent, its URL and version, and how it is doing. */
+export function endpointLine(endpoint) {
+    const { health } = endpoint;
+    const state = health.consecutiveFailures > 0
+        ? `failing (${health.consecutiveFailures}): ${health.lastError?.message || health.lastError?.code || "unknown"}`
+        : health.lastSuccessAt
+            ? `ok (last ${health.lastSuccessAt})`
+            : "no deliveries yet";
+    return `${endpoint.agentId}  ${endpoint.url}  ${endpoint.implementationVersion}  ${state}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/cli",
-  "version": "0.5.0-beta",
+  "version": "0.6.0-beta",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Nylorun Runtime client: Tenants, Project links and model providers",
@@ -30,9 +30,9 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@nylorun/agents": "0.9.0-beta",
-    "@nylorun/admin": "0.5.0-beta",
-    "@earendil-works/pi-ai": "0.87.0"
+    "@nylorun/agents": "0.10.0-beta",
+    "@nylorun/admin": "0.6.0-beta",
+    "@earendil-works/pi-ai": "0.99.1"
   },
   "devDependencies": {
     "typescript": "npm:@typescript/typescript6@^6.0.2",