@forestadmin/mcp-server 1.21.0 → 1.22.0

package/dist/file-uploads/file-reference.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UPLOADED_FILE_PREFIX = void 0;
+exports.default = parseFileReference;
+/**
+ * Sentinel prefix used inside action form values, e.g.
+ *   { "document": "$uploadedFile:<jwt>" }
+ * A string rather than an object, so it passes the agent-client field validation and stays
+ * cheap when getActionForm echoes it back into the model's context.
+ */
+exports.UPLOADED_FILE_PREFIX = '$uploadedFile:';
+/**
+ * Isolated so that the file URIs the MCP specification is designing (SEP-2631) can be recognized
+ * here without touching the resolution path.
+ */
+function parseFileReference(value) {
+    if (typeof value !== 'string' || !value.startsWith(exports.UPLOADED_FILE_PREFIX))
+        return null;
+    return value.slice(exports.UPLOADED_FILE_PREFIX.length);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1yZWZlcmVuY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZmlsZS11cGxvYWRzL2ZpbGUtcmVmZXJlbmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQVlBLHFDQUlDO0FBaEJEOzs7OztHQUtHO0FBQ1UsUUFBQSxvQkFBb0IsR0FBRyxnQkFBZ0IsQ0FBQztBQUVyRDs7O0dBR0c7QUFDSCxTQUF3QixrQkFBa0IsQ0FBQyxLQUFjO0lBQ3ZELElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxJQUFJLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyw0QkFBb0IsQ0FBQztRQUFFLE9BQU8sSUFBSSxDQUFDO0lBRXRGLE9BQU8sS0FBSyxDQUFDLEtBQUssQ0FBQyw0QkFBb0IsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUNsRCxDQUFDIn0=

package/dist/file-uploads/handles.d.ts

@@ -0,0 +1,11 @@
+export interface UploadHandleClaims {
+    key: string;
+    name: string;
+    mimeType: string;
+    sha256Base64?: string;
+}
+export declare function signUploadHandle(claims: UploadHandleClaims & {
+    userId: number | string;
+}, authSecret: string, ttlSeconds: number): string;
+export declare function verifyUploadHandle(handle: string, userId: number | string, authSecret: string): UploadHandleClaims;
+//# sourceMappingURL=handles.d.ts.map

package/dist/file-uploads/handles.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signUploadHandle = signUploadHandle;
+exports.verifyUploadHandle = verifyUploadHandle;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const HANDLE_TYPE = 'mcp-upload';
+function signUploadHandle(claims, authSecret, ttlSeconds) {
+    return jsonwebtoken_1.default.sign({
+        type: HANDLE_TYPE,
+        key: claims.key,
+        name: claims.name,
+        mime: claims.mimeType,
+        uploader: String(claims.userId),
+        ...(claims.sha256Base64 && { sha256: claims.sha256Base64 }),
+    }, authSecret, { expiresIn: ttlSeconds });
+}
+function verifyUploadHandle(handle, userId, authSecret) {
+    const decoded = jsonwebtoken_1.default.verify(handle, authSecret, { algorithms: ['HS256'] });
+    // The handle is signed with the secret that also signs access tokens, so the type claim is
+    // what keeps an access token from being redeemed as an upload handle.
+    if (decoded?.type !== HANDLE_TYPE)
+        throw new Error('Not an upload handle');
+    if (decoded.uploader !== String(userId))
+        throw new Error('Handle was issued to another user');
+    // key feeds storage.download and mime lands in the stored file, so neither may be undefined.
+    if (typeof decoded.key !== 'string' ||
+        typeof decoded.name !== 'string' ||
+        typeof decoded.mime !== 'string') {
+        throw new Error('Malformed upload handle');
+    }
+    return {
+        key: decoded.key,
+        name: decoded.name,
+        mimeType: decoded.mime,
+        sha256Base64: decoded.sha256,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZGxlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maWxlLXVwbG9hZHMvaGFuZGxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQVdBLDRDQWlCQztBQUVELGdEQWtDQztBQWhFRCxnRUFBd0M7QUFFeEMsTUFBTSxXQUFXLEdBQUcsWUFBWSxDQUFDO0FBU2pDLFNBQWdCLGdCQUFnQixDQUM5QixNQUF3RCxFQUN4RCxVQUFrQixFQUNsQixVQUFrQjtJQUVsQixPQUFPLHNCQUFZLENBQUMsSUFBSSxDQUN0QjtRQUNFLElBQUksRUFBRSxXQUFXO1FBQ2pCLEdBQUcsRUFBRSxNQUFNLENBQUMsR0FBRztRQUNmLElBQUksRUFBRSxNQUFNLENBQUMsSUFBSTtRQUNqQixJQUFJLEVBQUUsTUFBTSxDQUFDLFFBQVE7UUFDckIsUUFBUSxFQUFFLE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDO1FBQy9CLEdBQUcsQ0FBQyxNQUFNLENBQUMsWUFBWSxJQUFJLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxZQUFZLEVBQUUsQ0FBQztLQUM1RCxFQUNELFVBQVUsRUFDVixFQUFFLFNBQVMsRUFBRSxVQUFVLEVBQUUsQ0FDMUIsQ0FBQztBQUNKLENBQUM7QUFFRCxTQUFnQixrQkFBa0IsQ0FDaEMsTUFBYyxFQUNkLE1BQXVCLEVBQ3ZCLFVBQWtCO0lBRWxCLE1BQU0sT0FBTyxHQUFHLHNCQUFZLENBQUMsTUFBTSxDQUFDLE1BQU0sRUFBRSxVQUFVLEVBQUUsRUFBRSxVQUFVLEVBQUUsQ0FBQyxPQUFPLENBQUMsRUFBRSxDQU9oRixDQUFDO0lBRUYsMkZBQTJGO0lBQzNGLHNFQUFzRTtJQUN0RSxJQUFJLE9BQU8sRUFBRSxJQUFJLEtBQUssV0FBVztRQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsc0JBQXNCLENBQUMsQ0FBQztJQUMzRSxJQUFJLE9BQU8sQ0FBQyxRQUFRLEtBQUssTUFBTSxDQUFDLE1BQU0sQ0FBQztRQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMsbUNBQW1DLENBQUMsQ0FBQztJQUU5Riw2RkFBNkY7SUFDN0YsSUFDRSxPQUFPLE9BQU8sQ0FBQyxHQUFHLEtBQUssUUFBUTtRQUMvQixPQUFPLE9BQU8sQ0FBQyxJQUFJLEtBQUssUUFBUTtRQUNoQyxPQUFPLE9BQU8sQ0FBQyxJQUFJLEtBQUssUUFBUSxFQUNoQyxDQUFDO1FBQ0QsTUFBTSxJQUFJLEtBQUssQ0FBQyx5QkFBeUIsQ0FBQyxDQUFDO0lBQzdDLENBQUM7SUFFRCxPQUFPO1FBQ0wsR0FBRyxFQUFFLE9BQU8sQ0FBQyxHQUFHO1FBQ2hCLElBQUksRUFBRSxPQUFPLENBQUMsSUFBSTtRQUNsQixRQUFRLEVBQUUsT0FBTyxDQUFDLElBQUk7UUFDdEIsWUFBWSxFQUFFLE9BQU8sQ0FBQyxNQUFNO0tBQzdCLENBQUM7QUFDSixDQUFDIn0=

package/dist/file-uploads/resolve.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedFileUploads } from './types';
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+/**
+ * Only executeAction resolves references. getActionForm echoes field values back to the model,
+ * and a resolved file there would put the content back into the model's context.
+ */
+export default function resolveUploadedFileValues(values: Record<string, unknown>, authInfo: AuthInfo | undefined, uploads: ResolvedFileUploads | undefined): Promise<Record<string, unknown>>;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/file-uploads/resolve.js

@@ -0,0 +1,145 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = resolveUploadedFileValues;
+const crypto = __importStar(require("crypto"));
+const file_reference_1 = __importDefault(require("./file-reference"));
+const handles_1 = require("./handles");
+// Keyed by reference so one used by several fields is downloaded once. The field is the first
+// one that mentioned it, which is what error messages name.
+function collectReferences(values) {
+    const references = new Map();
+    for (const [field, value] of Object.entries(values)) {
+        const candidates = Array.isArray(value) ? value : [value];
+        candidates.forEach(candidate => {
+            const handle = (0, file_reference_1.default)(candidate);
+            if (handle && !references.has(candidate)) {
+                references.set(candidate, { field, handle });
+            }
+        });
+    }
+    return references;
+}
+// The contract puts no bound on a storage read. Without this, a backend that stops answering
+// holds its concurrency slot forever while the caller's own request timeout fires, so the
+// failure would be invisible here and the slots would drain away one by one.
+function withTimeout(operation, seconds, promise) {
+    let timer;
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`${operation} timed out after ${seconds}s`)), seconds * 1000);
+        }),
+    ]).finally(() => clearTimeout(timer));
+}
+async function download(field, claims, uploads) {
+    const tooLarge = (bytes) => new Error(`Field "${field}": uploaded file is ${bytes} bytes, above the ${uploads.maxBytes} byte limit`);
+    // A pre-authorized upload URL cannot always cap the object size, so the limit is enforced here,
+    // before the bytes are read whenever the backend can report a size. Wrapped like the download
+    // below: a backend that reports size from object metadata rejects on a missing key, which is the
+    // likeliest failure of the whole flow — the upload was blocked. Raw, that reaches the model as a
+    // bare SDK string with no field name and no diagnosis.
+    const size = await withTimeout(`Field "${field}": reading the size of the uploaded file`, uploads.downloadTimeoutSeconds, uploads.storage.getSize(claims.key)).catch((error) => {
+        throw new Error(`Field "${field}": could not read the uploaded file. ` +
+            `Did the upload to uploadUrl succeed? (${error.message})`);
+    });
+    if (typeof size === 'number' && Number.isFinite(size) && size > uploads.maxBytes) {
+        throw tooLarge(size);
+    }
+    // A backend that honours the contract rejects a missing object, so this is the shape the most
+    // likely mistake takes: the handle was never uploaded to. The raw message alone reads as an
+    // infrastructure failure. The key it may contain is already in the model's context, inside the
+    // handle it just sent.
+    const buffer = await withTimeout(`Field "${field}": reading the uploaded file`, uploads.downloadTimeoutSeconds, uploads.storage.download(claims.key)).catch((error) => {
+        throw new Error(`Field "${field}": could not read the uploaded file. ` +
+            `Did the upload to uploadUrl succeed? (${error.message})`);
+    });
+    // Re-checked after download because getSize is advisory, and because the object can be
+    // replaced between the two calls.
+    if (buffer.length > uploads.maxBytes)
+        throw tooLarge(buffer.length);
+    // Even if the upload URL leaked and someone overwrote the object, content substituted after
+    // the client pinned a digest cannot be redeemed.
+    if (claims.sha256Base64) {
+        const digest = crypto.createHash('sha256').update(new Uint8Array(buffer)).digest('base64');
+        if (digest !== claims.sha256Base64) {
+            throw new Error(`Field "${field}": uploaded file does not match the sha256 it was pinned to`);
+        }
+    }
+    return { buffer, mimeType: claims.mimeType, name: claims.name };
+}
+/**
+ * Only executeAction resolves references. getActionForm echoes field values back to the model,
+ * and a resolved file there would put the content back into the model's context.
+ */
+async function resolveUploadedFileValues(values, authInfo, uploads) {
+    const references = collectReferences(values);
+    if (references.size === 0)
+        return values;
+    if (!uploads) {
+        throw new Error('File uploads are not configured on this server. ' +
+            'Ask the administrator to set the fileUploads option to enable action file fields.');
+    }
+    const userId = authInfo?.extra?.userId;
+    if (userId === undefined || userId === null) {
+        throw new Error('Cannot resolve uploaded files without an authenticated user');
+    }
+    // Verified before acquiring a download slot: it is pure CPU, and it gates everything
+    // expensive, so a batch of forged handles is rejected instead of queueing behind the limit.
+    const verified = [...references].map(([reference, { field, handle }]) => {
+        try {
+            return { field, reference, claims: (0, handles_1.verifyUploadHandle)(handle, userId, uploads.authSecret) };
+        }
+        catch (error) {
+            // Reaching the model as a bare "jwt expired" names no field, and with several file fields in
+            // one form it names none of them.
+            throw new Error(`Field "${field}": this file handle is not usable (${error.message}). ` +
+                'Call requestActionFileUpload again and upload the file to the new destination.');
+        }
+    });
+    const files = new Map(await Promise.all(verified.map(async ({ field, reference, claims }) => [
+        reference,
+        await uploads.limitDownload(() => download(field, claims, uploads)),
+    ])));
+    const substitute = (value) => files.get(value) ?? value;
+    return Object.fromEntries(Object.entries(values).map(([field, value]) => [
+        field,
+        Array.isArray(value) ? value.map(substitute) : substitute(value),
+    ]));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/file-uploads/semaphore.d.ts

@@ -0,0 +1,3 @@
+export type RunExclusive = <T>(task: () => Promise<T>) => Promise<T>;
+export default function createSemaphore(limit: number): RunExclusive;
+//# sourceMappingURL=semaphore.d.ts.map

package/dist/file-uploads/semaphore.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createSemaphore;
+function createSemaphore(limit) {
+    let active = 0;
+    const queue = [];
+    // The queue is deliberately unbounded: one action submits all its file references at once, so a
+    // cap would reject a form carrying more of them than the limit allows, every time. Each read is
+    // bounded by downloadTimeoutSeconds instead, which is what keeps the queue draining.
+    const acquire = () => new Promise(resolve => {
+        if (active < limit) {
+            active += 1;
+            resolve();
+        }
+        else {
+            queue.push(resolve);
+        }
+    });
+    const release = () => {
+        const next = queue.shift();
+        // The slot transfers to the waiting task, so active stays unchanged.
+        if (next)
+            next();
+        else
+            active -= 1;
+    };
+    return async (task) => {
+        await acquire();
+        try {
+            return await task();
+        }
+        finally {
+            release();
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VtYXBob3JlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ZpbGUtdXBsb2Fkcy9zZW1hcGhvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQSxrQ0FrQ0M7QUFsQ0QsU0FBd0IsZUFBZSxDQUFDLEtBQWE7SUFDbkQsSUFBSSxNQUFNLEdBQUcsQ0FBQyxDQUFDO0lBQ2YsTUFBTSxLQUFLLEdBQXNCLEVBQUUsQ0FBQztJQUVwQyxnR0FBZ0c7SUFDaEcsZ0dBQWdHO0lBQ2hHLHFGQUFxRjtJQUNyRixNQUFNLE9BQU8sR0FBRyxHQUFHLEVBQUUsQ0FDbkIsSUFBSSxPQUFPLENBQU8sT0FBTyxDQUFDLEVBQUU7UUFDMUIsSUFBSSxNQUFNLEdBQUcsS0FBSyxFQUFFLENBQUM7WUFDbkIsTUFBTSxJQUFJLENBQUMsQ0FBQztZQUNaLE9BQU8sRUFBRSxDQUFDO1FBQ1osQ0FBQzthQUFNLENBQUM7WUFDTixLQUFLLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ3RCLENBQUM7SUFDSCxDQUFDLENBQUMsQ0FBQztJQUVMLE1BQU0sT0FBTyxHQUFHLEdBQUcsRUFBRTtRQUNuQixNQUFNLElBQUksR0FBRyxLQUFLLENBQUMsS0FBSyxFQUFFLENBQUM7UUFFM0IscUVBQXFFO1FBQ3JFLElBQUksSUFBSTtZQUFFLElBQUksRUFBRSxDQUFDOztZQUNaLE1BQU0sSUFBSSxDQUFDLENBQUM7SUFDbkIsQ0FBQyxDQUFDO0lBRUYsT0FBTyxLQUFLLEVBQUssSUFBc0IsRUFBYyxFQUFFO1FBQ3JELE1BQU0sT0FBTyxFQUFFLENBQUM7UUFFaEIsSUFBSSxDQUFDO1lBQ0gsT0FBTyxNQUFNLElBQUksRUFBRSxDQUFDO1FBQ3RCLENBQUM7Z0JBQVMsQ0FBQztZQUNULE9BQU8sRUFBRSxDQUFDO1FBQ1osQ0FBQztJQUNILENBQUMsQ0FBQztBQUNKLENBQUMifQ==

package/dist/file-uploads/types.d.ts

@@ -0,0 +1,74 @@
+import type { RunExclusive } from './semaphore';
+import type { Logger } from '../server';
+/** Storage backend for the action file upload side-channel. See the README for the flow. */
+export interface UploadStorage {
+    /** The URL must be reachable by the MCP client, which is what uploads the bytes. */
+    createUploadUrl(params: {
+        key: string;
+        mimeType: string;
+        /** Advisory: the server re-verifies the digest after download regardless. */
+        sha256?: string;
+        expiresInSeconds: number;
+    }): Promise<{
+        url: string;
+        method?: string;
+        headers?: Record<string, string>;
+    }>;
+    /** Must reject when the object does not exist. */
+    download(key: string): Promise<Buffer>;
+    /**
+     * Size of the uploaded object, used to reject oversized uploads before downloading them.
+     * Return undefined when the backend cannot report it cheaply — `maxBytes` is then only
+     * enforced after the bytes are in memory, so the process holds the whole object either way.
+     *
+     * Rejecting is fine when the object is absent — reading its metadata is how most backends
+     * answer this, and a missing object is the likeliest outcome of the whole flow, the upload
+     * having been blocked. The rejection is reported to the caller with the field name and the
+     * message, so it does not have to be distinguished from an unreadable one here.
+     */
+    getSize(key: string): Promise<number | undefined>;
+}
+/**
+ * @experimental The MCP specification is still designing its own file transfer story
+ * (SEP-2631). The storage contract is expected to survive, but the `requestActionFileUpload` tool
+ * and the handle format may change to follow the specification once it lands.
+ */
+export interface FileUploadsOptions {
+    /**
+     * Where uploaded objects live between the upload and the action. Omit it and the server keeps
+     * them in memory, on its own origin — nothing to provision, but only correct for a single
+     * instance: see the README.
+     */
+    storage?: UploadStorage;
+    keyPrefix?: string;
+    uploadUrlTtlSeconds?: number;
+    /** Must stay longer than uploadUrlTtlSeconds, so a slow upload leaves time to run the action. */
+    handleTtlSeconds?: number;
+    maxBytes?: number;
+    maxConcurrentDownloads?: number;
+    /**
+     * Total size the in-memory store holds across all pending uploads. Defaults to 64 MiB. Has no
+     * effect once a `storage` is given.
+     */
+    ephemeralMaxTotalBytes?: number;
+    /**
+     * How long a single storage read may take. Keep it well under the request timeout of the
+     * clients calling the agent, so a slow backend fails here rather than being cut mid-flight.
+     * Defaults to 15 seconds.
+     */
+    downloadTimeoutSeconds?: number;
+}
+export interface ResolvedFileUploads {
+    storage: UploadStorage;
+    keyPrefix: string;
+    uploadUrlTtlSeconds: number;
+    handleTtlSeconds: number;
+    maxBytes: number;
+    downloadTimeoutSeconds: number;
+    ephemeralMaxTotalBytes: number;
+    authSecret: string;
+    limitDownload: RunExclusive;
+}
+export declare const DEFAULT_EPHEMERAL_MAX_TOTAL_BYTES: number;
+export declare function resolveFileUploads(options: FileUploadsOptions | undefined, authSecret: string, logger?: Logger): ResolvedFileUploads | undefined;
+//# sourceMappingURL=types.d.ts.map

package/dist/file-uploads/types.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EPHEMERAL_MAX_TOTAL_BYTES = void 0;
+exports.resolveFileUploads = resolveFileUploads;
+const semaphore_1 = __importDefault(require("./semaphore"));
+const DEFAULT_KEY_PREFIX = 'mcp-uploads/';
+const DEFAULT_UPLOAD_URL_TTL_SECONDS = 15 * 60;
+const DEFAULT_HANDLE_TTL_SECONDS = 45 * 60;
+const DEFAULT_MAX_BYTES = 20 * 1024 * 1024;
+const DEFAULT_MAX_CONCURRENT_DOWNLOADS = 5;
+const DEFAULT_DOWNLOAD_TIMEOUT_SECONDS = 15;
+// Deliberately absolute rather than a multiple of maxBytes: derived, raising the per-file limit
+// would multiply what the process can hold, which is the opposite of what setting it suggests.
+exports.DEFAULT_EPHEMERAL_MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+function positiveInteger(field, value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`Invalid fileUploads.${field} "${value}": it must be a positive integer.`);
+    }
+    return value;
+}
+function resolveFileUploads(options, authSecret, logger) {
+    if (!options)
+        return undefined;
+    if (!options.storage)
+        throw new Error('fileUploads.storage is required.');
+    const uploadUrlTtlSeconds = positiveInteger('uploadUrlTtlSeconds', options.uploadUrlTtlSeconds) ??
+        DEFAULT_UPLOAD_URL_TTL_SECONDS;
+    const handleTtlSeconds = positiveInteger('handleTtlSeconds', options.handleTtlSeconds) ?? DEFAULT_HANDLE_TTL_SECONDS;
+    const maxBytes = positiveInteger('maxBytes', options.maxBytes) ?? DEFAULT_MAX_BYTES;
+    const ephemeralMaxTotalBytes = positiveInteger('ephemeralMaxTotalBytes', options.ephemeralMaxTotalBytes) ??
+        exports.DEFAULT_EPHEMERAL_MAX_TOTAL_BYTES;
+    // A handle expiring before its upload URL means uploads succeed and every redemption then
+    // fails with a bare "jwt expired".
+    if (handleTtlSeconds <= uploadUrlTtlSeconds) {
+        logger?.('Warn', `fileUploads.handleTtlSeconds=${handleTtlSeconds} is shorter than ` +
+            `fileUploads.uploadUrlTtlSeconds=${uploadUrlTtlSeconds}: a slow upload will finish with ` +
+            'an already expired handle.');
+    }
+    return {
+        storage: options.storage,
+        keyPrefix: options.keyPrefix ?? DEFAULT_KEY_PREFIX,
+        uploadUrlTtlSeconds,
+        handleTtlSeconds,
+        maxBytes,
+        downloadTimeoutSeconds: positiveInteger('downloadTimeoutSeconds', options.downloadTimeoutSeconds) ??
+            DEFAULT_DOWNLOAD_TIMEOUT_SECONDS,
+        ephemeralMaxTotalBytes,
+        authSecret,
+        limitDownload: (0, semaphore_1.default)(positiveInteger('maxConcurrentDownloads', options.maxConcurrentDownloads) ??
+            DEFAULT_MAX_CONCURRENT_DOWNLOADS),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { default as ForestMCPServer } from './server';
 export type { ForestMCPServerOptions, HttpCallback, ToolName } from './server';
 export type { TokenTtlOptions } from './utils/token-ttl';
+export type { FileUploadsOptions, UploadStorage } from './file-uploads/types';
 export type { InProcessAgentDispatcher, InProcessDispatchRequest, InProcessDispatchResponse, } from './in-process-agent-dispatcher';
 export { MCP_PATHS, isMcpRoute, makeIsMcpRoute } from './mcp-paths';
 export { ForestServerClientImpl, createForestServerClient } from './http-client';

package/dist/index.js

@@ -14,4 +14,4 @@ Object.defineProperty(exports, "makeIsMcpRoute", { enumerable: true, get: functi
 var http_client_1 = require("./http-client");
 Object.defineProperty(exports, "ForestServerClientImpl", { enumerable: true, get: function () { return http_client_1.ForestServerClientImpl; } });
 Object.defineProperty(exports, "createForestServerClient", { enumerable: true, get: function () { return http_client_1.createForestServerClient; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEseUNBQXlDO0FBQ3pDLG1DQUFzRDtBQUE3QywwSEFBQSxPQUFPLE9BQW1CO0FBUW5DLHlDQUFvRTtBQUEzRCxzR0FBQSxTQUFTLE9BQUE7QUFBRSx1R0FBQSxVQUFVLE9BQUE7QUFBRSwyR0FBQSxjQUFjLE9BQUE7QUFDOUMsNkNBQWlGO0FBQXhFLHFIQUFBLHNCQUFzQixPQUFBO0FBQUUsdUhBQUEsd0JBQXdCLE9BQUEifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEseUNBQXlDO0FBQ3pDLG1DQUFzRDtBQUE3QywwSEFBQSxPQUFPLE9BQW1CO0FBU25DLHlDQUFvRTtBQUEzRCxzR0FBQSxTQUFTLE9BQUE7QUFBRSx1R0FBQSxVQUFVLE9BQUE7QUFBRSwyR0FBQSxjQUFjLE9BQUE7QUFDOUMsNkNBQWlGO0FBQXhFLHFIQUFBLHNCQUFzQixPQUFBO0FBQUUsdUhBQUEsd0JBQXdCLE9BQUEifQ==

package/dist/server.d.ts

@@ -1,4 +1,5 @@
 import './polyfills';
+import type { FileUploadsOptions } from './file-uploads/types';
 import type { ForestServerClient } from './http-client';
 import type { InProcessAgentDispatcher } from './in-process-agent-dispatcher';
 import type { TokenTtlOptions } from './utils/token-ttl';
@@ -8,7 +9,7 @@ export declare const LOGO_URL = "https://forest-assets.s3.us-east-1.amazonaws.co
 export type LogLevel = 'Debug' | 'Info' | 'Warn' | 'Error';
 export type Logger = (level: LogLevel, message: string) => void;
 export type HttpCallback = (req: http.IncomingMessage, res: http.ServerResponse, next?: () => void) => void;
-export type ToolName = 'describeCollection' | 'list' | 'listRelated' | 'create' | 'update' | 'delete' | 'associate' | 'dissociate' | 'getActionForm' | 'executeAction';
+export type ToolName = 'describeCollection' | 'list' | 'listRelated' | 'create' | 'update' | 'delete' | 'associate' | 'dissociate' | 'getActionForm' | 'executeAction' | 'requestActionFileUpload';
 /**
  * Options for configuring the Forest Admin MCP Server
  */
@@ -57,6 +58,16 @@ export interface ForestMCPServerOptions {
      * Omit to accept any dynamically registered client.
      */
     allowedOAuthClients?: string[];
+    /**
+     * Action file uploads are on by default, with the objects held in memory. Pass an object to
+     * configure them — a `storage` backend, size limits, ttls — or `false` to turn the feature off:
+     * no `requestActionFileUpload` tool, no upload endpoint, and `executeAction` stops mentioning
+     * either. See the README for the flow and the storage contract.
+     *
+     * @experimental Expected to change to follow the MCP file transfer specification once it
+     * lands (SEP-2631).
+     */
+    fileUploads?: false | FileUploadsOptions;
 }
 /**
  * Forest Admin MCP Server
@@ -80,6 +91,9 @@ export default class ForestMCPServer {
     private agentDispatcher?;
     private tokenTtl?;
     private allowedOAuthClients?;
+    private fileUploadsOptions?;
+    private fileUploads?;
+    private ephemeralStorage?;
     constructor(options?: ForestMCPServerOptions);
     private createDefaultForestServerClient;
     private fetchCollectionNames;