@nylorun/agents 0.13.0-beta → 0.14.0-beta

package/dist/http.js

@@ -1,4 +1,4 @@
-import { PROTOCOL_FEATURES, PROTOCOL_HEADER, PROTOCOL_VERSION, PUBLISHABLE_KEY_HEADER, checkCompatibility, } from "@nylorun/core/compatibility";
+import { PROTOCOL_FEATURES, PROTOCOL_HEADER, PROTOCOL_VERSION, checkCompatibility, } from "@nylorun/core/compatibility";
 export function env(name) {
     return typeof process !== "undefined" ? process.env[name] : undefined;
 }
@@ -54,10 +54,9 @@ function parseProtocolRange(value) {
 }
 export class Transport {
     url;
-    /** The Tenant key; empty for a client that uses subject tokens. */
+    /** The Tenant key; empty for a client that uses issuer tokens. */
     key;
     token;
-    publishableKey;
     fetcher;
     /** Sent on every request, e.g. `Nylorun-Subject` and `Nylorun-Scopes` (`withHeaders`). */
     headers = {};
@@ -69,14 +68,13 @@ export class Transport {
         if (!url || (!token && !key))
             throw new Error("Set Runtime url and server key explicitly or via NYLORUN_RUNTIME_URL / NYLORUN_SERVER_KEY");
         if (token && options.key)
-            throw new Error("Use a Tenant key or subject tokens, not both");
+            throw new Error("Use a Tenant key or issuer tokens, not both");
         const parsed = new URL(url);
         if (!["http:", "https:"].includes(parsed.protocol))
             throw new Error("Runtime requires an HTTP(S) URL");
         this.url = url.replace(/\/$/, "");
         this.key = key;
         this.token = token;
-        this.publishableKey = options.publishableKey;
         // Browsers may not call `/health` (it refuses `Origin`); token clients rely on `426`.
         if (token)
             this.check.compatible = true;
@@ -165,8 +163,6 @@ export class Transport {
             ? await this.token.get(init.signal ?? undefined)
             : this.key;
         headers.set("Authorization", `Bearer ${bearer}`);
-        if (this.publishableKey)
-            headers.set(PUBLISHABLE_KEY_HEADER, this.publishableKey);
         headers.set(PROTOCOL_HEADER, String(PROTOCOL_VERSION));
         // JSON unless the caller says otherwise (an artifact upload sends the file's type).
         if (init.body && !headers.has("content-type"))
@@ -180,7 +176,7 @@ export class Transport {
             headers: await this.authHeaders(init),
             redirect: "error",
         });
-        // An expired or revoked subject token: get a new one and try once more.
+        // An expired token: get a new one and try once more.
         if (response.status === 401 && this.token && !options.retried401) {
             const body = (await response.clone().json().catch(() => undefined));
             if (body?.code === "token_expired") {

package/dist/index.d.ts

@@ -11,10 +11,7 @@ export { ArtifactsClient } from "./artifacts.js";
 export type { ArtifactBody, ArtifactLinkWithUrl, UploadArtifactOptions, } from "./artifacts.js";
 export type { ActAsOptions, AgentSource, SessionView, CommandOptions, CreateSessionOptions, SessionSandbox, ForSessionOptions, SandboxSpec, SessionSandboxHandle, } from "./client.js";
 export { SandboxesClient } from "./client.js";
-export { AccessClient, PublishableKeysClient, SigningKeysClient, TokensClient, } from "./access.js";
-export type { CreateTokenOptions } from "./access.js";
-export { createTokenEndpoint } from "./token-endpoint.js";
-export type { TokenEndpointOptions } from "./token-endpoint.js";
+export { AccessClient, SigningKeysClient } from "./access.js";
 export { createActionHandler } from "./action-handler.js";
 export type { ActionHandler, ActionHandlerOptions, RegisterOptions, } from "./action-handler.js";
 export type { ExecuteActionOptions, ExecutableDefinition, } from "./execute-action.js";

package/dist/index.js

@@ -6,8 +6,7 @@ export { SUBJECT_SCOPES } from "@nylorun/core/contracts";
 export { AgentsClient, SessionClient, createClient } from "./client.js";
 export { ArtifactsClient } from "./artifacts.js";
 export { SandboxesClient } from "./client.js";
-export { AccessClient, PublishableKeysClient, SigningKeysClient, TokensClient, } from "./access.js";
-export { createTokenEndpoint } from "./token-endpoint.js";
+export { AccessClient, SigningKeysClient } from "./access.js";
 export { createActionHandler } from "./action-handler.js";
 export { resolveConnection, ConnectionError } from "./connection.js";
 export { RuntimeError, IncompatibleRuntimeError } from "./http.js";

package/dist/session-client.d.ts

@@ -1,11 +1,10 @@
 /**
- * The Tenant API client classes, with no Node-only imports so a browser bundle can load them
- * (`@nylorun/agents/browser`). `client.ts` adds `createClient`, which resolves the
- * connection from the environment or the Project link.
+ * The Tenant API client classes, with no Node-only imports. `client.ts` adds `createClient`,
+ * which resolves the connection from the environment or the Project link.
  */
 import type { AgentManifest, BuiltAgent, BuiltWorkflow, JsonValue, SandboxToolName, WorkflowManifest } from "@nylorun/core/define";
 import { type SubjectScope, type CredentialInfo, type CredentialSelection, type MessagePart, type SandboxRequest, type SessionCommand, type VaultInfo } from "@nylorun/core/contracts";
-import { AccessClient, TokensClient } from "./access.js";
+import { AccessClient } from "./access.js";
 import { SandboxesClient } from "./sandboxes.js";
 import { ArtifactsClient } from "./artifacts.js";
 import { Transport, type Destination } from "./http.js";
@@ -64,12 +63,7 @@ export declare class AgentsClient {
      * themselves and hold the key; nothing is minted, cached or refreshed.
      */
     as(subject: string, options?: ActAsOptions): AgentsClient;
-    /**
-     * Mints subject tokens for signed-in people (Host feature `subject-tokens`), so their
-     * browser or app calls the Runtime directly. Application key only.
-     */
-    get tokens(): TokensClient;
-    /** The access policy, signing keys and revocations (Host feature `subject-tokens`). */
+    /** The signing keys and the public keys that verify delivery tokens. Application key only. */
     get access(): AccessClient;
     /**
      * Sandboxes as a resource (Host feature `sandboxes`): `ensure` one by id, `list` them by
@@ -100,14 +94,25 @@ export declare class AgentsClient {
         requestId?: string;
     }): Promise<unknown>;
     createSession(options: CreateSessionOptions): Promise<SessionClient>;
+    /**
+     * Creates a vault: the installation's own (`scope: "installation"`), which any session may
+     * attach, or one person's (`ownerUserId`), which only that person's sessions attach. Vault
+     * routes take the application key acting for no one (protocol 7): not a client made with `as`.
+     */
     createVault(options: {
         name: string;
-        ownerUserId: string;
         metadata?: Record<string, string>;
         idempotencyKey: string;
         requestId?: string;
-    }): Promise<VaultInfo>;
-    listVaults(ownerUserId: string, signal?: AbortSignal): Promise<{
+    } & ({
+        scope: "installation";
+        ownerUserId?: undefined;
+    } | {
+        scope?: "user";
+        ownerUserId: string;
+    })): Promise<VaultInfo>;
+    /** The installation vaults, after the vaults of `ownerUserId` when it is given. */
+    listVaults(ownerUserId?: string, signal?: AbortSignal): Promise<{
         vaults: VaultInfo[];
     }>;
     getVault(vaultId: string, signal?: AbortSignal): Promise<VaultInfo>;
@@ -303,6 +308,6 @@ export declare class SessionClient {
 export { RuntimeError, IncompatibleRuntimeError } from "./http.js";
 export type { Destination, IncompatibleReason } from "./http.js";
 export type { LiveEvent } from "@nylorun/core/contracts";
-export { AccessClient, PublishableKeysClient, SigningKeysClient, TokensClient, } from "./access.js";
+export { AccessClient, SigningKeysClient } from "./access.js";
 export { SandboxesClient } from "./sandboxes.js";
 export type { ForSessionOptions, SandboxSpec, SessionSandboxHandle } from "./sandboxes.js";

package/dist/session-client.js

@@ -2,7 +2,7 @@ import { SANDBOX_TOOL_NAMES, delegateOf, isBuiltWorkflow, isSandboxToolName, } f
 import { z } from "zod";
 import { SCOPES_HEADER, SUBJECT_HEADER } from "@nylorun/core/compatibility";
 import { parseSessionEvent, parseSubjectHeaders, } from "@nylorun/core/contracts";
-import { AccessClient, TokensClient } from "./access.js";
+import { AccessClient } from "./access.js";
 import { SandboxesClient } from "./sandboxes.js";
 import { ArtifactsClient } from "./artifacts.js";
 import { Transport, id, segment } from "./http.js";
@@ -95,14 +95,7 @@ export class AgentsClient {
             subject,
         });
     }
-    /**
-     * Mints subject tokens for signed-in people (Host feature `subject-tokens`), so their
-     * browser or app calls the Runtime directly. Application key only.
-     */
-    get tokens() {
-        return new TokensClient(this.transport);
-    }
-    /** The access policy, signing keys and revocations (Host feature `subject-tokens`). */
+    /** The signing keys and the public keys that verify delivery tokens. Application key only. */
     get access() {
         return new AccessClient(this.transport);
     }
@@ -185,17 +178,27 @@ export class AgentsClient {
         });
         return this.session(sessionId);
     }
+    /**
+     * Creates a vault: the installation's own (`scope: "installation"`), which any session may
+     * attach, or one person's (`ownerUserId`), which only that person's sessions attach. Vault
+     * routes take the application key acting for no one (protocol 7): not a client made with `as`.
+     */
     createVault(options) {
         return this.transport.json("/v1/vaults", "POST", {
             requestId: options.requestId ?? id(),
             idempotencyKey: options.idempotencyKey,
             name: options.name,
-            ownerUserId: options.ownerUserId,
+            ...(options.scope === "installation"
+                ? { scope: "installation" }
+                : { ownerUserId: options.ownerUserId }),
             ...(options.metadata ? { metadata: options.metadata } : {}),
         });
     }
+    /** The installation vaults, after the vaults of `ownerUserId` when it is given. */
     listVaults(ownerUserId, signal) {
-        return this.transport.json(`/v1/vaults?ownerUserId=${encodeURIComponent(ownerUserId)}`, "GET", undefined, signal);
+        return this.transport.json(ownerUserId === undefined
+            ? "/v1/vaults"
+            : `/v1/vaults?ownerUserId=${encodeURIComponent(ownerUserId)}`, "GET", undefined, signal);
     }
     getVault(vaultId, signal) {
         return this.transport.json(`/v1/vaults/${segment(vaultId)}`, "GET", undefined, signal);
@@ -398,5 +401,5 @@ export class SessionClient {
     }
 }
 export { RuntimeError, IncompatibleRuntimeError } from "./http.js";
-export { AccessClient, PublishableKeysClient, SigningKeysClient, TokensClient, } from "./access.js";
+export { AccessClient, SigningKeysClient } from "./access.js";
 export { SandboxesClient } from "./sandboxes.js";

package/dist/sse.js

@@ -65,7 +65,7 @@ export async function* observeSSE(transport, path, options = {}) {
     const signal = options.signal ?? controller.signal;
     let cursor = options.cursor;
     let retry = 250;
-    // The Runtime ended the stream because its subject token expired or was revoked: reconnect
+    // The Runtime ended the stream because its token expired: reconnect
     // at once (the transport fetches a new token), but only once in a row.
     let closedByRuntime = 0;
     while (!signal.aborted) {

package/dist/studio-embed.d.ts

@@ -1,6 +1,6 @@
 /**
  * `@nylorun/agents/studio-embed`: the contract between Studio and an app that embeds it in an
- * iframe (Studio design §8). Studio's web app and embedders such as Babai import it from here,
+ * iframe (Studio design §8). Studio's web app and the apps that embed it import it from here,
  * because Studio may not depend on `@nylorun/core` directly.
  *
  * No Node-only module is imported here or below.

package/dist/studio-embed.js

@@ -1,6 +1,6 @@
 /**
  * `@nylorun/agents/studio-embed`: the contract between Studio and an app that embeds it in an
- * iframe (Studio design §8). Studio's web app and embedders such as Babai import it from here,
+ * iframe (Studio design §8). Studio's web app and the apps that embed it import it from here,
  * because Studio may not depend on `@nylorun/core` directly.
  *
  * No Node-only module is imported here or below.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nylorun/agents",
-  "version": "0.13.0-beta",
+  "version": "0.14.0-beta",
   "description": "Nylorun agent definitions, session client and Action endpoint",
   "type": "module",
   "license": "Apache-2.0",
@@ -28,10 +28,6 @@
       "types": "./dist/ag-ui/index.d.ts",
       "import": "./dist/ag-ui/index.js"
     },
-    "./browser": {
-      "types": "./dist/browser.d.ts",
-      "import": "./dist/browser.js"
-    },
     "./a2a": {
       "types": "./dist/a2a/index.d.ts",
       "import": "./dist/a2a/index.js"
@@ -47,7 +43,7 @@
     "test": "vitest run --passWithNoTests"
   },
   "dependencies": {
-    "@nylorun/core": "0.12.0-beta",
+    "@nylorun/core": "0.13.0-beta",
     "gray-matter": "^4.0.3"
   },
   "peerDependencies": {

package/dist/browser.d.ts

@@ -1,104 +0,0 @@
-import type { CredentialSelection, VaultInfo } from "@nylorun/core/contracts";
-import type { TokenSource } from "./http.js";
-import { AgentsClient, type SessionClient } from "./session-client.js";
-import type { ArtifactsClient } from "./artifacts.js";
-/** What the token callback returns: the token, or the app server's `{ token, expiresAt }`. */
-export type TokenReply = string | {
-    token: string;
-    expiresAt?: string;
-};
-export interface BrowserClientOptions {
-    /** The Runtime's URL, as the page reaches it. */
-    url: string;
-    /** The Tenant's publishable key for this app (`nr_pub_…`). */
-    publishableKey: string;
-    /** Returns a subject token for the signed-in person, usually from your app server. */
-    token(signal?: AbortSignal): Promise<TokenReply>;
-    fetch?: typeof fetch;
-}
-interface Claims {
-    sub?: string;
-    exp?: number;
-}
-/** The token's claims, read without verifying (the Runtime verifies). */
-export declare function readClaims(token: string): Claims;
-/** A token kept in memory, fetched on demand, one fetch at a time. */
-export declare class CachedToken implements TokenSource {
-    private readonly fetchToken;
-    private readonly now;
-    private current;
-    private pending;
-    constructor(fetchToken: (signal?: AbortSignal) => Promise<TokenReply>, now?: () => number);
-    get(signal?: AbortSignal): Promise<string>;
-    invalidate(): void;
-    /** The subject of the current token, fetching one if needed. */
-    subject(signal?: AbortSignal): Promise<string>;
-}
-/** The signed-in person's view of the Runtime: their sessions and vaults, the agents they may use. */
-export declare class BrowserClient {
-    /** The underlying Tenant API client, for anything this class does not wrap. */
-    readonly client: AgentsClient;
-    readonly url: string;
-    readonly publishableKey: string;
-    private readonly tokens;
-    private readonly fetcher;
-    constructor(options: BrowserClientOptions);
-    /** The person the tokens are for. */
-    subject(signal?: AbortSignal): Promise<string>;
-    /** A current token, e.g. for a request this client does not make itself. */
-    token(signal?: AbortSignal): Promise<string>;
-    /** The agents the person may use: id, name and description. */
-    listAgents(signal?: AbortSignal): Promise<{
-        agents: {
-            agentId: string;
-            name?: string;
-            description?: string;
-        }[];
-    }>;
-    listSessions(agentId?: string, signal?: AbortSignal): Promise<{
-        sessions: import("./session-client.js").SessionView[];
-    }>;
-    session(sessionId: string): SessionClient;
-    /** The person's file artifacts, in their own sessions (protocol 6). */
-    get artifacts(): ArtifactsClient;
-    /** A session of the person's own; the owner is always the token's subject. */
-    createSession(options: {
-        id?: string;
-        agentId: string;
-        vaultIds?: readonly string[];
-        credentialSelections?: readonly CredentialSelection[];
-        /** A sandbox the token's `sandboxes` grants reach (Host feature `sandboxes`). */
-        sandbox?: {
-            id: string;
-        };
-    }): Promise<SessionClient>;
-    createVault(options: {
-        name: string;
-        idempotencyKey: string;
-        metadata?: Record<string, string>;
-    }): Promise<VaultInfo>;
-    listVaults(signal?: AbortSignal): Promise<{
-        vaults: VaultInfo[];
-    }>;
-    /** `fetch` with this client's credentials, retrying once after `401 token_expired`. */
-    private send;
-    /**
-     * For `@ag-ui/client`'s `HttpAgent`: `new HttpAgent({ url, fetch })`. The `fetch` adds the
-     * publishable key and a current token, and when the Runtime ends a run's stream because the
-     * token expired or was revoked, it reattaches with a new token from the last event, so the
-     * agent sees one run.
-     */
-    agUi(agentId: string): {
-        url: string;
-        fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-    };
-    /** The thread's messages, for `HttpAgent`'s `initialMessages`. */
-    agUiHistory(agentId: string, threadId: string, signal?: AbortSignal): Promise<unknown[]>;
-    /**
-     * Passes a run's frames through; on `nylorun.stream_closed` before the run finished, fetches
-     * the rest from the last event id and continues without repeating `RUN_STARTED`.
-     */
-    private stitch;
-}
-export declare function createBrowserClient(options: BrowserClientOptions): BrowserClient;
-export {};

package/dist/browser.js

@@ -1,281 +0,0 @@
-/**
- * `@nylorun/agents/browser`: a Runtime client for browsers and apps that hold no Tenant key
- * (Host features `subject-tokens` and `browser-access`). The page ships a publishable key; the
- * app server's token route returns a subject token for the signed-in person; the client keeps
- * it in memory, fetches a new one a minute before it expires or when the Runtime answers
- * `401 token_expired`, and never asks for two at once.
- *
- * No Node-only module is imported here or below.
- */
-import { PROTOCOL_HEADER, PROTOCOL_VERSION, PUBLISHABLE_KEY_HEADER, } from "@nylorun/core/compatibility";
-import { AgentsClient } from "./session-client.js";
-/** Fetch a new token this long before the current one expires. */
-const REFRESH_EARLY_MS = 60_000;
-/** The token's claims, read without verifying (the Runtime verifies). */
-export function readClaims(token) {
-    const payload = token.split(".")[1];
-    if (!payload)
-        return {};
-    try {
-        const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
-        const padded = base64 + "=".repeat((4 - (base64.length % 4)) % 4);
-        const json = new TextDecoder().decode(Uint8Array.from(atob(padded), (c) => c.charCodeAt(0)));
-        return JSON.parse(json);
-    }
-    catch {
-        return {};
-    }
-}
-/** A token kept in memory, fetched on demand, one fetch at a time. */
-export class CachedToken {
-    fetchToken;
-    now;
-    current;
-    pending;
-    constructor(fetchToken, now = Date.now) {
-        this.fetchToken = fetchToken;
-        this.now = now;
-    }
-    get(signal) {
-        if (this.current && this.current.expiresAt - REFRESH_EARLY_MS > this.now())
-            return Promise.resolve(this.current.token);
-        this.pending ??= this.fetchToken(signal)
-            .then((reply) => {
-            const token = typeof reply === "string" ? reply : reply.token;
-            if (typeof token !== "string" || token === "")
-                throw new Error("The token callback returned no token");
-            const expiresAt = typeof reply !== "string" && reply.expiresAt
-                ? Date.parse(reply.expiresAt)
-                : (readClaims(token).exp ?? 0) * 1000;
-            this.current = { token, expiresAt };
-            return token;
-        })
-            .finally(() => {
-            this.pending = undefined;
-        });
-        return this.pending;
-    }
-    invalidate() {
-        this.current = undefined;
-    }
-    /** The subject of the current token, fetching one if needed. */
-    async subject(signal) {
-        const sub = readClaims(await this.get(signal)).sub;
-        if (!sub)
-            throw new Error("The subject token names no subject");
-        return sub;
-    }
-}
-/** Reattaching a run the Runtime ended for its token, at most this many times in a row. */
-const MAX_REATTACH = 5;
-function parseFrame(text) {
-    let id;
-    let data;
-    for (const line of text.split("\n")) {
-        if (line.startsWith("id: "))
-            id = line.slice(4);
-        else if (line.startsWith("data: "))
-            data = line.slice(6);
-    }
-    let event;
-    try {
-        event = data === undefined ? undefined : JSON.parse(data);
-    }
-    catch {
-        event = undefined;
-    }
-    return { text, ...(id ? { id } : {}), ...(event ? { event } : {}) };
-}
-/** The frames of an SSE body, as they arrive. */
-async function* frames(body) {
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-        for (;;) {
-            const { value, done } = await reader.read();
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n");
-            let end;
-            while ((end = buffer.indexOf("\n\n")) >= 0) {
-                const text = buffer.slice(0, end);
-                buffer = buffer.slice(end + 2);
-                if (text.trim() !== "")
-                    yield parseFrame(text);
-            }
-        }
-    }
-    finally {
-        await reader.cancel().catch(() => { });
-    }
-}
-/** The signed-in person's view of the Runtime: their sessions and vaults, the agents they may use. */
-export class BrowserClient {
-    /** The underlying Tenant API client, for anything this class does not wrap. */
-    client;
-    url;
-    publishableKey;
-    tokens;
-    fetcher;
-    constructor(options) {
-        this.url = options.url.replace(/\/$/, "");
-        this.publishableKey = options.publishableKey;
-        this.tokens = new CachedToken((signal) => options.token(signal));
-        const base = options.fetch ?? globalThis.fetch;
-        // Called as a method, a page's window.fetch would lose its receiver.
-        this.fetcher = options.fetch ? base : (input, init) => base(input, init);
-        this.client = new AgentsClient({
-            url: this.url,
-            publishableKey: options.publishableKey,
-            token: this.tokens,
-            ...(options.fetch ? { fetch: options.fetch } : {}),
-        });
-    }
-    /** The person the tokens are for. */
-    subject(signal) {
-        return this.tokens.subject(signal);
-    }
-    /** A current token, e.g. for a request this client does not make itself. */
-    token(signal) {
-        return this.tokens.get(signal);
-    }
-    /** The agents the person may use: id, name and description. */
-    listAgents(signal) {
-        return this.client.listAgents({ ...(signal ? { signal } : {}) });
-    }
-    listSessions(agentId, signal) {
-        return this.client.listSessions({
-            ...(agentId ? { agentId } : {}),
-            ...(signal ? { signal } : {}),
-        });
-    }
-    session(sessionId) {
-        return this.client.session(sessionId);
-    }
-    /** The person's file artifacts, in their own sessions (protocol 6). */
-    get artifacts() {
-        return this.client.artifacts;
-    }
-    /** A session of the person's own; the owner is always the token's subject. */
-    async createSession(options) {
-        return this.client.createSession({
-            ...options,
-            ownerUserId: await this.subject(),
-        });
-    }
-    async createVault(options) {
-        return this.client.createVault({ ...options, ownerUserId: await this.subject() });
-    }
-    async listVaults(signal) {
-        return this.client.listVaults(await this.subject(signal), signal);
-    }
-    /** `fetch` with this client's credentials, retrying once after `401 token_expired`. */
-    async send(input, init = {}, retried = false) {
-        const headers = new Headers(init.headers);
-        headers.set("authorization", `Bearer ${await this.tokens.get(init.signal ?? undefined)}`);
-        headers.set(PUBLISHABLE_KEY_HEADER, this.publishableKey);
-        headers.set(PROTOCOL_HEADER, String(PROTOCOL_VERSION));
-        const response = await this.fetcher(input, { ...init, headers });
-        if (response.status !== 401 || retried)
-            return response;
-        const body = (await response.clone().json().catch(() => undefined));
-        if (body?.code !== "token_expired")
-            return response;
-        await response.body?.cancel().catch(() => { });
-        this.tokens.invalidate();
-        return this.send(input, init, true);
-    }
-    /**
-     * For `@ag-ui/client`'s `HttpAgent`: `new HttpAgent({ url, fetch })`. The `fetch` adds the
-     * publishable key and a current token, and when the Runtime ends a run's stream because the
-     * token expired or was revoked, it reattaches with a new token from the last event, so the
-     * agent sees one run.
-     */
-    agUi(agentId) {
-        const url = `${this.url}/v1/ag-ui/agents/${encodeURIComponent(agentId)}`;
-        const fetchRun = async (input, init = {}) => {
-            const target = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-            const response = await this.send(target, init);
-            const isStream = response.headers.get("content-type")?.includes("text/event-stream");
-            const method = (init.method ?? "GET").toUpperCase();
-            if (!response.ok || !isStream || !response.body || method !== "POST" || target !== url)
-                return response;
-            let run = {};
-            try {
-                run = JSON.parse(String(init.body ?? "{}"));
-            }
-            catch {
-                /* not a RunAgentInput: pass the stream through as it is */
-            }
-            if (!run.threadId)
-                return response;
-            return new Response(this.stitch(response.body, url, run.threadId, run.runId, init.signal ?? undefined), {
-                status: response.status,
-                headers: response.headers,
-            });
-        };
-        return { url, fetch: fetchRun };
-    }
-    /** The thread's messages, for `HttpAgent`'s `initialMessages`. */
-    async agUiHistory(agentId, threadId, signal) {
-        const response = await this.send(`${this.url}/v1/ag-ui/agents/${encodeURIComponent(agentId)}/threads/${encodeURIComponent(threadId)}/messages`, { method: "GET", ...(signal ? { signal } : {}) });
-        if (!response.ok)
-            throw new Error(`Runtime HTTP ${response.status}`);
-        return (await response.json());
-    }
-    /**
-     * Passes a run's frames through; on `nylorun.stream_closed` before the run finished, fetches
-     * the rest from the last event id and continues without repeating `RUN_STARTED`.
-     */
-    stitch(body, url, threadId, runId, signal) {
-        const encoder = new TextEncoder();
-        const self = this;
-        return new ReadableStream({
-            async start(controller) {
-                let lastId;
-                let source = body;
-                let reattaching = false;
-                try {
-                    for (let attempt = 0; source && attempt <= MAX_REATTACH; attempt += 1) {
-                        let closed = false;
-                        for await (const frame of frames(source)) {
-                            if (frame.event?.type === "CUSTOM" && frame.event.name === "nylorun.stream_closed") {
-                                if (frame.id)
-                                    lastId = frame.id;
-                                closed = true;
-                                break;
-                            }
-                            // The reattached stream starts its run again; the agent already has it.
-                            if (reattaching && frame.event?.type === "RUN_STARTED")
-                                continue;
-                            if (frame.id)
-                                lastId = frame.id;
-                            controller.enqueue(encoder.encode(`${frame.text}\n\n`));
-                        }
-                        source = null;
-                        if (!closed || !lastId || signal?.aborted)
-                            break;
-                        reattaching = true;
-                        const query = runId ? `?runId=${encodeURIComponent(runId)}` : "";
-                        const next = await self.send(`${url}/threads/${encodeURIComponent(threadId)}/events${query}`, {
-                            method: "GET",
-                            headers: { accept: "text/event-stream", "last-event-id": lastId },
-                            ...(signal ? { signal } : {}),
-                        });
-                        // 204: the run ended with nothing after the last event; there is no more to send.
-                        if (next.ok && next.status !== 204 && next.body)
-                            source = next.body;
-                    }
-                    controller.close();
-                }
-                catch (error) {
-                    controller.error(error);
-                }
-            },
-        });
-    }
-}
-export function createBrowserClient(options) {
-    return new BrowserClient(options);
-}

package/dist/token-endpoint.d.ts

@@ -1,23 +0,0 @@
-/**
- * A route for app servers that mints a subject token for the signed-in person (Host feature
- * `subject-tokens`). The browser client calls it whenever it needs a token. Mount it on your
- * app's own origin behind your sign-in: `POST` only, no CORS, never cached.
- *
- *   export const POST = createTokenEndpoint({
- *     client, role: "user", subject: (request) => userFromCookie(request)?.id,
- *   });
- */
-import type { TokenScope } from "@nylorun/core/contracts";
-import type { AgentsClient } from "./session-client.js";
-export interface TokenEndpointOptions {
-    /** The application client (the Tenant key stays on the server). */
-    client: AgentsClient | Promise<AgentsClient>;
-    /** The signed-in person the token is for; `undefined` answers 401. */
-    subject(request: Request): string | undefined | Promise<string | undefined>;
-    /** The access policy role to mint for, or a function of the request and subject. */
-    role: string | ((request: Request, subject: string) => string | Promise<string>);
-    scopes?: readonly TokenScope[];
-    agents?: readonly string[];
-    ttlSeconds?: number;
-}
-export declare function createTokenEndpoint(options: TokenEndpointOptions): (request: Request) => Promise<Response>;