@strapi/upload 5.52.3 → 5.54.0

package/dist/server/src/mcp/handlers/write-handlers.d.ts

@@ -0,0 +1,66 @@
+import type { Core, Modules } from '@strapi/types';
+/**
+ * `media_update_asset` — edits the writable metadata of one asset.
+ *
+ * Gated on `plugin::upload.assets.update` and mirrors `PUT /upload/files/:id`: the same
+ * `findEntityAndCheckPermissions` row-level check, the same `updateFileInfo` service call, and
+ * the same `updatedBy` attribution from the session user.
+ *
+ * The response carries the updated asset through the read sanitizer, so a client can confirm
+ * the write without a second `media_get_asset` round-trip — and so provider fields stay
+ * invisible on the write path too.
+ */
+export declare const createMediaUpdateAssetHandler: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext) => ({ args, }: {
+    args: Record<string, unknown>;
+}) => Promise<Modules.MCP.McpToolHandlerReturn>;
+/**
+ * `media_move_assets` — moves assets between folders in bulk.
+ *
+ * Bulk with a per-id report, rather than all-or-nothing: an agent reorganising a library moves
+ * many assets at once, and one bad id among good ones must not discard the valid moves. Each
+ * asset is moved on its own, so a failure is confined to its own id and the response says exactly
+ * which ids to retry.
+ *
+ * That is why this does not reuse the admin `/actions/bulk-move` controller path, whose single
+ * transaction is all-or-nothing by construction (and which also handles folders, out of scope
+ * here). It goes through `updateFileInfo` instead — the same service `media_update_asset` and
+ * `PUT /upload/files/:id` use — which sets the `folder` relation, recomputes the private
+ * `folderPath`, attributes `updatedBy`, and emits `media.update` per asset. Replicating the
+ * controller's raw join-table writes would skip all four.
+ *
+ * The moves are sequential on purpose. Each one writes the join table and `folderPath` for its
+ * asset, and a bounded reorganisation (100 ids max, per the input schema) is not worth the
+ * connection-pool contention of firing them in parallel.
+ */
+export declare const createMediaMoveAssetsHandler: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext) => ({ args, }: {
+    args: Record<string, unknown>;
+}) => Promise<Modules.MCP.McpToolHandlerReturn>;
+/**
+ * `media_delete_assets` — previews or performs the permanent deletion of assets, in bulk.
+ *
+ * Two branches behind one tool, for the same reason as `media_delete_folder`: the preview and the
+ * deletion must agree on what would be destroyed, and splitting them across tools would both let
+ * the two drift apart and let an agent reach the destructive one without ever seeing a preview.
+ * `dryRun` defaults to true (see the input schema), so omitting the flag previews and deleting
+ * takes an explicit `dryRun: false`.
+ *
+ * Per-id, not all-or-nothing — the opposite of `media_delete_folder`, on purpose. A folder delete
+ * cascades, so a mixed id list there is refused outright rather than half-applied over an unknown
+ * amount of content. Here each id is exactly one asset, the blast radius of a bad one is nil, and
+ * the requirement is explicit: a bad id among good ones must not discard the valid deletions.
+ * The dry run reports the same per-id split, so an agent sees which ids will not resolve *before*
+ * anything is destroyed rather than after.
+ *
+ * This does not reuse `file.deleteByIds` (the admin `/actions/bulk-delete` path). That helper
+ * fires `upload.remove` under a single `Promise.all`, so the first rejection discards the report
+ * of everything already deleted — unrecoverable for an operation with no undo. The removals are
+ * driven one at a time here instead, through the same `upload.remove` service, which deletes the
+ * provider file and every generated format, emits `media.delete`, and then deletes the row.
+ *
+ * The deletions are sequential on purpose: each one performs provider I/O, and a bounded batch
+ * (100 ids max, per the input schema) is not worth firing at a provider in parallel.
+ */
+export declare const createMediaDeleteAssetsHandler: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext) => ({ args, }: {
+    args: Record<string, unknown>;
+}) => Promise<Modules.MCP.McpToolHandlerReturn>;
+//# sourceMappingURL=write-handlers.d.ts.map

package/dist/server/src/mcp/handlers/write-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-handlers.d.ts","sourceRoot":"","sources":["../../../../../server/src/mcp/handlers/write-handlers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAiEnD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,6BAA6B,GACxC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,MAIxB,WAEX;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,KAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CA4C7C,CAAC;AA8BF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,4BAA4B,GACvC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,MAIxB,WAEX;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,KAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAgF7C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,8BAA8B,GACzC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,MAIxB,WAEX;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B,KAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAmF7C,CAAC"}

package/dist/server/src/mcp/index.d.ts

@@ -0,0 +1,3 @@
+export { registerUploadMcpTools, buildUploadMcpToolDefinitions } from './register-upload-mcp-tools';
+export type { UploadMcpTool } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/mcp/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AACpG,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC"}

package/dist/server/src/mcp/permissions.d.ts

@@ -0,0 +1,22 @@
+import type { Core, Modules } from '@strapi/types';
+/**
+ * Builds an admin permissions manager for a media model bound to the MCP session's ability.
+ *
+ * MCP tool handlers have no Koa context, so they cannot rely on route policies: each handler must
+ * re-check permissions itself, exactly as the admin controllers do via `ctx.state.userAbility`.
+ * The declarative `auth.policies` on a tool definition already gates registration and invocation;
+ * this second check is what keeps a handler safe if it is ever called from another entry point.
+ *
+ * It is also the only check bound to a model. `plugin::upload.read` is registered in the
+ * `plugins` section with no subject (see the upload plugin bootstrap), so a tool's policies
+ * carry an action only — a subject-less grant registers as CASL `subject: 'all'`. Passing a
+ * model UID as the policy subject is rejected by the admin-token validation, so the file /
+ * folder distinction is enforced here, where the permissions manager is bound to the UID.
+ */
+export declare const createMediaPermissionsManager: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext, action: string, model: string) => any;
+/**
+ * Throws `ForbiddenError` unless the session's ability permits `action` on `model`.
+ * Mirrors the `if (!pm.isAllowed) return ctx.forbidden()` guard in the admin controllers.
+ */
+export declare const assertMediaPermission: (strapi: Core.Strapi, context: Modules.MCP.McpHandlerContext, action: string, model: string) => any;
+//# sourceMappingURL=permissions.d.ts.map

package/dist/server/src/mcp/permissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","sourceRoot":"","sources":["../../../../server/src/mcp/permissions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAEnD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,6BAA6B,GACxC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,EACtC,QAAQ,MAAM,EACd,OAAO,MAAM,QAMX,CAAC;AAEL;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAChC,QAAQ,IAAI,CAAC,MAAM,EACnB,SAAS,OAAO,CAAC,GAAG,CAAC,iBAAiB,EACtC,QAAQ,MAAM,EACd,OAAO,MAAM,QASd,CAAC"}

package/dist/server/src/mcp/register-upload-mcp-tools.d.ts

@@ -0,0 +1,29 @@
+import type { Core } from '@strapi/types';
+import type { UploadMcpTool } from './types';
+/**
+ * The Media Library MCP tools.
+ *
+ * Folder writes inherit the same `plugin::upload.assets.update` action rather than introducing a
+ * folder-specific one, matching what the admin UI enforces today. MCP-specific folder RBAC is
+ * out of scope.
+ *
+ * Renaming and moving are separate tools for both objects — rename/update changes attributes,
+ * move changes location — so an agent selects by intent instead of assembling a combined patch.
+ *
+ * The asset and folder tools stay separate for both move and delete, even though
+ * `/actions/bulk-move` accepts both id lists at once and `/actions/bulk-delete` accepts `fileIds`
+ * and `folderIds` together. Asset ids and folder ids are indistinguishable integers from separate
+ * namespaces, and both `media_list_assets` and `media_list_folders` return a plain `id`, so a
+ * combined tool would let an agent pass folder ids where assets were meant with nothing to
+ * object. On the delete side that mistake is unrecoverable, and two tools also let each
+ * description carry the warning matched to its own blast radius.
+ */
+export declare const buildUploadMcpToolDefinitions: () => UploadMcpTool[];
+/**
+ * Registers the Media Library MCP tools via `strapi.ai.mcp.registerTool()`.
+ * Must be called from the plugin register phase, before the MCP HTTP server starts.
+ */
+export declare const registerUploadMcpTools: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+//# sourceMappingURL=register-upload-mcp-tools.d.ts.map

package/dist/server/src/mcp/register-upload-mcp-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-upload-mcp-tools.d.ts","sourceRoot":"","sources":["../../../../server/src/mcp/register-upload-mcp-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAG1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAmC7C;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,6BAA6B,QAAO,aAAa,EAiH7D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,YAAY;IAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAA;CAAE,KAAG,IAO5E,CAAC"}

package/dist/server/src/mcp/sanitizers/sanitize-media.d.ts

@@ -0,0 +1,63 @@
+import type { MediaFolderNode } from '../schemas';
+type RawFolder = {
+    id?: unknown;
+    name?: unknown;
+    children?: unknown;
+};
+type RawAsset = Record<string, unknown> & {
+    folder?: RawFolder | null;
+};
+/**
+ * Projects a raw file row onto the MCP asset shape.
+ *
+ * This is an allowlist: every exposed key is named explicitly, so `provider`,
+ * `provider_metadata` (which can carry provider credentials), `hash`, `formats`, `related`,
+ * and the private `folderPath` never reach an MCP client — including after new fields are
+ * added to the file content-type.
+ */
+export declare const sanitizeMediaAsset: (asset: RawAsset) => {
+    id: number;
+    name: string;
+    alternativeText: string | null;
+    caption: string | null;
+    url: string;
+    mime: string;
+    size: number;
+    width: number | null;
+    height: number | null;
+    ext: string | null;
+    folder: {
+        id: number;
+        name: string;
+    } | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+};
+/**
+ * Projects the recursive output of `folder.getStructure()` onto `{ id, name, children }`,
+ * dropping `path` and `pathId` (internal materialized-path bookkeeping).
+ */
+export declare const sanitizeMediaFolderTree: (nodes: unknown) => MediaFolderNode[];
+/**
+ * Projects a raw folder row onto the MCP folder shape.
+ *
+ * An allowlist for the same reason as `sanitizeMediaAsset`: `path` and `pathId` are the internal
+ * materialized-path bookkeeping the folder service uses to cascade moves and deletes. Exposing
+ * them would invite an agent to treat them as addressable, and any field added to the folder
+ * content-type later stays invisible until it is named here on purpose.
+ */
+export declare const sanitizeMediaFolder: (folder: (RawFolder & Record<string, unknown>) | null | undefined) => {
+    createdAt: string | null;
+    updatedAt: string | null;
+    parent?: {
+        id: number;
+        name?: undefined;
+    } | {
+        id: number;
+        name: string;
+    } | null | undefined;
+    id: number;
+    name: string;
+} | null;
+export {};
+//# sourceMappingURL=sanitize-media.d.ts.map

package/dist/server/src/mcp/sanitizers/sanitize-media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize-media.d.ts","sourceRoot":"","sources":["../../../../../server/src/mcp/sanitizers/sanitize-media.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,KAAK,SAAS,GAAG;IACf,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,KAAK,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACxC,MAAM,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;CAC3B,CAAC;AAeF;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,QAAQ;;;;;;;;;;;;;;;;;CAqBjD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,KAAG,eAAe,EAQvE,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,CAAC,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS;;;;;;;;;;;;QA+BjE,CAAC"}

package/dist/server/src/mcp/schemas/index.d.ts

@@ -0,0 +1,3 @@
+export { mediaIdSchema, folderIdSchema, folderNameSchema, pageSchema, pageSizeSchema, sortSchema, mediaListAssetsInputSchema, mediaGetAssetInputSchema, mediaListFoldersInputSchema, mediaUpdateAssetInputSchema, mediaCreateFolderInputSchema, mediaRenameFolderInputSchema, mediaMoveFolderInputSchema, mediaDeleteFolderInputSchema, mediaMoveAssetsInputSchema, mediaDeleteAssetsInputSchema, } from './input-schemas';
+export { mediaAssetOutputSchema, mediaGetAssetOutputSchema, mediaListAssetsOutputSchema, mediaFolderNodeSchema, mediaListFoldersOutputSchema, mediaUpdateAssetOutputSchema, mediaFolderOutputSchema, mediaCreateFolderOutputSchema, mediaRenameFolderOutputSchema, mediaMoveFolderOutputSchema, mediaDeleteFolderOutputSchema, mediaMoveAssetsFailureSchema, mediaMoveAssetsOutputSchema, mediaDeleteAssetsFailureSchema, mediaDeleteAssetsOutputSchema, type MediaFolderNode, } from './output-schemas';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/mcp/schemas/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../server/src/mcp/schemas/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,UAAU,EACV,cAAc,EACd,UAAU,EACV,0BAA0B,EAC1B,wBAAwB,EACxB,2BAA2B,EAC3B,2BAA2B,EAC3B,4BAA4B,EAC5B,4BAA4B,EAC5B,0BAA0B,EAC1B,4BAA4B,EAC5B,0BAA0B,EAC1B,4BAA4B,GAC7B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,sBAAsB,EACtB,yBAAyB,EACzB,2BAA2B,EAC3B,qBAAqB,EACrB,4BAA4B,EAC5B,4BAA4B,EAC5B,uBAAuB,EACvB,6BAA6B,EAC7B,6BAA6B,EAC7B,2BAA2B,EAC3B,6BAA6B,EAC7B,4BAA4B,EAC5B,2BAA2B,EAC3B,8BAA8B,EAC9B,6BAA6B,EAC7B,KAAK,eAAe,GACrB,MAAM,kBAAkB,CAAC"}

package/dist/server/src/mcp/schemas/input-schemas.d.ts

@@ -0,0 +1,148 @@
+import { z } from '@strapi/utils';
+/**
+ * Media files and folders are NOT documents: they are plain entities keyed by a numeric `id`,
+ * so there is no `documentId` and no draft/published pair. Every media identifier in the MCP
+ * surface is this numeric id.
+ */
+export declare const mediaIdSchema: z.ZodNumber;
+export declare const folderIdSchema: z.ZodNumber;
+export declare const pageSchema: z.ZodOptional<z.ZodNumber>;
+export declare const pageSizeSchema: z.ZodOptional<z.ZodNumber>;
+/**
+ * Sort is constrained to the same whitelist the Media Library admin uses, so MCP callers
+ * cannot sort by private columns such as `folderPath`.
+ */
+export declare const sortSchema: z.ZodOptional<z.ZodEnum<{
+    [x: string]: string;
+}>>;
+export declare const mediaListAssetsInputSchema: z.ZodObject<{
+    folderId: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    mime: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        [x: string]: string;
+    }>>;
+}, z.core.$strip>;
+export declare const mediaGetAssetInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, z.core.$strip>;
+export declare const mediaListFoldersInputSchema: z.ZodObject<{}, z.core.$strip>;
+/**
+ * `media_update_asset` input — the only writable asset metadata.
+ *
+ * `.strict()` turns an out-of-scope field into an error rather than a silent no-op. The custom
+ * object error directs folder-shaped inputs to `media_move_assets`; other unknown keys are named by
+ * Zod's default error, so the agent can correct the call without a round-trip.
+ *
+ * The "at least one field" rule is enforced in the handler, not here: a `.refine()` would turn
+ * this into a `ZodEffects`, which the MCP tool registry cannot expose as an input schema.
+ */
+export declare const mediaUpdateAssetInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodOptional<z.ZodString>;
+    alternativeText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    caption: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+/**
+ * Folder name, validated to the same rules as the admin folder controller
+ * (`controllers/validation/admin/folder.ts`): non-empty, no slashes, no surrounding whitespace.
+ *
+ * Enforcing the shape here rather than only in the handler means the agent is corrected by the
+ * tool schema — before a call is made — instead of by a service-level error afterwards. The
+ * uniqueness rule cannot live here: it needs a DB read, so it stays in the handler.
+ */
+export declare const folderNameSchema: z.ZodString;
+export declare const mediaCreateFolderInputSchema: z.ZodObject<{
+    name: z.ZodString;
+    parent: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strict>;
+/**
+ * `media_rename_folder` deliberately takes no `parent`: renaming and moving are separate tools, so an
+ * agent picks by intent. A `parent` here is a sign the caller wanted `media_move_folder`, and the
+ * custom object error says so rather than letting Zod's generic "unrecognized key" stand.
+ */
+export declare const mediaRenameFolderInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+}, z.core.$strict>;
+/**
+ * `media_move_folder` requires `parent` — including an explicit null for the root. Making it required
+ * is what keeps a mistyped move from silently becoming a no-op update.
+ */
+export declare const mediaMoveFolderInputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    parent: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * `media_delete_folder` input.
+ *
+ * `dryRun` defaults to true: the safe branch is the one an agent gets when it omits the flag, so
+ * a destructive cascade is never the path of least resistance (the initiative card's mitigation
+ * for irreversible MCP operations). Deleting requires saying `dryRun: false` on purpose.
+ *
+ * That default lives in the handler (`folder-handlers.ts`, `dryRun = true`), NOT in this schema:
+ * `.default(true)` here is deliberately avoided so an omitted flag is a preview no matter how a
+ * client serialises the advertised schema. The `.describe()` text below is what tells an agent
+ * the default, so the two must be kept in step — do not "fix" this to `.default(true)`.
+ */
+export declare const mediaDeleteFolderInputSchema: z.ZodObject<{
+    ids: z.ZodArray<z.ZodNumber>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+/**
+ * `media_move_assets` input.
+ *
+ * Bulk by design: an agent reorganising a library moves many assets at once, and one call with a
+ * per-id report is cheaper and easier to recover from than N sequential calls. There is no
+ * single-asset variant — the array length is the only difference, and a second tool would add a
+ * choice without removing a mistake. The admin REST API agrees: `/actions/bulk-move` is the only
+ * move route.
+ *
+ * `folder` is required, including an explicit null for the root, for the same reason `media_move_folder`
+ * requires `parent`: a move needs a destination, and an omitted key would silently become a no-op.
+ *
+ * ASSET ids only, and the schema CANNOT enforce it. Asset ids and folder ids are independently
+ * numbered, so the same integer routinely names both; the handler resolves ids in the file table,
+ * which means a folder id whose number collides with an asset moves that asset — and reports it
+ * as a success. Only an id matching no asset at all is reported as failed.
+ *
+ * This is an accepted risk, not an oversight: with a bare `ids: number[]` there is no way for the
+ * caller to say which namespace it meant, and refusing every colliding id would make those assets
+ * permanently unmovable over MCP. The mitigation is the tool description. The durable fix is
+ * namespaced handles (`asset:1` / `folder:1`) across the whole media surface, which is a breaking
+ * change to the read tools and belongs to its own ticket.
+ */
+export declare const mediaMoveAssetsInputSchema: z.ZodObject<{
+    ids: z.ZodArray<z.ZodNumber>;
+    folder: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * `media_delete_assets` input.
+ *
+ * Bulk-only, like `media_move_assets`: the admin REST API has no single-asset delete route either
+ * (`/actions/bulk-delete` is the only one), and single-vs-bulk is an array length rather than a
+ * distinction an agent can get wrong.
+ *
+ * `dryRun` defaults to true in the handler, not here — same reasoning as `media_delete_folder`: the
+ * safe branch is what an agent gets when it omits the flag, so an irreversible delete is never
+ * the path of least resistance. A schema-level `.default(true)` would publish as a JSON Schema
+ * default a client could serialise away.
+ *
+ * ASSET ids only, and the schema CANNOT enforce it. Asset ids and folder ids are independently
+ * numbered, so the same integer routinely names both; the handler resolves ids in the file table,
+ * which means a folder id whose number collides with an asset deletes that asset. Only an id
+ * matching no asset at all is reported as failed.
+ *
+ * This is an accepted risk, not an oversight: with a bare `ids: number[]` there is no way for the
+ * caller to say which namespace it meant, and refusing every colliding id would make those assets
+ * permanently undeletable over MCP. The mitigations are the dry run and the tool description. The
+ * durable fix is namespaced handles (`asset:1` / `folder:1`) across the whole media surface, which
+ * is a breaking change to the read tools and belongs to its own ticket.
+ */
+export declare const mediaDeleteAssetsInputSchema: z.ZodObject<{
+    ids: z.ZodArray<z.ZodNumber>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+//# sourceMappingURL=input-schemas.d.ts.map

package/dist/server/src/mcp/schemas/input-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-schemas.d.ts","sourceRoot":"","sources":["../../../../../server/src/mcp/schemas/input-schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,eAAe,CAAC;AAIlC;;;;GAIG;AACH,eAAO,MAAM,aAAa,aAMvB,CAAC;AAEJ,eAAO,MAAM,cAAc,aAIuE,CAAC;AAEnG,eAAO,MAAM,UAAU,4BAK4B,CAAC;AAEpD,eAAO,MAAM,cAAc,4BAM2B,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,UAAU;;GAKpB,CAAC;AAEJ,eAAO,MAAM,0BAA0B;;;;;;;;;iBAsBrC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;iBAEnC,CAAC;AAEH,eAAO,MAAM,2BAA2B,gCAAe,CAAC;AAIxD;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B;;;;;kBAuC7B,CAAC;AAEZ;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,aAO1B,CAAC;AAaJ,eAAO,MAAM,4BAA4B;;;kBAS9B,CAAC;AAEZ;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;;kBAgB9B,CAAC;AAEZ;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;kBAgB5B,CAAC;AAEZ;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,4BAA4B;;;kBAgB9B,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,0BAA0B;;;kBAiC5B,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,4BAA4B;;;kBAkC9B,CAAC"}

package/dist/server/src/mcp/schemas/output-schemas.d.ts

@@ -0,0 +1,276 @@
+import { z } from '@strapi/utils';
+/**
+ * The exhaustive set of asset fields the MCP surface may expose — an allowlist, for the reasons
+ * in `sanitizeMediaAsset`. A field added to the file content-type stays invisible to MCP until
+ * it is added both here and there.
+ */
+export declare const mediaAssetOutputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    alternativeText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    caption: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    url: z.ZodString;
+    mime: z.ZodString;
+    size: z.ZodNumber;
+    width: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    height: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    ext: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    folder: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+    }, z.core.$strip>>>;
+    createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const mediaGetAssetOutputSchema: z.ZodObject<{
+    data: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        alternativeText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        caption: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+        mime: z.ZodString;
+        size: z.ZodNumber;
+        width: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        height: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        ext: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        folder: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const mediaListAssetsOutputSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        alternativeText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        caption: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+        mime: z.ZodString;
+        size: z.ZodNumber;
+        width: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        height: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        ext: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        folder: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        page: z.ZodNumber;
+        pageSize: z.ZodNumber;
+        pageCount: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Folder tree node. `children` is recursive and unbounded in depth, so it is typed lazily.
+ */
+export type MediaFolderNode = {
+    id: number;
+    name: string;
+    children: MediaFolderNode[];
+};
+export declare const mediaFolderNodeSchema: z.ZodType<MediaFolderNode>;
+export declare const mediaListFoldersOutputSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodType<MediaFolderNode, unknown, z.core.$ZodTypeInternals<MediaFolderNode, unknown>>>;
+}, z.core.$strip>;
+/**
+ * `media_update_asset` output — the updated asset in the same shape the read tools return,
+ * so an agent can confirm the write without a follow-up `media_get_asset` call.
+ */
+export declare const mediaUpdateAssetOutputSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        alternativeText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        caption: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+        mime: z.ZodString;
+        size: z.ZodNumber;
+        width: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        height: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        ext: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        folder: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * A folder as returned by the write tools.
+ *
+ * Like the asset schema this is an ALLOWLIST: `path` and `pathId` are internal materialized-path
+ * bookkeeping and stay invisible to MCP clients, matching what `media_list_folders` already exposes.
+ */
+export declare const mediaFolderOutputSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    parent: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export declare const mediaCreateFolderOutputSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        parent: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const mediaRenameFolderOutputSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        parent: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const mediaMoveFolderOutputSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        parent: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * `media_delete_folder` output — the same shape for both branches, so an agent reads one contract.
+ *
+ * `dryRun` echoes which branch ran: on true the counts are what *would* be removed and nothing
+ * was touched; on false they are what actually was. Echoing it back means the agent can tell a
+ * preview from a completed deletion without tracking what it sent.
+ *
+ * There is no "skipped ids" field: an id that does not resolve to a folder rejects the whole
+ * call, so every id in the request is accounted for by `folders` on any successful response.
+ */
+export declare const mediaDeleteFolderOutputSchema: z.ZodObject<{
+    dryRun: z.ZodBoolean;
+    folders: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        parent: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    totalFolderNumber: z.ZodNumber;
+    totalFileNumber: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * `media_move_assets` output — a per-id report rather than a single verdict.
+ *
+ * A bad id among good ones does not roll back the valid moves (see the handler), so the response
+ * has to say which ids moved and which did not: an agent that only learned "the call failed"
+ * would either retry moves that already happened or abandon ones that did. `moved` and `failed`
+ * together account for every id in the request, on every successful response — including one
+ * where `moved` is empty because no id resolved.
+ *
+ * `moved` carries the full asset in the same shape the read tools return, so the new folder can
+ * be confirmed without a follow-up `media_get_asset`.
+ */
+export declare const mediaMoveAssetsFailureSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export declare const mediaMoveAssetsOutputSchema: z.ZodObject<{
+    destinationFolder: z.ZodNullable<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    moved: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        alternativeText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        caption: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+        mime: z.ZodString;
+        size: z.ZodNumber;
+        width: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        height: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        ext: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        folder: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    failed: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * `media_delete_assets` output — one contract for both branches, with a per-id account of every
+ * requested id.
+ *
+ * `dryRun` echoes which branch ran: on true `deleted` is what *would* be removed and nothing was
+ * touched; on false it is what actually was. Echoing it back means an agent can tell a preview
+ * from a completed deletion without tracking what it sent — the difference matters more here
+ * than anywhere else in this surface, because one branch is irreversible.
+ *
+ * `deleted` carries the full asset rather than a bare id, so the agent can report what it
+ * destroyed after the row is gone and no read can recover it. On a dry run it is the same shape,
+ * which is exactly what makes the preview a confirmation an agent can act on.
+ *
+ * Unlike `media_delete_folder`, an unresolvable id does NOT reject the call: deletions are performed
+ * per asset and reported per id, so a bad id among good ones neither rolls back the valid
+ * deletions nor stops them from happening. `deleted` and `failed` together account for every id
+ * in the request, on every successful response.
+ */
+export declare const mediaDeleteAssetsFailureSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export declare const mediaDeleteAssetsOutputSchema: z.ZodObject<{
+    dryRun: z.ZodBoolean;
+    deleted: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        name: z.ZodString;
+        alternativeText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        caption: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        url: z.ZodString;
+        mime: z.ZodString;
+        size: z.ZodNumber;
+        width: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        height: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        ext: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        folder: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodNumber;
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    failed: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+    totalFileNumber: z.ZodNumber;
+}, z.core.$strip>;
+//# sourceMappingURL=output-schemas.d.ts.map

package/dist/server/src/mcp/schemas/output-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-schemas.d.ts","sourceRoot":"","sources":["../../../../../server/src/mcp/schemas/output-schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,eAAe,CAAC;AAElC;;;;GAIG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;iBAqBjC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;iBAEpC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;iBAQtC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,CAAC,CAAC,OAAO,CAAC,eAAe,CAM5D,CAAC;AAEF,eAAO,MAAM,4BAA4B;;iBAEvC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;iBAEvC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;iBAelC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;iBAExC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;iBAExC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;iBAEtC,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;iBAexC,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,4BAA4B;;;iBAKvC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkBtC,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,8BAA8B;;;iBAOzC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;iBAqBxC,CAAC"}