@nylorun/agents 0.13.0-beta → 0.16.0-beta

package/dist/access.d.ts

@@ -1,105 +1,14 @@
 /**
- * Subject tokens and access management for app servers (Host feature `subject-tokens`), on the
- * application key. `client.tokens.create` mints a short-lived token for one signed-in person;
- * `client.access` manages the policy that decides what each role may do, the signing keys and
- * revocations. Each call checks the Host feature before sending anything.
+ * The Tenant's public keys, which verify the tokens it signs (capability links, run tokens).
+ * Listing, rotating and revoking signing keys is the Management API's (`admin.signingKeys` in
+ * `@nylorun/admin`, protocol 8).
  */
-import type { AccessPolicy, CreateTokenResponse, Jwks, PublishableKey, SigningKeyView, TokenScope } from "@nylorun/core/contracts";
-import { type Transport } from "./http.js";
-export interface CreateTokenOptions {
-    /** The person the token is for, e.g. `app:42`. */
-    subject: string;
-    /** A role of the Tenant's access policy. */
-    role: string;
-    /** Narrow the role's scopes. Default: all of the role's scopes. */
-    scopes?: readonly TokenScope[];
-    /** Narrow the role's agents. Default: all of the role's agents. */
-    agents?: readonly string[];
-    /**
-     * The sandboxes the token reaches (its `sbx` claim): exact ids, or prefixes ending in `/*`
-     * (`team-a/*`). Default: none (Host feature `sandboxes`).
-     */
-    sandboxes?: readonly string[];
-    /** 60 to 900 seconds, at most the policy's `maxTtlSeconds`. Default: that maximum. */
-    ttlSeconds?: number;
-    signal?: AbortSignal;
-}
-export declare class TokensClient {
-    private readonly transport;
-    constructor(transport: Transport);
-    /** Mints a subject token. Only the application key may; never acting for a subject. */
-    create(options: CreateTokenOptions): Promise<CreateTokenResponse>;
-}
-export declare class SigningKeysClient {
-    private readonly transport;
-    constructor(transport: Transport);
-    list(options?: {
-        signal?: AbortSignal;
-    }): Promise<SigningKeyView[]>;
-    /**
-     * standby → current → previous → revoked, and a new standby. Refused while the previous key
-     * may still verify live tokens; `force` skips that and signs those tokens out.
-     */
-    rotate(options?: {
-        force?: boolean;
-        signal?: AbortSignal;
-    }): Promise<SigningKeyView[]>;
-    /** Revokes a previous or standby key; the current key must be rotated first. */
-    revoke(keyId: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<SigningKeyView>;
-}
-/**
- * Publishable keys (Host feature `browser-access`): shipped in a web page or an app, they name
- * the Tenant and the app, and list the origins a browser may use them from.
- */
-export declare class PublishableKeysClient {
-    private readonly transport;
-    constructor(transport: Transport);
-    list(options?: {
-        signal?: AbortSignal;
-    }): Promise<PublishableKey[]>;
-    /**
-     * A new key. `origins` are exact origins (`https://app.example.com`) or
-     * `http://localhost:*`; `[]` allows native apps only.
-     */
-    create(options: {
-        name: string;
-        origins: readonly string[];
-        signal?: AbortSignal;
-    }): Promise<PublishableKey>;
-    /** Replaces the key's origins. */
-    update(keyId: string, options: {
-        origins: readonly string[];
-        signal?: AbortSignal;
-    }): Promise<PublishableKey>;
-    /** Revokes the key: every request that sends it gets the opaque 404. */
-    revoke(keyId: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<PublishableKey>;
-}
+import type { Jwks } from "@nylorun/core/contracts";
+import type { Transport } from "./http.js";
 export declare class AccessClient {
     private readonly transport;
-    readonly signingKeys: SigningKeysClient;
-    readonly publishableKeys: PublishableKeysClient;
     constructor(transport: Transport);
-    getPolicy(options?: {
-        signal?: AbortSignal;
-    }): Promise<AccessPolicy>;
-    putPolicy(policy: AccessPolicy, options?: {
-        signal?: AbortSignal;
-    }): Promise<AccessPolicy>;
-    /**
-     * Ends every token minted so far for `subject` and its open streams. Running turns continue;
-     * cancel them separately if they must stop.
-     */
-    revokeSubject(subject: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<{
-        subject: string;
-        epoch: number;
-    }>;
-    /** The public keys that verify the Tenant's subject tokens. */
+    /** The public keys that verify the tokens the Tenant signs. */
     jwks(options?: {
         signal?: AbortSignal;
     }): Promise<Jwks>;

package/dist/access.js

@@ -1,112 +1,10 @@
-import { id, segment } from "./http.js";
-const FEATURE = "subject-tokens";
-export class TokensClient {
-    transport;
-    constructor(transport) {
-        this.transport = transport;
-    }
-    /** Mints a subject token. Only the application key may; never acting for a subject. */
-    async create(options) {
-        await this.transport.requireFeature(FEATURE, options.signal);
-        return this.transport.json("/v1/tokens", "POST", {
-            requestId: id(),
-            subject: options.subject,
-            role: options.role,
-            ...(options.scopes ? { scopes: [...options.scopes] } : {}),
-            ...(options.agents ? { agents: [...options.agents] } : {}),
-            ...(options.sandboxes ? { sandboxes: [...options.sandboxes] } : {}),
-            ...(options.ttlSeconds === undefined ? {} : { ttlSeconds: options.ttlSeconds }),
-        }, options.signal);
-    }
-}
-export class SigningKeysClient {
-    transport;
-    constructor(transport) {
-        this.transport = transport;
-    }
-    async list(options = {}) {
-        await this.transport.requireFeature(FEATURE, options.signal);
-        const reply = await this.transport.json("/v1/access/signing-keys", "GET", undefined, options.signal);
-        return reply.keys;
-    }
-    /**
-     * standby → current → previous → revoked, and a new standby. Refused while the previous key
-     * may still verify live tokens; `force` skips that and signs those tokens out.
-     */
-    async rotate(options = {}) {
-        await this.transport.requireFeature(FEATURE, options.signal);
-        const reply = await this.transport.json("/v1/access/signing-keys/rotate", "POST", { requestId: id(), ...(options.force ? { force: true } : {}) }, options.signal);
-        return reply.keys;
-    }
-    /** Revokes a previous or standby key; the current key must be rotated first. */
-    async revoke(keyId, options = {}) {
-        await this.transport.requireFeature(FEATURE, options.signal);
-        return this.transport.json(`/v1/access/signing-keys/${segment(keyId)}/revoke`, "POST", { requestId: id() }, options.signal);
-    }
-}
-/**
- * Publishable keys (Host feature `browser-access`): shipped in a web page or an app, they name
- * the Tenant and the app, and list the origins a browser may use them from.
- */
-export class PublishableKeysClient {
-    transport;
-    constructor(transport) {
-        this.transport = transport;
-    }
-    async list(options = {}) {
-        await this.transport.requireFeature("browser-access", options.signal);
-        const reply = await this.transport.json("/v1/access/publishable-keys", "GET", undefined, options.signal);
-        return reply.keys;
-    }
-    /**
-     * A new key. `origins` are exact origins (`https://app.example.com`) or
-     * `http://localhost:*`; `[]` allows native apps only.
-     */
-    async create(options) {
-        await this.transport.requireFeature("browser-access", options.signal);
-        return this.transport.json("/v1/access/publishable-keys", "POST", { requestId: id(), name: options.name, origins: [...options.origins] }, options.signal);
-    }
-    /** Replaces the key's origins. */
-    async update(keyId, options) {
-        await this.transport.requireFeature("browser-access", options.signal);
-        return this.transport.json(`/v1/access/publishable-keys/${segment(keyId)}`, "PUT", { requestId: id(), origins: [...options.origins] }, options.signal);
-    }
-    /** Revokes the key: every request that sends it gets the opaque 404. */
-    async revoke(keyId, options = {}) {
-        await this.transport.requireFeature("browser-access", options.signal);
-        return this.transport.json(`/v1/access/publishable-keys/${segment(keyId)}`, "DELETE", undefined, options.signal);
-    }
-}
 export class AccessClient {
     transport;
-    signingKeys;
-    publishableKeys;
     constructor(transport) {
         this.transport = transport;
-        this.signingKeys = new SigningKeysClient(transport);
-        this.publishableKeys = new PublishableKeysClient(transport);
-    }
-    async getPolicy(options = {}) {
-        await this.transport.requireFeature(FEATURE, options.signal);
-        const reply = await this.transport.json("/v1/access/policy", "GET", undefined, options.signal);
-        return reply.policy;
-    }
-    async putPolicy(policy, options = {}) {
-        await this.transport.requireFeature(FEATURE, options.signal);
-        const reply = await this.transport.json("/v1/access/policy", "PUT", { requestId: id(), policy }, options.signal);
-        return reply.policy;
-    }
-    /**
-     * Ends every token minted so far for `subject` and its open streams. Running turns continue;
-     * cancel them separately if they must stop.
-     */
-    async revokeSubject(subject, options = {}) {
-        await this.transport.requireFeature(FEATURE, options.signal);
-        return this.transport.json("/v1/access/revocations", "POST", { requestId: id(), subject }, options.signal);
     }
-    /** The public keys that verify the Tenant's subject tokens. */
+    /** The public keys that verify the tokens the Tenant signs. */
     async jwks(options = {}) {
-        await this.transport.requireFeature(FEATURE, options.signal);
         return this.transport.json("/v1/access/jwks", "GET", undefined, options.signal);
     }
 }

package/dist/ag-ui/handler.d.ts

@@ -5,8 +5,8 @@
  * person, so the Runtime keeps one person out of another's threads and does all the protocol
  * work. The browser never sees the Tenant key, the Runtime's URL or the Tenant id.
  *
- * The same threads are reachable directly from a browser with a subject token: each thread is
- * one session per subject, agent and thread on both paths.
+ * The same threads are reachable directly from a browser with a trusted issuer's token (through
+ * the operator's proxy): each thread is one session per subject, agent and thread on both paths.
  */
 import { type SubjectScope } from "@nylorun/core/contracts";
 import type { BuiltWorkflow } from "@nylorun/core/define";
@@ -27,10 +27,7 @@ export interface AgUiHandlerOptions {
     basePath?: string;
     /** Application client. Default: `createClient()`, from the environment or the Project link. */
     client?: AgentsClient | Promise<AgentsClient>;
-    /**
-     * What each subject may do through this endpoint. Default `["sessions:own"]`; add
-     * `vaults:own` if `session()` attaches the person's vaults.
-     */
+    /** What each subject may do through this endpoint. Default `["sessions:own"]`. */
     scopes?: readonly SubjectScope[];
     /** Optional per-session parameters, e.g. the person's vault for connected accounts. */
     session?(subject: string, agentId: string): AgUiSessionOptions | Promise<AgUiSessionOptions>;

package/dist/ag-ui/handler.js

@@ -5,8 +5,8 @@
  * person, so the Runtime keeps one person out of another's threads and does all the protocol
  * work. The browser never sees the Tenant key, the Runtime's URL or the Tenant id.
  *
- * The same threads are reachable directly from a browser with a subject token: each thread is
- * one session per subject, agent and thread on both paths.
+ * The same threads are reachable directly from a browser with a trusted issuer's token (through
+ * the operator's proxy): each thread is one session per subject, agent and thread on both paths.
  */
 import { parseSubjectHeaders } from "@nylorun/core/contracts";
 import { createClient, } from "../client.js";

package/dist/artifacts.d.ts

@@ -9,7 +9,7 @@
  * session's sandbox as a version of its `outputs` folder. Read one as a tree, one file by path,
  * a diff between versions or a zip.
  *
- * Acting for a person (`client.as`, a subject token), only the artifacts of their own sessions.
+ * Acting for a person (`client.as`, or a trusted issuer's token), only the artifacts of their own sessions.
  */
 import type { ArtifactDiff, ArtifactLink, ArtifactTree, ArtifactView, DeleteArtifactResponse, UploadArtifactResponse } from "@nylorun/core/contracts";
 import { type Transport } from "./http.js";

package/dist/files.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Definition files (track R2 M4): `client.files`. A definition names the files it needs by the
+ * SHA-256 of their bytes (a skill's folder, `SkillManifest.files`); the Runtime holds each one
+ * once, uploaded with `PUT /v1/files/sha256:<hex>`, and refuses a definition naming a file it
+ * does not hold (`400 definition_files_missing`). `saveAgent` uploads an agent's files itself.
+ */
+import { type DefinitionFileView } from "@nylorun/core/contracts";
+import type { SkillFileSource } from "@nylorun/core/define";
+import { type Transport } from "./http.js";
+/** `sha256:<hex>` of `bytes`. */
+export declare function definitionFileHash(bytes: Uint8Array): Promise<string>;
+export declare class FilesClient {
+    private readonly transport;
+    constructor(transport: Transport);
+    /** Whether the Runtime holds the file `sha256` (`sha256:<hex>`) names. */
+    has(sha256: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<boolean>;
+    /**
+     * Uploads one file, at most 10 MiB. The Runtime checks its bytes hash to `sha256` (default:
+     * their hash) and keeps a file it already holds as it is.
+     */
+    upload(bytes: Uint8Array, options?: {
+        sha256?: string;
+        signal?: AbortSignal;
+    }): Promise<DefinitionFileView>;
+    /** Uploads each of `files` the Runtime does not hold yet. */
+    ensure(files: ReadonlyMap<string, SkillFileSource>, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}

package/dist/files.js

@@ -0,0 +1,60 @@
+/**
+ * Definition files (track R2 M4): `client.files`. A definition names the files it needs by the
+ * SHA-256 of their bytes (a skill's folder, `SkillManifest.files`); the Runtime holds each one
+ * once, uploaded with `PUT /v1/files/sha256:<hex>`, and refuses a definition naming a file it
+ * does not hold (`400 definition_files_missing`). `saveAgent` uploads an agent's files itself.
+ */
+import { isDefinitionFileHash, } from "@nylorun/core/contracts";
+import { RuntimeError } from "./http.js";
+/** `sha256:<hex>` of `bytes`. */
+export async function definitionFileHash(bytes) {
+    const digest = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", bytes));
+    return `sha256:${[...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function pathOf(sha256) {
+    if (!isDefinitionFileHash(sha256))
+        throw new TypeError(`${sha256} is not a definition file's hash: sha256:<64 lowercase hex>`);
+    return `/v1/files/${sha256}`;
+}
+export class FilesClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Whether the Runtime holds the file `sha256` (`sha256:<hex>`) names. */
+    async has(sha256, options = {}) {
+        try {
+            await this.transport.request(pathOf(sha256), {
+                method: "HEAD",
+                ...(options.signal ? { signal: options.signal } : {}),
+            });
+            return true;
+        }
+        catch (error) {
+            if (error instanceof RuntimeError && error.status === 404)
+                return false;
+            throw error;
+        }
+    }
+    /**
+     * Uploads one file, at most 10 MiB. The Runtime checks its bytes hash to `sha256` (default:
+     * their hash) and keeps a file it already holds as it is.
+     */
+    async upload(bytes, options = {}) {
+        const response = await this.transport.request(pathOf(options.sha256 ?? (await definitionFileHash(bytes))), {
+            method: "PUT",
+            body: bytes,
+            headers: { "content-type": "application/octet-stream" },
+            ...(options.signal ? { signal: options.signal } : {}),
+        });
+        return (await response.json());
+    }
+    /** Uploads each of `files` the Runtime does not hold yet. */
+    async ensure(files, options = {}) {
+        for (const [sha256, source] of files) {
+            if (await this.has(sha256, options))
+                continue;
+            await this.upload(await source.read(), { sha256, ...options });
+        }
+    }
+}

package/dist/http.d.ts

@@ -1,8 +1,9 @@
 import { type Compatibility, type ProtocolRange } from "@nylorun/core/compatibility";
 /**
- * Subject tokens for a client that holds no Tenant key (a browser or an app; Host feature
- * `subject-tokens`). `get` returns a current token and may fetch a new one; `invalidate`
- * drops the cached one after the Runtime answered `401 token_expired`.
+ * Bearer tokens for a client that holds no Tenant key: a trusted issuer's tokens (Host feature
+ * `trusted-issuers`), from the operator's identity provider. `get` returns a current token and
+ * may fetch a new one; `invalidate` drops the cached one after the Runtime answered
+ * `401 token_expired`.
  */
 export interface TokenSource {
     get(signal?: AbortSignal): Promise<string>;
@@ -16,10 +17,8 @@ export interface Destination {
     url?: string;
     key?: string;
     fetch?: typeof fetch;
-    /** Instead of `key`: subject tokens. The client then skips the `/health` check. */
+    /** Instead of `key`: a trusted issuer's tokens. The client then skips the `/health` check. */
     token?: TokenSource;
-    /** A publishable key (Host feature `browser-access`): names the app and its origins. */
-    publishableKey?: string;
 }
 export declare function env(name: string): string | undefined;
 export declare class RuntimeError extends Error {
@@ -39,10 +38,9 @@ export declare class IncompatibleRuntimeError extends Error {
 }
 export declare class Transport {
     readonly url: string;
-    /** The Tenant key; empty for a client that uses subject tokens. */
+    /** The Tenant key; empty for a client that uses issuer tokens. */
     readonly key: string;
     readonly token: TokenSource | undefined;
-    readonly publishableKey: string | undefined;
     readonly fetcher: typeof fetch;
     /** Sent on every request, e.g. `Nylorun-Subject` and `Nylorun-Scopes` (`withHeaders`). */
     readonly headers: Readonly<Record<string, string>>;
@@ -53,11 +51,6 @@ export declare class Transport {
      * transport's compatibility check, so a copy made per request does not repeat `/health`.
      */
     withHeaders(headers: Readonly<Record<string, string>>): Transport;
-    /**
-     * The same destination with another bearer (a delivery token for an Action endpoint's
-     * callbacks). Like `withHeaders`, the copy shares this transport's compatibility check.
-     */
-    withKey(key: string): Transport;
     /** Clears the cached Host compatibility result (used after a 426). */
     clearCompatibilityCache(): void;
     private ensureCompatible;

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;
@@ -94,14 +92,6 @@ export class Transport {
             headers: Object.freeze({ ...this.headers, ...headers }),
         });
     }
-    /**
-     * The same destination with another bearer (a delivery token for an Action endpoint's
-     * callbacks). Like `withHeaders`, the copy shares this transport's compatibility check.
-     */
-    withKey(key) {
-        const copy = Object.create(Transport.prototype);
-        return Object.assign(copy, this, { key });
-    }
     /** Clears the cached Host compatibility result (used after a 426). */
     clearCompatibilityCache() {
         this.check.compatible = false;
@@ -165,8 +155,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 +168,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

@@ -1,23 +1,18 @@
-export { hashManifest, PROTOCOL_VERSION, PROTOCOL_FEATURES, HOST_PROTOCOL, DEFINITION_SCHEMA_VERSION, PROTOCOL_HEADER, SUBJECT_HEADER, SCOPES_HEADER, TENANT_ID_PATTERN, isTenantId, newTenantId, newPrincipalId, checkCompatibility, compareVersions, ERROR_CODES, } from "@nylorun/core/compatibility";
+export { hashManifest, PROTOCOL_VERSION, PROTOCOL_FEATURES, HOST_PROTOCOL, DEFINITION_SCHEMA_VERSION, PROTOCOL_HEADER, SUBJECT_HEADER, SCOPES_HEADER, SESSION_ID_HEADER, TURN_ID_HEADER, AGENT_ID_HEADER, TENANT_ID_PATTERN, isTenantId, newTenantId, newPrincipalId, checkCompatibility, compareVersions, ERROR_CODES, } from "@nylorun/core/compatibility";
 export type { ProtocolFeature, ProtocolRange, Compatibility, ErrorCode, } from "@nylorun/core/compatibility";
 export { Agent, AgentBuilder } from "./builder.js";
-export { AgentBuildError, AgentLifecycleError, Loop, Chain, Switch, Parallel, Map, VerdictSchema, isVerdict, withInstructions, withoutTools, WorkflowBuildError, isBuiltWorkflow, capability, CapabilityBuilder, flow, tool, defineSchema, ToolError, } from "@nylorun/core/define";
-export type { FlowAgentBuilder, Flow, Named, StageArgs, NestedStageArgs, CapabilityIdentity, } from "@nylorun/core/define";
-export type { AgentOptions, AgentManifest, BuiltAgent, BuiltWorkflow, LoopOptions, LoopDecideArgs, LoopVerifyArgs, LoopDecision, ChainOptions, SwitchOptions, ParallelOptions, MapOptions, Verdict, WorkflowBinding, WorkflowManifest, ToolDefinition, ToolExecutionContext, ToolOutcome, Patch, Decision, TurnDecision, HookScope, BeforeHook, AfterHook, JsonValue, JsonObject, } from "@nylorun/core/define";
-export type { LiveEvent, SessionEvent, SessionEventOf, EventType, SessionCommand, Action, ActionOutcome, CredentialInfo, CredentialSelection, VaultInfo, SubjectScope, SandboxView, SandboxEvent, SandboxKind, MessagePart, ArtifactView, ArtifactVersionView, ArtifactLink, UploadArtifactResponse, ArtifactTree, ArtifactDiff, FolderEntry, } from "@nylorun/core/contracts";
+export { AgentBuildError, AgentLifecycleError, VerdictSchema, isVerdict, WorkflowBuildError, isBuiltWorkflow, capability, CapabilityBuilder, flow, tool, http, defineSchema, ToolError, } from "@nylorun/core/define";
+export type { FlowAgentBuilder, Flow, Named, LoopOptions, StageOptions, CapabilityIdentity, HttpTarget, } from "@nylorun/core/define";
+export type { AgentOptions, AgentManifest, BuiltAgent, BuiltWorkflow, Verdict, WorkflowBinding, WorkflowManifest, ToolDefinition, ToolExecutionContext, ToolOutcome, JsonValue, JsonObject, } from "@nylorun/core/define";
+export type { SessionPage, SessionListItem, SessionManifestView, HistoryPage, SessionUsageTotals, ModelCall, ModelCallsPage, SandboxPage, LiveEvent, SessionEvent, SessionEventOf, EventType, SessionCommand, CredentialInfo, CredentialSelection, VaultInfo, SubjectScope, SandboxView, SandboxEvent, SandboxKind, MessagePart, ArtifactView, ArtifactVersionView, ArtifactLink, UploadArtifactResponse, DefinitionFileView, ArtifactTree, ArtifactDiff, FolderEntry, } from "@nylorun/core/contracts";
 export { SUBJECT_SCOPES } from "@nylorun/core/contracts";
 export { AgentsClient, SessionClient, createClient } from "./client.js";
 export { ArtifactsClient } from "./artifacts.js";
+export { FilesClient, definitionFileHash } from "./files.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 { createActionHandler } from "./action-handler.js";
-export type { ActionHandler, ActionHandlerOptions, RegisterOptions, } from "./action-handler.js";
-export type { ExecuteActionOptions, ExecutableDefinition, } from "./execute-action.js";
+export { AccessClient } from "./access.js";
 export { resolveConnection, ConnectionError } from "./connection.js";
 export type { ResolvedConnection } from "./connection.js";
 export { RuntimeError, IncompatibleRuntimeError } from "./http.js";
@@ -26,11 +21,8 @@ export { plugin } from "./plugins/plugin.js";
 export type { PluginCapability } from "./plugins/plugin.js";
 export { loadPlugin, PluginError } from "./plugins/load.js";
 export type { LoadedPlugin, PluginDiagnostic } from "./plugins/load.js";
-export { prepareStdioLaunch, expandPluginPlaceholders } from "./plugins/launch.js";
-export type { StdioLaunch } from "./plugins/launch.js";
 export { skills, loadSkillsFromDirectory, resolveSkillsRoot, parseSkill, SkillsError, formatSkillCatalog, SKILLS_USAGE, } from "./skills/index.js";
 export type { SkillsCapability, SkillsOptions, SkillDiagnostic, } from "./skills/index.js";
 export { mcp, McpError } from "./mcp/index.js";
 export type { McpCapability, McpOptions, McpServerSpec } from "./mcp/index.js";
-export type { ActionSandbox, ActionSandboxToolResult, CreateActionSandboxOptions, } from "./sandbox/index.js";
-export { createActionSandbox, definitionDeclaresSandbox, isActionSandboxTool, } from "./sandbox/index.js";
+export type { SessionPageOptions } from "./reads.js";

package/dist/index.js

@@ -1,19 +1,16 @@
 // Definition authoring and wire contracts are the only harness runtime imports.
-export { hashManifest, PROTOCOL_VERSION, PROTOCOL_FEATURES, HOST_PROTOCOL, DEFINITION_SCHEMA_VERSION, PROTOCOL_HEADER, SUBJECT_HEADER, SCOPES_HEADER, TENANT_ID_PATTERN, isTenantId, newTenantId, newPrincipalId, checkCompatibility, compareVersions, ERROR_CODES, } from "@nylorun/core/compatibility";
+export { hashManifest, PROTOCOL_VERSION, PROTOCOL_FEATURES, HOST_PROTOCOL, DEFINITION_SCHEMA_VERSION, PROTOCOL_HEADER, SUBJECT_HEADER, SCOPES_HEADER, SESSION_ID_HEADER, TURN_ID_HEADER, AGENT_ID_HEADER, TENANT_ID_PATTERN, isTenantId, newTenantId, newPrincipalId, checkCompatibility, compareVersions, ERROR_CODES, } from "@nylorun/core/compatibility";
 export { Agent, AgentBuilder } from "./builder.js";
-export { AgentBuildError, AgentLifecycleError, Loop, Chain, Switch, Parallel, Map, VerdictSchema, isVerdict, withInstructions, withoutTools, WorkflowBuildError, isBuiltWorkflow, capability, CapabilityBuilder, flow, tool, defineSchema, ToolError, } from "@nylorun/core/define";
+export { AgentBuildError, AgentLifecycleError, VerdictSchema, isVerdict, WorkflowBuildError, isBuiltWorkflow, capability, CapabilityBuilder, flow, tool, http, defineSchema, ToolError, } from "@nylorun/core/define";
 export { SUBJECT_SCOPES } from "@nylorun/core/contracts";
 export { AgentsClient, SessionClient, createClient } from "./client.js";
 export { ArtifactsClient } from "./artifacts.js";
+export { FilesClient, definitionFileHash } from "./files.js";
 export { SandboxesClient } from "./client.js";
-export { AccessClient, PublishableKeysClient, SigningKeysClient, TokensClient, } from "./access.js";
-export { createTokenEndpoint } from "./token-endpoint.js";
-export { createActionHandler } from "./action-handler.js";
+export { AccessClient } from "./access.js";
 export { resolveConnection, ConnectionError } from "./connection.js";
 export { RuntimeError, IncompatibleRuntimeError } from "./http.js";
 export { plugin } from "./plugins/plugin.js";
 export { loadPlugin, PluginError } from "./plugins/load.js";
-export { prepareStdioLaunch, expandPluginPlaceholders } from "./plugins/launch.js";
 export { skills, loadSkillsFromDirectory, resolveSkillsRoot, parseSkill, SkillsError, formatSkillCatalog, SKILLS_USAGE, } from "./skills/index.js";
 export { mcp, McpError } from "./mcp/index.js";
-export { createActionSandbox, definitionDeclaresSandbox, isActionSandboxTool, } from "./sandbox/index.js";

package/dist/plugins/load.d.ts

@@ -1,4 +1,5 @@
-import type { McpServerManifest, SkillRecord } from "@nylorun/core/define";
+import { type McpServerManifest } from "@nylorun/core/define";
+import { type LoadedSkill } from "../skills/load.js";
 export declare const PLUGIN_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
 export declare const MCP_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
 export interface PluginDiagnostic {
@@ -16,7 +17,7 @@ export interface LoadedPlugin {
     readonly root: string;
     readonly name: string;
     readonly description?: string;
-    readonly skills: Readonly<Record<string, SkillRecord>>;
+    readonly skills: Readonly<Record<string, LoadedSkill>>;
     readonly mcpServers: Readonly<Record<string, McpServerManifest>>;
     readonly diagnostics: readonly PluginDiagnostic[];
 }