Read an asset from Cascade CMS by identifier.

Default preview mode returns a compact browse-oriented asset_handle, asset identity, raw_hash, index_version, fact/reference counts, node counts, root nodelet outline, and raw_resource_uri. Preview is not audit-complete; use cascade_asset_list_facts, cascade_asset_search_values, cascade_asset_search_keys, cascade_asset_get_value, cascade_asset_list_scalar_artifacts, cascade_asset_list_references, cascade_asset_list_nodelets, and cascade_asset_get_nodelet with the returned asset_handle for follow-up inspection. Use read_mode: "raw" only when the full REST payload is required.

Args:

• identifier (object, required): The asset to read

  • id (string, optional): Cascade internal asset ID (e.g., "d3631e59ac1e..."). Takes priority over path when both are provided.

  • path (object, optional): Site-qualified path

    • path (string, required): Asset path within the site, starting from root (e.g., "/about/team")

    • siteId OR siteName (string): Which site the path belongs to

  • type (string, required): Entity type — one of the 56 EntityTypeString values (page, file, folder, block, template, etc.)

  • recycled (boolean, optional): Read from recycle bin.

• read_mode (string, optional): 'preview' (default, compact handle-based output) or 'raw' (full REST payload; expensive for structured assets). Returns: Preview mode: { asset_handle, asset_type, asset_identity, raw_resource_uri, raw_hash, index_version, audit_complete: false, total_fact_count, reference_count, node_count, max_depth, root_outline, omitted_fields, warnings, next_actions } Raw mode: { success: true, asset: { : { ...type-specific representation } } } On failure: { success: false, message: "Asset not found" }

Examples:

• Use when: "Read the homepage" -> { identifier: { type: "page", path: { path: "/", siteName: "www" } } }

• Use when: "Get file by ID" -> { identifier: { type: "file", id: "abc123..." } }

• Use when: "Load folder config" -> { identifier: { type: "folder", path: { path: "/about", siteName: "www" } } }

• Don't use when: You want to modify — use cascade_edit instead.

• Don't use when: You want to check access rights — use cascade_read_access_rights.

Error Handling:

• "Asset not found" when the identifier doesn't resolve

• "Permission denied" when credentials lack read access

• "Site not found" when siteName/siteId is invalid. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Use after cascade_read. List object, array, key, and scalar facts indexed from the full cached raw Cascade response. Supports pointer, key, value, scalar, and reference filters with cursor pagination. This tool never reads Cascade directly and reports complete: true only when the current filter has no remaining matches. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Use after cascade_read. Search full scalar values across the cached raw Cascade response, not shortened previews. Returns JSON Pointer provenance, scalar type, value length, preview, and match offsets where practical. This tool never reads Cascade directly. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Use after cascade_read. Find object key occurrences anywhere in the cached raw Cascade response. Returns the JSON Pointer to the keyed value plus parent pointer. This tool never reads Cascade directly. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Use after cascade_read. Retrieve the exact raw cached value at a JSON Pointer. Long strings can be sliced with offset and length. This tool never reads Cascade directly. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Use after cascade_read. List Cascade-native references discovered from id/path pairs, structured asset nodes, metadata, page configurations, and page regions. This tool never reads Cascade directly. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Use after cascade_read. Enumerate derived link/path-like artifacts from cached raw string scalar facts, including http_url, site_link, href, src, anchor, mailto, tel, and root_path. Returns JSON Pointer and offset provenance. This tool never reads Cascade directly. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Use after cascade_read. List child structuredData nodelets for a JSON Pointer in the cached asset_handle returned by cascade_read. Use pointer "" to list root nodelets. This is a convenience view over structuredDataNodes, not an audit-complete view. This tool never reads Cascade directly. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Use after cascade_read. Fetch the exact structuredData nodelet or bounded subtree at a JSON Pointer in the cached asset_handle returned by cascade_read. This is a convenience view over structuredDataNodes, not an audit-complete view. This tool never reads Cascade directly. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Create a new asset in Cascade CMS.

The request body wraps a typed envelope under asset — one of 48 envelope keys (page, file, folder, symlink, textBlock, feedBlock, indexBlock, xmlBlock, xhtmlDataDefinitionBlock, twitterFeedBlock, reference, template, xsltFormat, scriptFormat, user, group, role, assetFactory, contentType, destination, editorConfiguration, metadataSet, pageConfigurationSet, publishSet, dataDefinition, sharedField, site, workflowDefinition, workflowEmail, wordPressConnector, googleAnalyticsConnector, fileSystemTransport, ftpTransport, databaseTransport, cloudTransport, and the *Container types). This matches the upstream Cascade REST API Asset schema exactly. Returns the new asset's ID on success.

Payload conventions (apply to every create call):

• Send ONLY the fields you actually need to set. Every optional field should be omitted unless you have a real value to provide — Cascade applies its own defaults server-side. Do not pad payloads with "reasonable defaults" like reviewOnSchedule: false or shouldBePublished: true when you do not need to override them.

• For every <thing>Id / <thing>Path pair (parentFolderId vs parentFolderPath, siteId vs siteName, contentTypeId vs contentTypePath, metadataSetId vs metadataSetPath, ...), prefer the id form when you know the id. Path is a valid fallback and Cascade resolves it server-side — don't round-trip through cascade_read just to look up an id.

• Text encoding: rich-text fields (xhtml, WYSIWYG structuredData text, xmlBlock xml) must be well-formed XML — named HTML entities like   and astral-plane Unicode (including emoji) crash the render. See resource cascade://text-encoding for the per-field-category rules.

Args:

• asset (object, required): Single-key envelope. Key is the camelCase type; value is the asset body. Common shapes (only required fields shown — add optionals only when you need to set them):

  • { page: { name, parentFolderId OR parentFolderPath, siteId OR siteName, contentTypeId OR contentTypePath, ... } }

  • { file: { name, parentFolderId OR parentFolderPath, siteId OR siteName, text? OR data?, ... } }

  • { folder: { name, parentFolderId OR parentFolderPath, siteId OR siteName, ... } }

  • { textBlock: { name, parentFolderId OR parentFolderPath, siteId OR siteName, text, ... } }

  • { xmlBlock: { name, parentFolderId OR parentFolderPath, siteId OR siteName, xml, ... } }

  • { symlink: { name, parentFolderId OR parentFolderPath, siteId OR siteName, linkURL, ... } } Admin-area types (assetFactory, contentType, transports, workflow*, *Container) use parentContainerId/Path instead of parentFolderId/Path.

Returns: Cascade OperationResult: { success: true, createdAssetId: "" } On failure: { success: false, message: "" }

Examples:

• Use when: "Create a page under /about" -> { asset: { page: { name: "team", parentFolderPath: "/about", siteName: "www", contentTypePath: "/standard-page" } } }

• Use when: "Upload a text file" -> { asset: { file: { name: "robots.txt", parentFolderPath: "/", siteName: "www", text: "User-agent: *" } } }

• Use when: "Create a text block" -> { asset: { textBlock: { name: "greeting", parentFolderPath: "/blocks", siteName: "www", text: "Hello" } } }

• Don't use when: The asset already exists — use cascade_edit.

• Don't use when: You want to duplicate an existing asset — use cascade_copy.

Error Handling:

• "Parent folder not found" when parentFolderId/parentFolderPath is invalid

• "Asset name collision" when an asset with the same name exists in the parent

• "Permission denied" when credentials lack create access on the parent

• "Invalid content type" when contentTypeId/contentTypePath doesn't resolve. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Edit an existing Cascade CMS asset.

Accepts the full asset body (same envelope shape as cascade_create). The workflow is symmetric when cascade_read is called with read_mode: "raw": modify the raw asset envelope and pass the same envelope back to cascade_edit. Some asset types require a prior cascade_check_out.

Payload conventions:

• Edit replaces the asset body, so send the full object as read — do not try to send only the fields you are changing.

• When constructing an edit payload from scratch (not round-tripping a read), still omit optional fields you have no intention of setting; don't invent defaults.

• Prefer id over path on every id/path pair (metadataSetId over metadataSetPath, etc.). Cascade resolves paths server-side.

• Text encoding: same rules as cascade_create — rich-text fields must be well-formed XML with only the five XML built-in entities (&, <, >, ", '). See resource cascade://text-encoding.

Args:

• asset (object, required): Single-key envelope (same as cascade_create). Inner object must include id to identify the existing asset.

Returns: Cascade OperationResult: { success: true } On failure: { success: false, message: "" }

Examples:

• Use when: "Update a page's metadata" -> Read first with cascade_read; modify asset.page.metadata; pass { asset: asset.asset } back.

• Use when: "Change a block's structured data" -> { asset: { xhtmlDataDefinitionBlock: { id: "...", structuredData: { ... } } } }

• Use when: "Rewrite a symlink's target" -> { asset: { symlink: { id: "...", linkURL: "https://new.example.com" } } }

• Don't use when: The asset doesn't exist — use cascade_create.

• Don't use when: You want a partial patch — Cascade's edit replaces the asset body; always send the full object.

Error Handling:

• "Asset not found" when id doesn't resolve

• "Permission denied" when credentials lack edit rights

• "Asset is checked out by another user" when the asset is locked

• "Validation error" when required fields are missing or malformed. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Delete an asset from Cascade CMS.

By default, deletion sends the asset to the recycle bin; deleteParameters can unpublish and/or hard-delete. Site removal and root-folder path "/" removal are rejected; root-folder ID safeguards require generated tool-block rules. If the asset is under a workflow that requires review, workflowConfiguration specifies the approval flow. This is a DESTRUCTIVE operation — confirm intent before calling.

Args:

• identifier (object, required): The asset to delete

  • id (string, optional): Asset ID (preferred)

  • path (object, optional): { path, siteId OR siteName }

  • type (string, required): Entity type of the asset

• deleteParameters (object, optional, shape varies — see Cascade docs): Controls delete behavior

  • doWorkflow (boolean): Whether to run the workflow on delete

  • unpublish (boolean): Unpublish from destinations before deleting

• workflowConfiguration (object, optional, shape varies — see Cascade docs): Workflow step assignments when user can't bypass workflow

Returns: Cascade OperationResult: { success: true } On failure: { success: false, message: "" }

Examples:

• Use when: "Delete a page" -> { identifier: { type: "page", id: "..." } }

• Use when: "Unpublish then delete" -> { identifier: { type: "page", id: "..." }, deleteParameters: { unpublish: true } }

• Don't use when: You just want to move/rename — use cascade_move.

• Don't use when: You want to unpublish without deleting — use cascade_publish_unpublish with unpublish: true.

Error Handling:

• "Asset not found" when the identifier doesn't resolve

• "Permission denied" when credentials lack delete rights

• "Asset has children" when deleting a non-empty folder without cascade

• "Workflow required" when the container requires workflow and none was supplied. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Move an asset to a new container and/or rename it.

Performs an in-place rename when newName is set but destinationContainerIdentifier is omitted, a pure move when destinationContainerIdentifier is set and newName is omitted, or both simultaneously when both are provided. References to the asset from other assets are updated automatically by Cascade.

Args:

• identifier (object, required): The asset to move

  • id (string, optional): Asset ID (preferred)

  • path (object, optional): { path, siteId OR siteName }

  • type (string, required): Entity type of the asset

• moveParameters (object, required):

  • destinationContainerIdentifier (object, optional): Where to move the asset. Omit to keep in current container.

  • doWorkflow (boolean, required): Whether to run workflow on the move

  • newName (string, optional): New asset name. Omit to keep current name.

• workflowConfiguration (object, optional, shape varies — see Cascade docs): Workflow step assignments

Returns: Cascade OperationResult: { success: true } On failure: { success: false, message: "" }

Examples:

• Use when: "Rename /about/teem to /about/team" -> { identifier: { type: "page", id: "..." }, moveParameters: { doWorkflow: false, newName: "team" } }

• Use when: "Move page to /archive" -> { identifier: { type: "page", id: "..." }, moveParameters: { doWorkflow: false, destinationContainerIdentifier: { type: "folder", path: { path: "/archive", siteName: "www" } } } }

• Don't use when: You want to duplicate — use cascade_copy.

Error Handling:

• "Asset not found" when the source identifier doesn't resolve

• "Destination not found" when destinationContainerIdentifier is invalid

• "Name collision" when an asset with newName already exists in the destination

• "Permission denied" when credentials lack move rights on source or destination. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Copy an asset to a new container with a new name.

Creates a fresh, independent copy of an asset. Unlike cascade_move, the original stays in place and the copy gets its own ID. destinationContainerIdentifier and newName are both required. For copying an entire site, use cascade_site_copy instead.

Args:

• identifier (object, required): The source asset to copy

  • id (string, optional): Asset ID (preferred)

  • path (object, optional): { path, siteId OR siteName }

  • type (string, required): Entity type of the source

• copyParameters (object, required):

  • destinationContainerIdentifier (object, required): The container (folder/site) that will receive the copy

  • doWorkflow (boolean, required): Whether to run workflow on the copy

  • newName (string, required): Name for the new asset (must be unique within destination)

• workflowConfiguration (object, optional, shape varies — see Cascade docs): Workflow step assignments

Returns: Cascade OperationResult: { success: true } On failure: { success: false, message: "" }

Examples:

• Use when: "Duplicate /templates/basic as /templates/basic-v2" -> { identifier: { type: "page", path: { path: "/templates/basic", siteName: "www" } }, copyParameters: { destinationContainerIdentifier: { type: "folder", path: { path: "/templates", siteName: "www" } }, newName: "basic-v2", doWorkflow: false } }

• Don't use when: You want to rename in place — use cascade_move.

• Don't use when: You want to copy an entire site — use cascade_site_copy.

Error Handling:

• "Asset not found" when the source identifier doesn't resolve

• "Destination not found" when destinationContainerIdentifier is invalid

• "Name collision" when newName already exists in destination

• "Permission denied" when credentials lack read on source or create on destination. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Search for assets across Cascade CMS by search terms, optional field subset, and asset type filter.

Runs a keyword search against Cascade's indexed content. Can be scoped to a single site (via siteId or siteName) or run across all sites when neither is provided. The searchFields array narrows which asset fields are matched (default: all searchable fields); searchTypes narrows which asset types are returned. Results are paginated client-side by this MCP layer.

Args:

• searchInformation (object, required):

  • searchTerms (string, required): Keyword(s) to match, non-empty

  • siteId (string, optional): Restrict to a site by ID

  • siteName (string, optional): Restrict to a site by name (ignored if siteId is set)

  • searchFields (string[], optional): Fields to search. Allowed: "name", "path", "createdBy", "modifiedBy", "displayName", "title", "summary", "teaser", "keywords", "description", "author", "blob", "velocityFormatContent", "xml", "link". Default: all.

  • searchTypes (string[], optional): Asset types to return (e.g. ["page", "file"]). Default: all.

• limit (number, optional): Max results per page, 1-500 (default 50)

• offset (number, optional): Skip N results for pagination (default 0)

Returns: The response is a page: { success: true, total: , count: , offset: , has_more: , next_offset: <offset for next page, if has_more>, matches: [ { id, type, path: { path, siteId, siteName } }, ... ] } On failure: { success: false, message: "" }

Examples:

• Use when: "Find all pages mentioning 'admissions'" -> { searchInformation: { searchTerms: "admissions", searchTypes: ["page"] } }

• Use when: "Title search in site 'www'" -> { searchInformation: { searchTerms: "scholarship", siteName: "www", searchFields: ["title"] } }

• Don't use when: You already know the id/path — use cascade_read directly.

• Don't use when: You want audit events — use cascade_read_audits.

Pagination:

• Default limit of 50 works for most queries. Increase up to 500 for larger pages.

• If has_more is true and you need all results, call again with offset: next_offset.

• For a complete enumeration (e.g., all pages matching a term), loop until has_more: false.

• For focused searches where you only need top matches, stop as soon as you have what you need.

Error Handling:

• "searchTerms must not be empty" when the term is missing or blank

• "Site not found" when siteName/siteId is invalid

• "Permission denied" when credentials lack read access. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

List all sites accessible with the current API credentials.

Returns identifiers (id, name, type="site") for every site the authenticated user can see. This is typically the first call an agent makes to discover which sites exist before reading or editing assets inside them. The response contains only identifiers — call cascade_read with { type: "site", ... } to fetch a site's full configuration.

Args: (none)

Returns: Cascade OperationResult: { success: true, sites: [ { id, type: "site", path: { path, siteId, siteName } }, ... ] } On failure: { success: false, message: "" }

Examples:

• Use when: "What sites do I have access to?" -> {}

• Use when: "I need to find a siteId before reading a page" -> call this, then match by name.

• Don't use when: You already know the site name/id — skip straight to cascade_read.

• Don't use when: You need a site's full config — use cascade_read with type "site".

Error Handling:

• "Permission denied" when credentials are invalid

• "Authentication failed" when the API key is missing or revoked. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Copy an entire site to a new site with a new name.

Duplicates all assets, folders, templates, and configuration from an existing site into a brand-new site. This is a LONG-RUNNING operation — Cascade returns once the copy has started but finishes asynchronously. Poll cascade_list_sites to confirm completion. Either originalSiteId or originalSiteName must be provided; if both are given, originalSiteId wins.

Args:

• originalSiteId (string, optional): Source site ID. Preferred when known.

• originalSiteName (string, optional): Source site name. Used when originalSiteId is omitted.

• newSiteName (string, required): Name for the new copied site. Must be unique across sites.

(Either originalSiteId or originalSiteName is required; the tool rejects calls that omit both.)

Returns: Cascade OperationResult: { success: true } On failure: { success: false, message: "" }

Examples:

• Use when: "Duplicate the 'staging' site as 'staging-2026'" -> { originalSiteName: "staging", newSiteName: "staging-2026" }

• Use when: "Copy site by id for a new campaign" -> { originalSiteId: "abc123...", newSiteName: "campaign-fall" }

• Don't use when: You want to copy a single asset — use cascade_copy.

• Don't use when: The site already exists under newSiteName — no merge behavior is supported.

Error Handling:

• "requires either originalSiteId or originalSiteName" when both are omitted

• "Source site not found" when the original identifier doesn't resolve

• "Site name collision" when newSiteName already exists

• "Permission denied" when the user isn't a site-copy administrator. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Read access rights (users/groups + permission levels) for a Cascade asset.

Returns the complete ACL (access control list) for an asset: which users and groups can read or write it, and what the default level is for everyone else. Access levels are "none", "read", and "write" for allLevel, and "read" or "write" for explicit ACL entries. Useful for auditing permissions before sharing content or before a bulk edit.

Args:

• identifier (object, required): The asset whose ACL to read

  • id (string, optional): Asset ID (preferred)

  • path (object, optional): { path, siteId OR siteName }

  • type (string, required): Entity type of the asset

Returns: Cascade OperationResult: { success: true, accessRightsInformation: { identifier: { ... }, aclEntries: [ { name, type: "user"|"group", level }, ... ], allLevel: "none"|"read"|"write" } } On failure: { success: false, message: "" }

Examples:

• Use when: "Who has edit access to /about?" -> { identifier: { type: "folder", path: { path: "/about", siteName: "www" } } }

• Use when: "Audit page permissions" -> { identifier: { type: "page", id: "..." } }

• Don't use when: You want to change permissions — use cascade_edit_access_rights.

• Don't use when: You want workflow settings — use cascade_read_workflow_settings.

Error Handling:

• "Asset not found" when the identifier doesn't resolve

• "Permission denied" when credentials lack admin/read-acl rights. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Modify access rights (ACL) for a Cascade asset. Optionally apply to all descendants.

Replaces the asset's ACL wholesale — include every user/group you want to keep; anyone omitted loses their explicit entry and falls back to allLevel. For folders or containers, setting applyToChildren: true propagates the new ACL recursively. Typical workflow: call cascade_read_access_rights first to get the current ACL, modify the array, then pass it here.

Args:

• identifier (object, required): The asset whose ACL to modify

  • id (string, optional): Asset ID (preferred)

  • path (object, optional): { path, siteId OR siteName }

  • type (string, required): Entity type of the asset

• accessRightsInformation (object, required):

  • aclEntries (array, optional): Full explicit ACL. Each entry: { name, type: "user"|"group", level: "read"|"write", id? }; include id for group entries when Cascade provides it.

  • allLevel (string): Default for everyone not listed. One of "none" | "read" | "write".

• applyToChildren (boolean, optional): For containers only. Default false. Propagates the ACL to all descendants.

Returns: Cascade OperationResult: { success: true } On failure: { success: false, message: "" }

Examples:

• Use when: "Grant group 'editors' write access" -> { identifier: { type: "folder", id: "..." }, accessRightsInformation: { aclEntries: [{ name: "editors", type: "group", level: "write" }], allLevel: "read" } }

• Use when: "Lock a folder tree down" -> pass applyToChildren: true alongside the restricted ACL.

• Don't use when: You only want to read — use cascade_read_access_rights.

• Don't use when: You want to change workflow policy — use cascade_edit_workflow_settings.

Error Handling:

• "Asset not found" when the identifier doesn't resolve

• "User/group not found" when an aclEntries name is invalid

• "Permission denied" when credentials lack admin/edit-acl rights. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Read workflow settings for a Cascade container (folder or site).

Returns which workflow definitions are available on the container, whether workflow is required for changes inside it, whether children inherit the setting, and the step/action configuration. Workflow settings apply to containers only — if you query a non-container, Cascade returns an error. Use this before editing workflow policy so you know the existing configuration.

Args:

• identifier (object, required): The container

  • id (string, optional): Container ID (preferred)

  • path (object, optional): { path, siteId OR siteName }

  • type (string, required): Typically "folder" or "site"

Returns: Cascade OperationResult: { success: true, workflowSettings: { identifier: { ... }, workflowDefinitions: [ ... ], inheritedWorkflowDefinitions: [ ... ], inheritWorkflows: boolean, requireWorkflow: boolean } } On failure: { success: false, message: "" }

Examples:

• Use when: "Does /about require workflow?" -> { identifier: { type: "folder", path: { path: "/about", siteName: "www" } } }

• Use when: "Read a site's workflow policy" -> { identifier: { type: "site", id: "..." } }

• Don't use when: You want to inspect an in-flight workflow — use cascade_read_workflow_information.

• Don't use when: Target is not a container — workflow settings are container-only.

Error Handling:

• "Asset not found" when the identifier doesn't resolve

• "Not a container" when type is not folder/site/similar

• "Permission denied" when credentials lack read access. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Update workflow settings for a Cascade container (folder/site). Optionally propagate to children.

Replaces the container's workflow configuration wholesale. Two boolean flags control propagation: applyInheritWorkflowsToChildren copies the "inherit" setting to descendants, applyRequireWorkflowToChildren copies the "required" setting. Call cascade_read_workflow_settings first so you can pass the existing workflowSettings with only your edits.

Args:

• identifier (object, required): The container to update

  • id (string, optional): Container ID (preferred)

  • path (object, optional): { path, siteId OR siteName }

  • type (string, required): Typically "folder" or "site"

• workflowSettings (object, required, shape varies — see Cascade docs): Complete replacement workflow configuration

  • workflowDefinitions (array): Which workflows apply in this container

  • inheritWorkflows (boolean): Whether to inherit from parent

  • requireWorkflow (boolean): Whether workflow is mandatory for edits

• applyInheritWorkflowsToChildren (boolean, optional, default false): Propagate inheritWorkflows to descendants

• applyRequireWorkflowToChildren (boolean, optional, default false): Propagate requireWorkflow to descendants

Returns: Cascade OperationResult: { success: true } On failure: { success: false, message: "" }

Examples:

• Use when: "Require workflow on /releases and all its children" -> set requireWorkflow: true + applyRequireWorkflowToChildren: true.

• Use when: "Swap a workflow definition on a folder" -> pass the new workflowDefinitions array.

• Don't use when: You want to advance an in-flight workflow — use cascade_perform_workflow_transition.

• Don't use when: You only need to read — use cascade_read_workflow_settings.

Error Handling:

• "Asset not found" when the identifier doesn't resolve

• "Invalid workflow definition" when a referenced workflow ID is wrong

• "Permission denied" when credentials lack admin rights. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Read information about the in-flight workflow attached to an asset.

When an asset is going through an approval workflow, Cascade tracks the current step, who owns it, what history has been recorded, and which actions (forward, reverse, reassign, etc.) are available. This tool surfaces that state. The returned workflow object has an id and a list of available actions; pass those to cascade_perform_workflow_transition to advance the workflow.

Args:

• identifier (object, required): The asset whose workflow state to read

  • id (string, optional): Asset ID (preferred)

  • path (object, optional): { path, siteId OR siteName }

  • type (string, required): Entity type of the asset

Returns: Cascade OperationResult: { success: true, workflow: { id: "", name: "...", currentStep: "...", actions: [ { identifier, label, actionType, nextId }, ... ], history: [ ... ], ownedByCurrentUser: boolean, relatedAsset: { ... } } } On failure: { success: false, message: "" } — also when no workflow is in flight

Examples:

• Use when: "What step is /about/team in?" -> { identifier: { type: "page", path: { path: "/about/team", siteName: "www" } } }

• Use when: "List actions I can take on this asset's workflow" -> pass the identifier and read workflow.actions.

• Don't use when: You want workflow policy — use cascade_read_workflow_settings.

• Don't use when: No workflow is in flight — expect a "no workflow" failure.

Error Handling:

• "Asset not found" when the identifier doesn't resolve

• "No workflow in progress" when the asset has no active workflow

• "Permission denied" when credentials lack read access. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Advance an in-flight workflow to its next step (approve, reject, publish, etc.).

Executes a named action against an active workflow. The workflowId and actionIdentifier come from a prior cascade_read_workflow_information call — the tool does not enumerate actions itself. A transitionComment is recommended so reviewers understand the decision; it's stored in the workflow history. Once the final step is executed, Cascade may publish, delete, or otherwise commit the change associated with the workflow.

Args:

• workflowId (string, required): The active workflow's id (from cascade_read_workflow_information)

• actionIdentifier (string, required): The action to take (from workflow.actions[].identifier)

• transitionComment (string, optional): User comment explaining this transition

Returns: Cascade OperationResult: { success: true } On failure: { success: false, message: "" }

Examples:

• Use when: "Approve an editor's page submission" -> { workflowId: "...", actionIdentifier: "approve", transitionComment: "Looks good." }

• Use when: "Reject and send back" -> { workflowId: "...", actionIdentifier: "reject", transitionComment: "Fix the headline." }

• Don't use when: You don't yet know which actions are valid — call cascade_read_workflow_information first.

• Don't use when: No workflow exists — this only advances an in-flight one.

Error Handling:

• "Workflow not found" when workflowId is invalid or already finished

• "Invalid action" when actionIdentifier is not among the workflow's available actions

• "Permission denied" when current user can't act on this workflow step. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

List the relationships an asset has — the other assets that reference it ("what is using this?") and the users subscribed to its notifications.

Cascade exposes two related discovery questions through this single endpoint:

1. "What relationships does this asset have?" — i.e. what references it: "which pages use this block?", "which pages link to this file?", "which content-types use this data definition?". The referenced asset is the query target; the assets that point at it show up in the response.

2. "Who gets notified when this asset changes?" — user/group subscribers, both auto (ownership/workflow/group) and manual (opt-in).

Directionality matters: the lookup runs against the asset being referenced, NOT the asset doing the referencing. If a page embeds a block, query the BLOCK to find the page. Querying the page will NOT list its embedded blocks — it will list the assets that reference the page.

Args:

• identifier (object, required): The asset whose relationships/subscribers to list

  • id (string, optional): Asset ID. Prefer id when known; Cascade auto-resolves path→id server-side when only path is given.

  • path (object, optional): { path, siteId OR siteName } — valid fallback when id is unknown.

  • type (string, required): Entity type of the asset. Use the EntityType string (e.g. "page", "block_XHTML_DATADEFINITION", "contenttype") — NOT the camelCase envelope key ("xhtmlDataDefinitionBlock", "contentType"). Most asset kinds differ between the two schemes; see IdentifierSchema.type / cascade://entity-types.

Returns: Cascade OperationResult: { success: true, subscribers: [ { id, type, path: { path, siteId, siteName } }, ... ], manualSubscribers: [ { id, type, path: { path, siteId, siteName } }, ... ] } Entries may be related assets (pages, content-types, ...) that reference this one, users subscribed to notifications, or both — distinguish by type. On failure: { success: false, message: "" }

Examples:

• Use when: "What relationships does this block have?" / "Which pages use this block?" -> { identifier: { type: "block_XHTML_DATADEFINITION", id: "" } } then inspect response entries.

• Use when: "Which assets link to this file?" -> { identifier: { type: "file", id: "" } }.

• Use when: "Who gets notified when /about changes?" -> { identifier: { type: "folder", path: { path: "/about", siteName: "www" } } }.

• Don't use when: You want outbound relationships — i.e. "which blocks does this page embed?". That direction isn't queryable; read the page and inspect its body.

• Don't use when: You want to read messages sent — use cascade_list_messages.

Error Handling:

• "Asset not found" when the identifier doesn't resolve

• "Permission denied" when credentials lack read access. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

List in-Cascade mailbox messages for the authenticated user.

Cascade has an internal message center — workflow requests, publish notifications, system alerts, and peer messages all land here. Returns all messages visible to the authenticated user (both unread and read, active inbox and archived, depending on your Cascade server's defaults). Message IDs from this list can be passed to cascade_mark_message or cascade_delete_message.

Args:

• limit (number, optional): Max results per page, 1-500 (default 50)

• offset (number, optional): Skip N results for pagination (default 0)

Returns: The response is a page: { success: true, total: , count: , offset: , has_more: , next_offset: <offset for next page, if has_more>, messages: [ { id, type: "message", to, from?, subject, date?, body }, ... ] } On failure: { success: false, message: "" }

Examples:

• Use when: "What's in my Cascade inbox?" -> {}

• Use when: "Check if workflow messages are waiting" -> {} then filter messages by subject.

• Don't use when: You want an asset's relationships or subscribers — use cascade_list_subscribers.

• Don't use when: You want audit events — use cascade_read_audits.

Pagination:

• Default limit of 50 works for most inboxes. Increase up to 500 for larger ones.

• If has_more is true and you need all messages, call again with offset: next_offset.

• For focused queries (most recent only), stop as soon as you have what you need.

Error Handling:

• "Authentication failed" when credentials are invalid

• "Permission denied" when the user has no mailbox configured. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Mark a Cascade inbox message as read, unread, archive, or unarchive.

Toggles the status of a single message. markType controls the action: "read"/"unread" swap the read flag; "archive"/"unarchive" move the message between the inbox and the archive. This is idempotent — marking an already-read message as "read" is a no-op.

Args:

• identifier (object, required): The message to mark

  • id (string, required): Message ID (from cascade_list_messages)

  • type (string, required): Must be "message"

• markType (string, required): One of "read" | "unread" | "archive" | "unarchive"

Returns: Cascade OperationResult: { success: true } On failure: { success: false, message: "" }

Examples:

• Use when: "Mark a workflow notice as read" -> { identifier: { type: "message", id: "..." }, markType: "read" }

• Use when: "Archive an old notification" -> { identifier: { type: "message", id: "..." }, markType: "archive" }

• Don't use when: You want to delete — use cascade_delete_message.

• Don't use when: You want to list — use cascade_list_messages.

Error Handling:

• "Message not found" when the identifier doesn't resolve

• "Invalid markType" when markType is outside the allowed set

• "Permission denied" when the message belongs to another user. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Permanently delete a message from the authenticated user's Cascade mailbox.

This is a DESTRUCTIVE operation — once deleted, the message cannot be recovered (archive is not the same as recycle-bin for messages). Prefer cascade_mark_message with markType: "archive" for retention. Messages must belong to the authenticated user; you cannot delete messages in another user's mailbox.

Args:

• identifier (object, required): The message to delete

  • id (string, required): Message ID (from cascade_list_messages)

  • type (string, required): Must be "message"

Returns: Cascade OperationResult: { success: true } On failure: { success: false, message: "" }

Examples:

• Use when: "Permanently clear spam-like notifications" -> { identifier: { type: "message", id: "..." } }

• Don't use when: You want to hide it without deleting — use cascade_mark_message with markType: "archive".

• Don't use when: You want to delete in bulk — this deletes one message per call.

Error Handling:

• "Message not found" when the identifier doesn't resolve

• "Permission denied" when the message belongs to another user. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Lock a Cascade asset for exclusive editing.

Check-out creates a working copy of the asset that only the authenticated user can edit; other users see the previously committed version until check-in. Required for some asset types (especially files and binary content types) before cascade_edit will succeed. The response includes a workingCopyIdentifier that represents the locked working copy for subsequent calls. Always pair with cascade_check_in when editing finishes to release the lock.

Args:

• identifier (object, required): The asset to check out

  • id (string, optional): Asset ID (preferred)

  • path (object, optional): { path, siteId OR siteName }

  • type (string, required): Entity type of the asset

Returns: Cascade OperationResult: { success: true, workingCopyIdentifier?: { id, type, path: { path, siteId, siteName } } } On failure: { success: false, message: "" }

Examples:

• Use when: "Lock a page before editing" -> { identifier: { type: "page", id: "..." } }

• Use when: "Check out a file for binary replacement" -> { identifier: { type: "file", path: { path: "/assets/logo.png", siteName: "www" } } }

• Don't use when: You've finished editing — use cascade_check_in to release.

• Don't use when: Read-only operations — checkout isn't needed for cascade_read.

Error Handling:

• "Asset not found" when the identifier doesn't resolve

• "Already checked out" when another user holds the lock

• "Permission denied" when credentials lack edit rights. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Release a checked-out Cascade asset and commit the working copy with a comment.

Completes the pair opened by cascade_check_out: the working copy becomes the new committed version, the lock is released, and the comments string is stored in the asset's version history. Must be called by the same user who performed the check-out. The asset (identified by id/path) must be currently checked out — Cascade will reject check-in of an asset that isn't locked.

Args:

• identifier (object, required): The asset to check in

  • id (string, optional): Asset ID (preferred)

  • path (object, optional): { path, siteId OR siteName }

  • type (string, required): Entity type of the asset

• comments (string, required): Description of the changes — stored in version history

Returns: Cascade OperationResult: { success: true } On failure: { success: false, message: "" }

Examples:

• Use when: "Commit working changes with a note" -> { identifier: { type: "page", id: "..." }, comments: "Fixed broken links in footer." }

• Don't use when: The asset isn't checked out — you'll get "Asset not checked out".

• Don't use when: Someone else checked it out — only the owner can check in.

Error Handling:

• "Asset not found" when the identifier doesn't resolve

• "Asset not checked out" when the asset isn't currently locked

• "Checked out by another user" when a different user holds the lock

• "Permission denied" when credentials lack edit rights. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Read Cascade audit log entries matching the specified filters.

Queries Cascade's system audit log for events like edits, publishes, logins, check-outs, deletes, and workflow transitions. All auditParameters fields are optional — providing none returns every recorded event (expect large volumes; always apply a date range filter). Results are always returned newest-first by Cascade; this MCP layer then slices the page.

Args:

• auditParameters (object, required, shape varies — see Cascade docs): Filter conditions

  • identifier (object, optional): Limit to events on a specific asset

  • username (string, optional): Limit to events by a specific user

  • groupname (string, optional): Limit to events by users in a group

  • rolename (string, optional): Limit to events by users with a role

  • startDate (string, optional): ISO-ish date; earliest event to include

  • endDate (string, optional): ISO-ish date; latest event to include

  • auditType (string, optional): One of: "login", "login_failed", "logout", "start_workflow", "advance_workflow", "edit", "copy", "create", "reference", "delete", "delete_unpublish", "check_in", "check_out", "activate_version", "publish", "unpublish", "recycle", "restore", "move"

• limit (number, optional): Max results per page, 1-500 (default 50)

• offset (number, optional): Skip N results for pagination (default 0)

Returns: The response is a page: { success: true, total: , count: , offset: , has_more: , next_offset: <offset for next page, if has_more>, audits: [ { user, action, identifier?: { ... }, date }, ... ] } On failure: { success: false, message: "" }

Examples:

• Use when: "Who edited /about today?" -> { auditParameters: { identifier: { type: "folder", path: { path: "/about", siteName: "www" } }, auditType: "edit", startDate: "2026-04-13T00:00:00Z" } }

• Use when: "All logins in April 2026" -> { auditParameters: { auditType: "login", startDate: "2026-04-01T00:00:00Z", endDate: "2026-04-30T23:59:59Z" } }

• Don't use when: You want the current state — use cascade_read.

• Don't use when: You want user inbox messages — use cascade_list_messages.

Pagination:

• Default limit of 50 works for most queries. Increase up to 500 for larger pages.

• If has_more is true and you need all audits, call again with offset: next_offset.

• For a complete enumeration (e.g., all audits in a date range), loop until has_more: false.

• For focused queries where you only need the most recent, stop as soon as you have what you need.

Error Handling:

• "Invalid date format" when startDate/endDate don't parse

• "Invalid auditType" when auditType isn't in the allowed set

• "Permission denied" when credentials lack audit-read rights. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Read all Cascade system preferences.

Returns every configurable server-wide preference as name/value pairs. Preferences include things like default publish behavior, image handling defaults, API limits, and UI options. Typically useful before calling cascade_edit_preference so you know the current value. Requires system-admin-level credentials.

Args: (none)

Returns: Cascade OperationResult: { success: true, preferences: [ { name: "...", value: "..." }, ... ] } On failure: { success: false, message: "" }

Examples:

• Use when: "What's the current publish-on-save setting?" -> {}

• Use when: "Inspect all server preferences" -> {}

• Don't use when: You want user-level settings — preferences are system-wide.

• Don't use when: You only need one preference — still call this (there's no read-single endpoint), then filter client-side.

Error Handling:

• "Permission denied" when credentials lack system-admin rights

• "Authentication failed" when the API key is invalid. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Update a single Cascade system preference.

Accepts a preference object with name and value. The name must exactly match an existing preference key (see cascade_read_preferences for the full list); value is always sent as a string, even for numeric or boolean preferences (Cascade parses it). Changes take effect server-wide immediately. Requires system-admin-level credentials.

Args:

• preference (object, required, shape varies — see Cascade docs): The preference to update

  • name (string, required): Exact preference key

  • value (string, required): New value (serialized as string even for numbers/booleans)

Returns: Cascade OperationResult: { success: true } On failure: { success: false, message: "" }

Examples:

• Use when: "Increase the server's API timeout" -> { preference: { name: "api.request.timeoutSeconds", value: "60" } }

• Use when: "Toggle a feature flag" -> { preference: { name: "feature.somefeature.enabled", value: "true" } }

• Don't use when: You want to read current values — use cascade_read_preferences first.

• Don't use when: The target is user-scoped — system preferences are server-wide.

Error Handling:

• "Preference not found" when name is not a recognized key

• "Invalid value" when value can't be parsed for the preference's type

• "Permission denied" when credentials lack system-admin rights. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Publish a Cascade asset to its configured destinations, or unpublish it from those destinations.

The operation is controlled by the publishInformation payload: by default it publishes; set unpublish: true to remove the asset from its destinations instead. Publishing propagates changes to external systems (HTTP, FTP, filesystem targets). This can affect production websites — use with care. Publishing is asynchronous on Cascade's side; this call queues the job and returns quickly.

Args:

• identifier (object, required): The asset to publish or unpublish

  • id (string, optional): Asset ID (preferred)

  • path (object, optional): { path, siteId OR siteName }

  • type (string, required): Entity type of the asset

• publishInformation (object, required, shape varies — see Cascade docs):

  • destinations (array, optional): Specific destination identifiers. Omit for "all enabled destinations".

  • unpublish (boolean, optional, default false): When true, unpublish instead of publish.

  • publishRelatedAssets (boolean, optional): Also publish referenced assets.

  • publishRelatedPublishSet (boolean, optional): Also publish related publish sets.

  • scheduledDate (string, optional): ISO-ish date for scheduled (future) publish.

Returns: Cascade OperationResult: { success: true } On failure: { success: false, message: "" }

Examples:

• Use when: "Publish a page now" -> { identifier: { type: "page", id: "..." }, publishInformation: {} }

• Use when: "Unpublish a page" -> { identifier: { type: "page", id: "..." }, publishInformation: { unpublish: true } }

• Use when: "Schedule publish for next week" -> { identifier: { ... }, publishInformation: { scheduledDate: "2026-04-20T12:00:00Z" } }

• Don't use when: You want to delete entirely — use cascade_remove (which can unpublish too).

• Don't use when: You haven't yet committed edits — Cascade publishes the last committed version.

Error Handling:

• "Asset not found" when the identifier doesn't resolve

• "No destinations configured" when the asset has no destinations and none were supplied

• "Permission denied" when credentials lack publish rights

• "Workflow required" when the asset's container demands workflow approval before publish. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

List or add blocked Cascade tool-call rules stored in the local JSON repository.

Use this tool when an agent should persist a guardrail that prevents selected Cascade tools from running against matching asset payloads. Rules require:

• tools: exact MCP tool names to block, such as cascade_remove or cascade_edit.

• url: one or more https Cascade CMS asset URLs at /entity/open.act. Each URL must include id and type.

• type plus id/path for explicit selectors. URL selectors and explicit selectors may be combined.

Actions:

• list: return the repository path and current rules.

• add: append rule.

This management tool writes only the local repository. Because add can change guardrails, clients should require user approval before calling this tool. The blocked-call check runs before checked Cascade tools invoke Cascade. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Persist generated blocked-call rules that prevent removal of accessible Cascade sites and their root folders.

The tool lists accessible sites, blocks cascade_remove by site id and site name/path, then tries to read each site's root folder at "/". Readable root folders are blocked by id, and path "/" is always included to block path-based root-folder removal. Existing generated rules from this tool are replaced instead of duplicated; unrelated rules are preserved.

Returns a report with protected site count, protected root-folder id count, unreadable root folders, the block-store path, and final rule count. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Read this MCP server's name and version (cascade_server_version).

Use this tool when you need to confirm which cascade-cms-mcp-server version is running in the client.

Args: (none)

Returns: { success: true, name: "cascade-cms-mcp-server", version: "" }

Examples:

• Check the MCP server version: {}. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.

Retrieve a slice of a cached MCP response by handle (cascade_read_response).

When a Cascade tool response exceeds the MCP character budget, the server caches the complete payload and returns a handle in structuredContent._cache.handle plus a preview in the text block. Use cascade_read_response to fetch the rest — either the remainder in chunks, or a targeted byte range if you know the structure.

Args:

• handle (string, required): The handle returned by a prior tool call's structuredContent._cache.handle (e.g. "h_550e8400-...").

• offset (number, optional, default 0): Byte offset within the full rendered response. Use the originating call's bytes_returned as the next offset, or structuredContent._cache.next_offset when iterating.

• length (number, optional, default 25000): Max characters to return in this slice. Capped at 25000.

Returns: { success: true, handle: "", bytes_total: , offset: , bytes_returned: , slice_text: "", has_more: , next_offset: <offset to use next, if has_more> } The same JSON object is returned in content[0].text and structuredContent; slice_text contains the response slice.

Examples:

• Continue reading: { handle: "h_abc...", offset: 20000 }

• Specific byte range: { handle: "h_abc...", offset: 50000, length: 10000 }

• Don't use when: The originating response fit under the limit (no handle was minted).

• Don't use when: The handle is older than 50 oversize responses back (LRU-evicted); re-run the originating tool.

Error Handling:

• "Handle not found" — the handle was evicted (cache holds the last 50 oversize responses) or never existed. Re-run the originating tool. Responses are JSON text; structuredContent is authoritative when the response fits. Oversized responses return bounded _cache metadata for cascade_read_response. For cascade_read, read_mode controls preview versus raw Cascade payload shape.