@nylorun/agents 0.14.0-beta → 0.16.1-beta

package/dist/session-client.d.ts

@@ -3,10 +3,12 @@
  * 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 { 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 = {
@@ -63,7 +65,7 @@ export declare class AgentsClient {
      * themselves and hold the key; nothing is minted, cached or refreshed.
      */
     as(subject: string, options?: ActAsOptions): AgentsClient;
-    /** The signing keys and the public keys that verify delivery tokens. Application key only. */
+    /** 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
@@ -72,101 +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;
-        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`.
+     * 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`.
      */
-    createVault(options: {
-        name: string;
-        metadata?: Record<string, string>;
-        idempotencyKey: string;
+    saveAgent(agent: AgentSource | BuiltWorkflow, options?: {
+        implementationVersion?: string;
         requestId?: string;
-    } & ({
-        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>;
-    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;
-    }>;
+    }): Promise<unknown>;
+    createSession(options: CreateSessionOptions): Promise<SessionClient>;
     session(sessionId: string): SessionClient;
 }
 export type CommandOptions = {
@@ -230,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;
@@ -308,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, SigningKeysClient } from "./access.js";
+export { AccessClient } from "./access.js";
 export { SandboxesClient } from "./sandboxes.js";
 export type { ForSessionOptions, SandboxSpec, SessionSandboxHandle } from "./sandboxes.js";

package/dist/session-client.js

@@ -1,11 +1,13 @@
-import { SANDBOX_TOOL_NAMES, delegateOf, isBuiltWorkflow, isSandboxToolName, } from "@nylorun/core/define";
+import { SANDBOX_TOOL_NAMES, codeToolRefusal, delegateOf, isBuiltWorkflow, isSandboxToolName, } from "@nylorun/core/define";
 import { z } from "zod";
 import { SCOPES_HEADER, SUBJECT_HEADER } from "@nylorun/core/compatibility";
-import { parseSessionEvent, parseSubjectHeaders, } from "@nylorun/core/contracts";
+import { SessionManifestViewSchema, SessionUsageTotalsSchema, ModelCallsPageSchema, parseSessionEvent, parseSubjectHeaders, } 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 { Transport, id, segment } from "./http.js";
+import { FilesClient } from "./files.js";
+import { Transport, env, id, segment } from "./http.js";
 import { observeSSE } from "./sse.js";
 function sessionSandboxOf(transport, sessionId) {
     const call = (tool, args) => transport.json(`/v1/sessions/${segment(sessionId)}/sandbox/${segment(tool)}`, "POST", args);
@@ -28,8 +30,8 @@ function linkedSessionId(event) {
         ? sessionId
         : undefined;
 }
-const middlewareClosure = "Hosted definitions support declarative capabilities and before/after hooks, not middleware closures";
-/** The agent's declarations, then those of each agent it uses as a tool, keyed `<child>/<capability>`. */
+const middlewareClosure = "Hosted definitions support declarative capabilities, not middleware closures";
+/** The agent's declarations, then those of each agent it uses as a tool. */
 function declarationsOf(agent) {
     if (isBuiltWorkflow(agent) || agent.manifest.kind === "workflow")
         return [];
@@ -39,30 +41,26 @@ function declarationsOf(agent) {
     const binding = built.getBinding?.();
     if (!binding || !("declarations" in binding))
         return [];
-    const found = (binding.declarations ?? []).map((item) => ({ key: item.id, item }));
+    const found = [...(binding.declarations ?? [])];
     for (const tool of binding.tools ?? []) {
         const delegate = delegateOf(tool);
-        const child = delegate?.agent;
-        for (const item of child?.getBinding().declarations ?? [])
-            found.push({ key: `${child.id}/${item.id}`, item });
-        // A flow agent used as a tool: its agents' declarations, keyed `<flow>/<agent>/<capability>`.
-        const flow = delegate?.workflow;
-        for (const leaf of Object.values(flow?.getBinding().agents ?? {}))
-            for (const item of leaf.declarations ?? [])
-                found.push({ key: `${flow.id}/${leaf.manifest.id}/${item.id}`, item });
+        found.push(...(delegate?.agent?.getBinding().declarations ?? []));
+        // A flow agent used as a tool: its agents' declarations.
+        for (const leaf of Object.values(delegate?.workflow?.getBinding().agents ?? {}))
+            found.push(...(leaf.declarations ?? []));
     }
     return found;
 }
-function pluginRootsOf(agent) {
-    const roots = {};
-    for (const { key, item } of declarationsOf(agent))
-        if (item.pluginRoot)
-            roots[key] = item.pluginRoot;
-    return Object.keys(roots).length === 0 ? undefined : roots;
+/** The bytes of every skill file the agent's definition names, by `sha256:<hex>`. */
+function skillFilesOf(agent, into = new Map()) {
+    for (const item of declarationsOf(agent))
+        for (const [sha256, source] of Object.entries(item.skillFiles ?? {}))
+            into.set(sha256, source);
+    return into;
 }
 /** Closures stay on the live binding. The published manifest cannot name them. */
 export function assertNoMiddlewareClosures(agent) {
-    if (declarationsOf(agent).some(({ item }) => item.hasMiddleware))
+    if (declarationsOf(agent).some((item) => item.hasMiddleware))
         throw new Error(middlewareClosure);
 }
 export class AgentsClient {
@@ -95,7 +93,7 @@ export class AgentsClient {
             subject,
         });
     }
-    /** The signing keys and the public keys that verify delivery tokens. Application key only. */
+    /** The public keys that verify the tokens the Tenant signs. */
     get access() {
         return new AccessClient(this.transport);
     }
@@ -110,10 +108,17 @@ export class AgentsClient {
     get artifacts() {
         return new ArtifactsClient(this.transport);
     }
+    /** Definition files: the skill files a definition names, by content hash. */
+    get files() {
+        return new FilesClient(this.transport);
+    }
     /** The Runtime's protocol features, including optional ones such as `transcript-events`. */
     hostFeatures(options = {}) {
         return this.transport.hostFeatures(options.signal);
     }
+    get sessions() {
+        return new SessionsReadClient(this.transport);
+    }
     listAgents(options = {}) {
         return this.transport.json("/v1/agents", "GET", undefined, options.signal);
     }
@@ -123,44 +128,35 @@ export class AgentsClient {
             : "";
         return this.transport.json(`/v1/sessions${query}`, "GET", undefined, options.signal);
     }
-    async saveAgent(agent, options) {
-        if (isBuiltWorkflow(agent) && agent.manifest.workflowSchemaVersion === 2) {
-            // A v2 workflow embeds its agents: one document, carrying their plugin roots.
-            const pluginRoots = {};
+    /**
+     * 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`.
+     */
+    async saveAgent(agent, options = {}) {
+        const files = new Map();
+        if (isBuiltWorkflow(agent)) {
+            // A flow agent embeds its agents: one document, carrying their files.
             for (const binding of Object.values(agent.getBinding().agents)) {
                 const leaf = { id: binding.manifest.id, manifest: binding.manifest, getBinding: () => binding };
                 assertNoMiddlewareClosures(leaf);
-                for (const [key, root] of Object.entries(pluginRootsOf(leaf) ?? {}))
-                    pluginRoots[`${leaf.id}/${key}`] = root;
+                skillFilesOf(leaf, files);
             }
-            return this.transport.json(`/v1/agents/${segment(agent.id)}`, "PUT", {
-                requestId: options.requestId ?? id(),
-                manifest: agent.manifest,
-                implementationVersion: options.implementationVersion,
-                ...(Object.keys(pluginRoots).length === 0 ? {} : { pluginRoots }),
-            });
         }
-        if (isBuiltWorkflow(agent)) {
-            for (const binding of Object.values(agent.getBinding().agents)) {
-                await this.saveAgent({
-                    id: binding.manifest.id,
-                    manifest: binding.manifest,
-                    getBinding: () => binding,
-                }, options);
-            }
-            return this.transport.json(`/v1/agents/${segment(agent.id)}`, "PUT", {
-                requestId: options.requestId ?? id(),
-                manifest: agent.manifest,
-                implementationVersion: options.implementationVersion,
-            });
+        else {
+            assertNoMiddlewareClosures(agent);
+            skillFilesOf(agent, files);
         }
-        assertNoMiddlewareClosures(agent);
-        const pluginRoots = pluginRootsOf(agent);
+        const refusal = codeToolRefusal(agent.manifest);
+        if (refusal)
+            throw new Error(refusal);
+        await this.files.ensure(files);
         return this.transport.json(`/v1/agents/${segment(agent.id)}`, "PUT", {
             requestId: options.requestId ?? id(),
             manifest: agent.manifest,
-            implementationVersion: options.implementationVersion,
-            ...(pluginRoots === undefined ? {} : { pluginRoots }),
+            implementationVersion: options.implementationVersion ?? env("NYLORUN_IMPLEMENTATION_VERSION") ?? "dev",
         });
     }
     async createSession(options) {
@@ -178,58 +174,6 @@ 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,
-            ...(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(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);
-    }
-    deleteVault(vaultId) {
-        return this.transport.json(`/v1/vaults/${segment(vaultId)}`, "DELETE");
-    }
-    createCredential(vaultId, options) {
-        return this.transport.json(`/v1/vaults/${segment(vaultId)}/credentials`, "POST", {
-            requestId: options.requestId ?? id(),
-            idempotencyKey: options.idempotencyKey,
-            name: options.name,
-            auth: options.auth,
-        });
-    }
-    listCredentials(vaultId, signal) {
-        return this.transport.json(`/v1/vaults/${segment(vaultId)}/credentials`, "GET", undefined, signal);
-    }
-    getCredential(vaultId, credentialId, signal) {
-        return this.transport.json(`/v1/vaults/${segment(vaultId)}/credentials/${segment(credentialId)}`, "GET", undefined, signal);
-    }
-    rotateCredential(vaultId, credentialId, options) {
-        return this.transport.json(`/v1/vaults/${segment(vaultId)}/credentials/${segment(credentialId)}`, "POST", {
-            requestId: options.requestId ?? id(),
-            idempotencyKey: options.idempotencyKey,
-            auth: options.auth,
-        });
-    }
-    deleteCredential(vaultId, credentialId) {
-        return this.transport.json(`/v1/vaults/${segment(vaultId)}/credentials/${segment(credentialId)}`, "DELETE");
-    }
     session(sessionId) {
         return new SessionClient(this.transport, sessionId);
     }
@@ -310,19 +254,45 @@ export class SessionClient {
             ...(options.reason ? { reason: options.reason } : {}),
         }, options.signal);
     }
-    /** `agent` narrows to one agent used as a tool: its delegationId or its path. */
+    async manifest(options = {}) {
+        await this.transport.requireFeature("session-reads", options.signal);
+        return SessionManifestViewSchema.parse(await this.transport.json(`${this.path}/manifest`, "GET", undefined, options.signal));
+    }
+    async usage(options = {}) {
+        await this.transport.requireFeature("session-reads", options.signal);
+        const query = new URLSearchParams();
+        if (options.turnId !== undefined)
+            query.set("turnId", options.turnId);
+        return SessionUsageTotalsSchema.parse(await this.transport.json(`${this.path}/usage${query.size ? `?${query}` : ""}`, "GET", undefined, options.signal));
+    }
+    async modelCalls(options = {}) {
+        await this.transport.requireFeature("session-reads", options.signal);
+        const query = new URLSearchParams({ limit: String(options.limit ?? 50) });
+        if (options.turnId !== undefined)
+            query.set("turnId", options.turnId);
+        if (options.cursor !== undefined)
+            query.set("cursor", options.cursor);
+        return ModelCallsPageSchema.parse(await this.transport.json(`${this.path}/calls/model?${query}`, "GET", undefined, options.signal));
+    }
     async history(options = {}) {
         const query = new URLSearchParams();
         if (options.cursor)
             query.set("cursor", options.cursor);
         if (options.agent)
             query.set("agent", options.agent);
+        if (options.limit !== undefined) {
+            await this.transport.requireFeature("session-reads", options.signal);
+            query.set("limit", String(options.limit));
+        }
         const search = query.toString();
-        const page = z
-            .object({ items: z.array(z.unknown()), cursor: z.string().nullable() })
-            .parse(await this.transport.json(`${this.path}/items${search ? `?${search}` : ""}`, "GET", undefined, options.signal));
+        const schema = z.object({ items: z.array(z.unknown()), cursor: z.string().nullable() });
+        const page = (options.limit === undefined ? schema : schema.extend({ tail: z.boolean() })).parse(await this.transport.json(`${this.path}/items${search ? `?${search}` : ""}`, "GET", undefined, options.signal));
         // Typed when the catalog knows the type; a newer Runtime's type stays a bare envelope.
-        return { items: page.items.map(parseSessionEvent), cursor: page.cursor };
+        return {
+            items: page.items.map(parseSessionEvent),
+            cursor: page.cursor,
+            ...("tail" in page ? { tail: page.tail } : {}),
+        };
     }
     async *observe(options = {}) {
         if (!options.follow) {
@@ -401,5 +371,5 @@ export class SessionClient {
     }
 }
 export { RuntimeError, IncompatibleRuntimeError } from "./http.js";
-export { AccessClient, SigningKeysClient } from "./access.js";
+export { AccessClient } from "./access.js";
 export { SandboxesClient } from "./sandboxes.js";

package/dist/skills/index.d.ts

@@ -1,5 +1,5 @@
 export { skills } from "./skills.js";
 export type { SkillsCapability, SkillsOptions } from "./skills.js";
 export { loadSkillsFromDirectory, resolveSkillsRoot, parseSkill, SkillsError, } from "./load.js";
-export type { SkillDiagnostic } from "./load.js";
+export type { LoadedSkill, SkillDiagnostic } from "./load.js";
 export { formatSkillCatalog, SKILLS_USAGE } from "./catalog.js";

package/dist/skills/load.d.ts

@@ -1,4 +1,4 @@
-import type { SkillRecord } from "@nylorun/core/define";
+import { type SkillFileSource } from "@nylorun/core/define";
 export interface SkillDiagnostic {
     readonly severity: "info" | "warning";
     readonly code: string;
@@ -10,16 +10,27 @@ export declare class SkillsError extends Error {
     readonly diagnostics: readonly SkillDiagnostic[];
     constructor(code: string, message: string, diagnostics?: readonly SkillDiagnostic[]);
 }
+/** One skill read from its folder: what the manifest names, and where each file's bytes are. */
+export interface LoadedSkill {
+    readonly name: string;
+    readonly description: string;
+    /** Every file of the folder by its `/`-separated path, as `sha256:<hex>`. */
+    readonly files: Readonly<Record<string, string>>;
+    /** Each file's bytes, by `sha256:<hex>`, for the client to upload. */
+    readonly sources: Readonly<Record<string, SkillFileSource>>;
+}
 /** Resolve a skills catalog directory; throws when missing or not a directory. */
 export declare function resolveSkillsRoot(directory: string): string;
 /**
  * Load Agent Skills (agentskills.io) from a catalog directory.
- * Each immediate subdirectory with a valid SKILL.md becomes one skill.
+ * Each immediate subdirectory with a valid SKILL.md becomes one skill, with every file of its
+ * folder (text or binary) hashed. Throws `SkillsError` for a skill the Runtime cannot hold: a
+ * file over 10 MiB, more than 500 files, or a path a manifest cannot name.
  */
 export declare function loadSkillsFromDirectory(directory: string, diagnostics: SkillDiagnostic[], options?: {
     readonly boundary?: string;
     readonly codePrefix?: string;
-}): Readonly<Record<string, SkillRecord>>;
+}): Readonly<Record<string, LoadedSkill>>;
 export declare function parseSkill(text: string, directoryName: string): {
     name: string;
     description: string;