@nylorun/agents 0.13.0-beta → 0.16.0-beta

package/dist/plugins/load.js

@@ -1,7 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, realpathSync, statSync, } from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { stdioMcpRefusal } from "@nylorun/core/define";
 import { loadSkillsFromDirectory } from "../skills/load.js";
-import { expandPluginPlaceholders } from "./launch.js";
 export const PLUGIN_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
 export const MCP_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
 const PLUGIN_FIELDS = new Set([
@@ -17,7 +17,6 @@ const PLUGIN_FIELDS = new Set([
     "extensions",
 ]);
 const AUTHOR_FIELDS = new Set(["name", "email", "url"]);
-const RESERVED_ENV = new Set(["PLUGIN_ROOT", "PLUGIN_DATA"]);
 export class PluginError extends Error {
     code;
     diagnostics;
@@ -76,7 +75,7 @@ export function loadPlugin(directory) {
             });
     }
     const skills = loadSkills(root, diagnostics);
-    const mcpServers = loadMcp(root, parsed.name, diagnostics);
+    const mcpServers = loadMcp(root, diagnostics);
     return {
         root,
         name: parsed.name,
@@ -132,7 +131,7 @@ function loadSkills(root, diagnostics) {
         codePrefix: "plugin",
     });
 }
-function loadMcp(root, pluginName, diagnostics) {
+function loadMcp(root, diagnostics) {
     const location = join(root, "mcp.json");
     if (!existsSync(location))
         return {};
@@ -186,101 +185,54 @@ function loadMcp(root, pluginName, diagnostics) {
         });
         return {};
     }
-    const pluginData = join(dirname(root), ".nylorun", "plugin-data", pluginName);
     const servers = {};
     for (const [name, value] of Object.entries(parsed.mcpServers)) {
-        const server = validateServer(name, value, root, pluginData);
-        if (!server) {
+        if (isRecord(value) && value.type === "stdio")
+            throw new PluginError("plugin.mcp-stdio", stdioMcpRefusal(name), diagnostics);
+        const server = validateServer(name, value);
+        if (typeof server === "string") {
             diagnostics.push({
                 severity: "warning",
                 code: "plugin.mcp-server-skipped",
-                message: `Skipped invalid MCP server '${name}'`,
+                message: `Skipped invalid MCP server '${name}': ${server}`,
                 path: location,
             });
             continue;
         }
-        if (server.type === "stdio")
-            mkdirSync(pluginData, { recursive: true });
         servers[name] = server;
     }
     return servers;
 }
-function validateServer(name, value, root, pluginData) {
+/** The server, or why it is skipped. */
+function validateServer(name, value) {
     if (!isRecord(value) || typeof value.type !== "string")
-        return undefined;
-    if (value.type === "stdio")
-        return validateStdio(name, value, root, pluginData);
+        return "it has no type";
     if (value.type === "streamable-http" || value.type === "sse")
         return validateRemote(name, value);
-    return undefined;
-}
-function validateStdio(name, value, root, pluginData) {
-    const allowed = new Set(["type", "command", "args", "env", "cwd"]);
-    if (Object.keys(value).some((key) => !allowed.has(key)))
-        return undefined;
-    if (typeof value.command !== "string" || !isCommandToken(value.command))
-        return undefined;
-    if (value.command.startsWith("./") && !commandStaysInside(root, value.command))
-        return undefined;
-    let args;
-    if (value.args !== undefined) {
-        if (!Array.isArray(value.args) || value.args.some((item) => typeof item !== "string"))
-            return undefined;
-        args = value.args;
-    }
-    let env;
-    if (value.env !== undefined) {
-        if (!isRecord(value.env))
-            return undefined;
-        env = {};
-        for (const [key, item] of Object.entries(value.env)) {
-            if (typeof item !== "string" || RESERVED_ENV.has(key))
-                return undefined;
-            env[key] = item;
-        }
-    }
-    let cwd;
-    if (value.cwd !== undefined) {
-        if (typeof value.cwd !== "string" || !isCwdForm(value.cwd))
-            return undefined;
-        const expanded = expandPluginPlaceholders(value.cwd, root, pluginData);
-        const absolute = expanded.startsWith("/") || /^[A-Za-z]:[\\/]/.test(expanded)
-            ? expanded
-            : resolve(root, expanded);
-        const boundary = value.cwd === "${PLUGIN_DATA}" || value.cwd.startsWith("${PLUGIN_DATA}/")
-            ? pluginData
-            : root;
-        if (!isInside(boundary, absolute))
-            return undefined;
-        cwd = value.cwd;
-    }
-    return {
-        name,
-        type: "stdio",
-        command: value.command,
-        ...(args === undefined ? {} : { args }),
-        ...(env === undefined ? {} : { env }),
-        ...(cwd === undefined ? {} : { cwd }),
-    };
+    return `type '${value.type}' is not streamable-http or sse`;
 }
 function validateRemote(name, value) {
     const allowed = new Set(["type", "url", "headers"]);
-    if (Object.keys(value).some((key) => !allowed.has(key)))
-        return undefined;
-    if (typeof value.url !== "string" || !isRemoteUrl(value.url))
-        return undefined;
+    const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unknown.length > 0)
+        return `${value.type} servers take only type, url and headers, not ${unknown.join(", ")}`;
+    if (typeof value.url !== "string")
+        return "url must be a string";
+    const problem = remoteUrlProblem(value.url);
+    if (problem)
+        return problem;
     let headers;
     if (value.headers !== undefined) {
         if (!isRecord(value.headers))
-            return undefined;
+            return "headers must be an object";
         const seen = new Set();
         headers = {};
         for (const [key, item] of Object.entries(value.headers)) {
             if (typeof item !== "string" || !isHeaderName(key) || /[\r\n\0]/.test(item))
-                return undefined;
+                return `header '${key}' is not a valid header`;
             const folded = key.toLowerCase();
             if (seen.has(folded))
-                return undefined;
+                return `header '${key}' is repeated`;
             seen.add(folded);
             headers[key] = item;
         }
@@ -292,41 +244,29 @@ function validateRemote(name, value) {
         ...(headers === undefined ? {} : { headers }),
     };
 }
-function commandStaysInside(root, command) {
-    const lexical = resolve(root, command);
-    if (!isInside(root, lexical))
-        return false;
-    return !existsSync(lexical) || realInside(root, lexical) !== undefined;
-}
-function isCommandToken(command) {
-    if (!command || /\s/.test(command))
-        return false;
-    if (command.startsWith("./"))
-        return !command.split("/").includes("..");
-    return !command.includes("/") && !command.includes("\\") && !command.includes("${");
-}
-function isCwdForm(cwd) {
-    return (cwd.startsWith("./") ||
-        cwd === "${PLUGIN_ROOT}" ||
-        cwd.startsWith("${PLUGIN_ROOT}/") ||
-        cwd === "${PLUGIN_DATA}" ||
-        cwd.startsWith("${PLUGIN_DATA}/"));
-}
-function isRemoteUrl(value) {
+/**
+ * Why `value` is not a remote server URL: https, or plain http to this machine's loopback (a
+ * local Tenant in Docker reaches it on the Docker host). No credentials or fragment.
+ */
+function remoteUrlProblem(value) {
     let url;
     try {
         url = new URL(value);
     }
     catch {
-        return false;
+        return `url '${value}' is not a URL`;
     }
-    if (url.username || url.password || url.hash)
-        return false;
+    if (url.username || url.password)
+        return "url must not carry credentials; use headers";
+    if (url.hash)
+        return "url must not have a fragment";
     if (url.protocol === "https:")
-        return true;
+        return undefined;
     if (url.protocol !== "http:")
-        return false;
-    return isLoopback(url.hostname);
+        return `url must be https, not ${url.protocol.slice(0, -1)}`;
+    if (isLoopback(url.hostname))
+        return undefined;
+    return `plain http is allowed only for localhost, 127.0.0.1 or [::1]; use https for ${url.hostname}`;
 }
 function isLoopback(hostname) {
     const host = hostname.replace(/^\[|\]$/g, "");

package/dist/plugins/plugin.d.ts

@@ -3,6 +3,11 @@ import { type LoadedPlugin, type PluginDiagnostic } from "./load.js";
 export interface PluginCapability extends CapabilityDeclaration {
     readonly diagnostics: readonly PluginDiagnostic[];
 }
-/** Read an Agent Plugin package and return one capability for `Agent.use`. */
+/**
+ * Read an Agent Plugin package and return one capability for `Agent.use`. Each part it skips
+ * (an invalid MCP server or skill) is a process warning, so building or registering the agent
+ * says why the agent has less than the package declares. A stdio MCP server throws: Nylorun
+ * accepts remote servers only.
+ */
 export declare function plugin(directory: string): PluginCapability;
 export declare function capabilityFromPlugin(loaded: LoadedPlugin): PluginCapability;

package/dist/plugins/plugin.js

@@ -1,10 +1,28 @@
 import { formatSkillCatalog, SKILLS_USAGE } from "../skills/catalog.js";
+import { skillsDeclaration } from "../skills/skills.js";
 import { loadPlugin, } from "./load.js";
-/** Read an Agent Plugin package and return one capability for `Agent.use`. */
+/**
+ * Read an Agent Plugin package and return one capability for `Agent.use`. Each part it skips
+ * (an invalid MCP server or skill) is a process warning, so building or registering the agent
+ * says why the agent has less than the package declares. A stdio MCP server throws: Nylorun
+ * accepts remote servers only.
+ */
 export function plugin(directory) {
     const loaded = loadPlugin(directory);
+    warn(loaded);
     return capabilityFromPlugin(loaded);
 }
+function warn(loaded) {
+    for (const diagnostic of loaded.diagnostics) {
+        if (diagnostic.severity !== "warning")
+            continue;
+        process.emitWarning(`Plugin '${loaded.name}': ${diagnostic.message}`, {
+            type: "NylorunPluginWarning",
+            code: diagnostic.code,
+            ...(diagnostic.path === undefined ? {} : { detail: diagnostic.path }),
+        });
+    }
+}
 export function capabilityFromPlugin(loaded) {
     const names = Object.values(loaded.skills);
     const instructions = names.length === 0
@@ -16,17 +34,12 @@ export function capabilityFromPlugin(loaded) {
                 description: skill.description,
             }))),
         ];
-    const skills = Object.fromEntries(names.map((skill) => [
-        skill.name,
-        { name: skill.name, description: skill.description },
-    ]));
     return {
         id: loaded.name,
         type: "agent-plugin",
-        pluginRoot: loaded.root,
         ...(loaded.description === undefined ? {} : { description: loaded.description }),
         ...(instructions === undefined ? {} : { instructions }),
-        ...(names.length === 0 ? {} : { skills, skillRecords: loaded.skills }),
+        ...(names.length === 0 ? {} : skillsDeclaration(names)),
         ...(Object.keys(loaded.mcpServers).length === 0
             ? {}
             : { mcpServers: loaded.mcpServers }),

package/dist/reads.d.ts

@@ -0,0 +1,17 @@
+/** Optional public reads shared by Studio, CLI and custom clients. */
+import { type SessionListItem, type SessionPage } from "@nylorun/core/contracts";
+import type { Transport } from "./http.js";
+export type SessionPageOptions = {
+    agentId?: string;
+    status?: SessionListItem["status"];
+    sandboxId?: string;
+    ownerUserId?: string;
+    limit?: number;
+    cursor?: string;
+    signal?: AbortSignal;
+};
+export declare class SessionsReadClient {
+    private readonly transport;
+    constructor(transport: Transport);
+    page(options?: SessionPageOptions): Promise<SessionPage>;
+}

package/dist/reads.js

@@ -0,0 +1,17 @@
+/** Optional public reads shared by Studio, CLI and custom clients. */
+import { SessionPageSchema, } from "@nylorun/core/contracts";
+export class SessionsReadClient {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async page(options = {}) {
+        await this.transport.requireFeature("session-reads", options.signal);
+        const { signal, ...filters } = options;
+        const query = new URLSearchParams({ limit: String(options.limit ?? 50) });
+        for (const [key, value] of Object.entries(filters))
+            if (value !== undefined)
+                query.set(key, String(value));
+        return SessionPageSchema.parse(await this.transport.json(`/v1/sessions?${query}`, "GET", undefined, signal));
+    }
+}

package/dist/sandboxes.d.ts

@@ -58,6 +58,35 @@ export declare class SandboxesClient {
         labels?: Readonly<Record<string, string>>;
         signal?: AbortSignal;
     }): Promise<SandboxView[]>;
+    page(options?: {
+        labels?: Readonly<Record<string, string>>;
+        limit?: number;
+        cursor?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        sandboxes: {
+            id: string;
+            kind: "pod" | "virtual";
+            labels: Record<string, string>;
+            spec: Record<string, unknown>;
+            state: "creating" | "ready" | "running" | "stopped";
+            pod?: {
+                desired: "deleted" | "running" | "suspended";
+                observed: "creating" | "deleting" | "expired" | "failed" | "lost" | "running" | "suspended";
+                volumeGeneration: number;
+                hostEpoch: number;
+                expiresAt?: string | undefined;
+                reason?: string | undefined;
+            } | undefined;
+            sessions: {
+                id: string;
+                activeTurnId: string | null;
+            }[];
+            createdAt: string;
+            updatedAt: string;
+        }[];
+        nextCursor: string | null;
+    }>;
     /** Deletes the sandbox and its files; `deleted` is false when there was none. */
     delete(sandboxId: string, options?: {
         signal?: AbortSignal;

package/dist/sandboxes.js

@@ -12,7 +12,7 @@
  *
  * Ids may hold `/`; they are sent percent-encoded as one path segment.
  */
-import { isSandboxId, } from "@nylorun/core/contracts";
+import { SandboxPageSchema, isSandboxId, } from "@nylorun/core/contracts";
 import { id, segment } from "./http.js";
 const FEATURE = "sandboxes";
 export class SandboxesClient {
@@ -53,6 +53,15 @@ export class SandboxesClient {
         const reply = await this.transport.json(`/v1/sandboxes${search ? `?${search}` : ""}`, "GET", undefined, options.signal);
         return reply.sandboxes;
     }
+    async page(options = {}) {
+        await this.transport.requireFeature("session-reads", options.signal);
+        const query = new URLSearchParams({ limit: String(options.limit ?? 50) });
+        if (options.cursor !== undefined)
+            query.set("cursor", options.cursor);
+        for (const [key, value] of Object.entries(options.labels ?? {}))
+            query.append("label", `${key}=${value}`);
+        return SandboxPageSchema.parse(await this.transport.json(`/v1/sandboxes?${query}`, "GET", undefined, options.signal));
+    }
     /** Deletes the sandbox and its files; `deleted` is false when there was none. */
     async delete(sandboxId, options = {}) {
         const path = this.path(sandboxId);

package/dist/session-client.d.ts

@@ -1,13 +1,14 @@
 /**
- * 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 { type SessionItemsResponse, type SessionSummary, type ListAgentsResponse, type ListPublicAgentsResponse, type SubjectScope, type CredentialSelection, type MessagePart, type SandboxRequest, type SessionCommand } from "@nylorun/core/contracts";
+import { SessionsReadClient } from "./reads.js";
+import { AccessClient } from "./access.js";
 import { SandboxesClient } from "./sandboxes.js";
 import { ArtifactsClient } from "./artifacts.js";
+import { FilesClient } from "./files.js";
 import { Transport, type Destination } from "./http.js";
 /** Application-principal access to a session's sandbox built-ins (workflows.md §8). */
 export type SessionSandbox = {
@@ -64,12 +65,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 public keys that verify the tokens the Tenant signs. */
     get access(): AccessClient;
     /**
      * Sandboxes as a resource (Host feature `sandboxes`): `ensure` one by id, `list` them by
@@ -78,90 +74,38 @@ export declare class AgentsClient {
     get sandboxes(): SandboxesClient;
     /** File artifacts: upload, list, download with Range, capability links (protocol 6). */
     get artifacts(): ArtifactsClient;
+    /** Definition files: the skill files a definition names, by content hash. */
+    get files(): FilesClient;
     /** The Runtime's protocol features, including optional ones such as `transcript-events`. */
     hostFeatures(options?: {
         signal?: AbortSignal;
     }): Promise<readonly string[]>;
+    get sessions(): SessionsReadClient;
     listAgents(options?: {
         signal?: AbortSignal;
-    }): Promise<{
-        agents: {
-            manifest: AgentManifest;
-        }[];
+    }): Promise<ListAgentsResponse | {
+        agents: (ListPublicAgentsResponse["agents"][number] & {
+            manifest?: never;
+        })[];
     }>;
     listSessions(options?: {
         agentId?: string;
         signal?: AbortSignal;
     }): Promise<{
-        sessions: SessionView[];
+        sessions: SessionSummary[];
     }>;
-    saveAgent(agent: AgentSource | BuiltWorkflow, options: {
-        implementationVersion: string;
+    /**
+     * Registers the agent's definition (`PUT /v1/agents/{id}`), first uploading the skill files
+     * it names that the Runtime does not hold. A definition with a tool that runs your code
+     * (`tool({ run })`, a flow's tool stage) is refused before anything is sent: the Runtime runs
+     * no code of yours during a session. `implementationVersion` defaults to
+     * `NYLORUN_IMPLEMENTATION_VERSION`, else `dev`.
+     */
+    saveAgent(agent: AgentSource | BuiltWorkflow, options?: {
+        implementationVersion?: string;
         requestId?: string;
     }): Promise<unknown>;
     createSession(options: CreateSessionOptions): Promise<SessionClient>;
-    createVault(options: {
-        name: string;
-        ownerUserId: string;
-        metadata?: Record<string, string>;
-        idempotencyKey: string;
-        requestId?: string;
-    }): Promise<VaultInfo>;
-    listVaults(ownerUserId: string, signal?: AbortSignal): Promise<{
-        vaults: VaultInfo[];
-    }>;
-    getVault(vaultId: string, signal?: AbortSignal): Promise<VaultInfo>;
-    deleteVault(vaultId: string): Promise<{
-        id: string;
-    }>;
-    createCredential(vaultId: string, options: {
-        name: string;
-        idempotencyKey: string;
-        requestId?: string;
-        auth: {
-            type: "bearer";
-            url: string;
-            token: string;
-        } | {
-            type: "oauth";
-            url: string;
-            accessToken: string;
-            expiresAt?: string | null;
-            refresh?: {
-                tokenEndpoint: string;
-                clientId: string;
-                refreshToken: string;
-                tokenEndpointAuth: {
-                    type: "none";
-                } | {
-                    type: "client_secret_basic";
-                    clientSecret: string;
-                } | {
-                    type: "client_secret_post";
-                    clientSecret: string;
-                };
-            };
-        };
-    }): Promise<CredentialInfo>;
-    listCredentials(vaultId: string, signal?: AbortSignal): Promise<{
-        credentials: CredentialInfo[];
-    }>;
-    getCredential(vaultId: string, credentialId: string, signal?: AbortSignal): Promise<CredentialInfo>;
-    rotateCredential(vaultId: string, credentialId: string, options: {
-        idempotencyKey: string;
-        requestId?: string;
-        auth: {
-            type: "bearer";
-            token: string;
-        } | {
-            type: "oauth";
-            accessToken: string;
-            expiresAt?: string | null;
-        };
-    }): Promise<CredentialInfo>;
-    deleteCredential(vaultId: string, credentialId: string): Promise<{
-        id: string;
-    }>;
     session(sessionId: string): SessionClient;
 }
 export type CommandOptions = {
@@ -225,42 +169,80 @@ export declare class SessionClient {
         cursor: string | null;
         requestId: string;
     }>;
-    /** `agent` narrows to one agent used as a tool: its delegationId or its path. */
-    history(options?: {
+    manifest(options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        sessionId: string;
+        agentId: string;
+        manifestHash: string;
+        implementationVersion: string;
+        manifest: Record<string, unknown>;
+    }>;
+    usage(options?: {
+        turnId?: string;
+        signal?: AbortSignal;
+    }): Promise<{
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+        cachedTokens: number;
+        cacheWriteTokens: number;
+        reasoningTokens: number;
+        costUsd: number;
+        sessionId: string;
+        turnId: string | null;
+        asOf: string;
+        calls: number;
+        duplicates: number;
+        unpricedCalls: number;
+        unreportedCalls: number;
+        unknownQualityCalls: number;
+    }>;
+    modelCalls(options?: {
+        turnId?: string;
+        limit?: number;
         cursor?: string;
-        agent?: string;
         signal?: AbortSignal;
     }): Promise<{
-        items: ({
-            schema: "nylorun.event/2";
-            eventId: string;
-            tenantId: string;
+        calls: {
+            id: string;
             sessionId: string;
-            runId: string | null;
-            turnId: string | null;
-            incarnation: number;
-            epoch: number;
-            seq: number;
-            cursor: string;
-            time: string;
-            schemaVersion: number;
-            source: {
-                kind: "api" | "controller" | "edge" | "egress-gate" | "evidence" | "harness" | "human" | "init" | "loop" | "model-gate" | "operator" | "sandboxd" | "supervisor" | "tool-gate";
-                id: string;
-            };
-            evidence: "asserted" | "attested" | "claimed" | "measured" | "observed";
-            trace?: {
-                traceId: string;
-                spanId: string;
-                parentSpanId?: string | undefined;
-            } | undefined;
-            visibility: "internal" | "public" | "restricted";
-            retention: "full" | "metadata";
-            type: string;
-            payload: unknown;
-        } | import("@nylorun/core/contracts").SessionEvent)[];
-        cursor: string | null;
+            turnId: string;
+            agentId: string;
+            provider: string | null;
+            model: string | null;
+            at: string;
+            outcome: "completed" | "failed";
+            usage: {
+                inputTokens: number;
+                outputTokens: number;
+                totalTokens: number;
+                cachedTokens: number;
+                cacheWriteTokens: number;
+                reasoningTokens: number;
+                costUsd: number;
+                duplicate: boolean;
+                tokensReported: boolean | null;
+                costKnown: boolean | null;
+            } | null;
+        }[];
+        nextCursor: string | null;
+        asOf: string;
+    }>;
+    /** `agent` narrows to one agent used as a tool: its delegationId or its path. */
+    history(options: {
+        cursor?: string;
+        agent?: string;
+        signal?: AbortSignal;
+        limit: number;
+    }): Promise<SessionItemsResponse & {
+        tail: boolean;
     }>;
+    history(options?: {
+        cursor?: string;
+        agent?: string;
+        signal?: AbortSignal;
+    }): Promise<SessionItemsResponse>;
     observe(options?: {
         cursor?: string;
         signal?: AbortSignal;
@@ -303,6 +285,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 } from "./access.js";
 export { SandboxesClient } from "./sandboxes.js";
 export type { ForSessionOptions, SandboxSpec, SessionSandboxHandle } from "./sandboxes.js";