agent-cms 0.1.0 → 0.3.0

package/dist/{http-transport-DbFCI6Cs.mjs → server-D0XqvDjU.mjs}

@@ -1,8 +1,7 @@
-import { $ as listRecords, A as scheduleUnpublish, C as SearchInput, D as clearSchedule, F as removeBlockType, H as listAssets, I as removeLocale, J as publishRecord, K as bulkPublishRecords, L as AssetImportContext, P as removeBlockFromWhitelist, Q as getRecord, R as createAsset, U as replaceAsset, V as importAssetFromUrl, X as bulkCreateRecords, Y as unpublishRecord, Z as createRecord, _t as updateModel, a as exportSchema, at as getVersion, b as ReorderInput, bt as VectorizeContext, c as CreateAssetInput, ct as HooksContext, et as patchBlocksForField, f as CreateModelInput, ft as updateField, g as ImportSchemaInput, h as ImportAssetFromUrlInput, it as updateSingletonRecord, k as schedulePublish, lt as createField, mt as deleteModel, n as listEditorTokens, nt as removeRecord, o as importSchema, ot as listVersions, p as CreateRecordInput, pt as createModel, q as bulkUnpublishRecords, r as revokeEditorToken, rt as reorderRecords, st as restoreVersion, t as createEditorToken, tt as patchRecord, u as CreateFieldInput, ut as deleteField, vt as reindexAll, y as ReindexSearchInput, yt as search } from "./token-service-BDjccMmz.mjs";
-import { B as encodeJson, J as ValidationError, K as SchemaEngineError, L as decodeJsonRecordStringOr, m as markdownToDast } from "./structured-text-service-B4xSlUg_.mjs";
+import { $ as bulkCreateRecords, A as clearSchedule, B as AssetImportContext, C as ReorderInput, Ct as search, E as SearchInput, G as listAssets, K as replaceAsset, L as removeBlockFromWhitelist, M as schedulePublish, N as scheduleUnpublish, Q as unpublishRecord, R as removeBlockType, S as ReindexSearchInput, St as reindexAll, V as createAsset, W as importAssetFromUrl, X as bulkUnpublishRecords, Y as bulkPublishRecords, Z as publishRecord, _t as deleteModel, a as listEditorTokens, at as removeRecord, b as PatchBlocksInput, c as exportSchema, ct as getVersion, d as CreateAssetInput, dt as HooksContext, et as createRecord, ft as createField, g as CreateRecordInput, gt as createModel, h as CreateModelInput, ht as updateField, i as createEditorToken, it as patchRecord, l as importSchema, lt as listVersions, n as resolvePreviewPath, nt as listRecords, o as revokeEditorToken, ot as reorderRecords, p as CreateFieldInput, pt as deleteField, rt as patchBlocksForField, st as updateSingletonRecord, t as createPreviewToken, tt as getRecord, ut as restoreVersion, v as ImportAssetFromUrlInput, wt as VectorizeContext, xt as updateModel, y as ImportSchemaInput, yt as getModelByApiKey, z as removeLocale } from "./preview-service-C9Tmhdye.mjs";
+import { B as encodeJson, J as ValidationError, K as SchemaEngineError, L as decodeJsonRecordStringOr } from "./structured-text-service-BJkqWRkq.mjs";
 import { Context, Effect, Layer, Option, Schema } from "effect";
 import { SqlClient } from "@effect/sql";
-import * as HttpLayerRouter from "@effect/platform/HttpLayerRouter";
 import * as McpServer from "@effect/ai/McpServer";
 import * as McpSchema from "@effect/ai/McpSchema";
 import * as AiTool from "@effect/ai/Tool";
@@ -72,37 +71,6 @@ const CommonDependencies = [
 	HooksContext,
 	AssetImportContext
 ];
-const BlockEntry = Schema.Struct({
-	id: Schema.String,
-	type: Schema.String,
-	data: JsonRecord
-});
-const BuildStructuredTextInput = Schema.Struct({
-	markdown: Schema.optional(Schema.String),
-	blocks: Schema.optional(Schema.Array(BlockEntry)),
-	nodes: Schema.optional(Schema.Array(Schema.Union(Schema.Struct({
-		type: Schema.Literal("paragraph"),
-		text: Schema.String
-	}), Schema.Struct({
-		type: Schema.Literal("heading"),
-		level: Schema.Number,
-		text: Schema.String
-	}), Schema.Struct({
-		type: Schema.Literal("code"),
-		code: Schema.String,
-		language: Schema.optional(Schema.String)
-	}), Schema.Struct({
-		type: Schema.Literal("blockquote"),
-		text: Schema.String
-	}), Schema.Struct({
-		type: Schema.Literal("list"),
-		style: Schema.optional(Schema.Literal("bulleted", "numbered")),
-		items: Schema.Array(Schema.String)
-	}), Schema.Struct({ type: Schema.Literal("thematicBreak") }), Schema.Struct({
-		type: Schema.Literal("block"),
-		ref: Schema.String
-	}))))
-});
 const UpdateModelInput = Schema.Struct({
 	modelId: Schema.String,
 	name: Schema.optional(Schema.String),
@@ -110,7 +78,8 @@ const UpdateModelInput = Schema.Struct({
 	singleton: Schema.optional(Schema.Boolean),
 	sortable: Schema.optional(Schema.Boolean),
 	hasDraft: Schema.optional(Schema.Boolean),
-	allLocalesRequired: Schema.optional(Schema.Boolean)
+	allLocalesRequired: Schema.optional(Schema.Boolean),
+	canonicalPathTemplate: Schema.optional(Schema.NullOr(Schema.String))
 });
 const UpdateFieldInput = Schema.Struct({
 	fieldId: Schema.String,
@@ -132,16 +101,6 @@ const UpdateRecordInput = Schema.Struct({
 	modelApiKey: Schema.String,
 	data: Schema.optionalWith(JsonRecord, { default: () => ({}) })
 });
-const PatchBlocksInput = Schema.Struct({
-	recordId: Schema.String,
-	modelApiKey: Schema.String,
-	fieldApiKey: Schema.String,
-	value: Schema.optional(Schema.Unknown),
-	blocks: Schema.Record({
-		key: Schema.String,
-		value: Schema.NullOr(Schema.Unknown)
-	})
-});
 const DeleteRecordInput = Schema.Struct({
 	recordId: Schema.String,
 	modelApiKey: Schema.String
@@ -155,6 +114,10 @@ const PublishRecordsInput = Schema.Struct({
 	modelApiKey: Schema.String,
 	recordIds: Schema.Array(Schema.String).pipe(Schema.filter((value) => value.length >= 1, { message: () => "recordIds must contain at least 1 entry" }), Schema.filter((value) => value.length <= 1e3, { message: () => "recordIds must contain at most 1000 entries" }))
 });
+const SetPublishStatusInput = Schema.Struct({
+	action: Schema.Literal("publish", "unpublish"),
+	...PublishRecordsInput.fields
+});
 const ScheduleInput = Schema.Struct({
 	recordId: Schema.String,
 	modelApiKey: Schema.String,
@@ -201,6 +164,10 @@ const GetRecordInput = Schema.Struct({
 	recordId: Schema.String,
 	modelApiKey: Schema.String
 });
+const GetPreviewUrlInput = Schema.Struct({
+	recordId: Schema.String,
+	modelApiKey: Schema.String
+});
 const SetupContentModelPromptInput = Schema.Struct({ description: Schema.String });
 const GenerateGraphqlQueriesPromptInput = Schema.Struct({ modelApiKey: Schema.String });
 function cmsTool(name, description, parameters) {
@@ -211,48 +178,60 @@ function cmsTool(name, description, parameters) {
 		failure: Schema.Unknown,
 		dependencies: CommonDependencies
 	});
-	const isReadonly = name.startsWith("query_") || name.startsWith("get_") || name === "schema_info" || name === "build_structured_text" || name === "search_content";
+	const isReadonly = name.startsWith("query_") || name.startsWith("get_") || name === "schema_info" || name === "search_content";
 	tool = tool.annotate(AiTool.Readonly, isReadonly);
 	tool = tool.annotate(AiTool.Idempotent, isReadonly || name.startsWith("update_") || name.startsWith("replace_"));
 	tool = tool.annotate(AiTool.Destructive, name.startsWith("delete_") || name === "remove_block");
 	tool = tool.annotate(AiTool.OpenWorld, name === "search_content");
 	return tool;
 }
-/**
-* Parse a text string with inline markdown into DAST inline (span) nodes.
-* Returns the children of the first paragraph, or a single span fallback.
-*/
-function parseInlineSpans(text) {
-	const first = markdownToDast(text).document.children.at(0);
-	if (first != null && "children" in first) return first.children;
-	return [{
-		type: "span",
-		value: text
-	}];
-}
-function collectBlockRefs(node, refs = /* @__PURE__ */ new Set()) {
-	if (node == null || typeof node !== "object") return refs;
-	if (Array.isArray(node)) {
-		for (const entry of node) collectBlockRefs(entry, refs);
-		return refs;
-	}
-	if ("type" in node && node.type === "block" && "item" in node && typeof node.item === "string") refs.add(node.item);
-	for (const value of Object.values(node)) collectBlockRefs(value, refs);
-	return refs;
-}
-function assertKnownBlockRefs(blockMap, refs) {
-	for (const ref of refs) if (!(ref in blockMap)) throw new Error(`Unknown block ref '${ref}'. Define it in blocks before referencing it.`);
-}
-function assertNoUnusedBlocks(blockMap, refs) {
-	const unused = Object.keys(blockMap).filter((id) => !refs.has(id));
-	if (unused.length > 0) throw new Error(`Unused blocks: ${unused.join(", ")}. Every block must be referenced in the document.`);
-}
 function toStructuredContent(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 function isToolPayload(value) {
 	return value !== null && typeof value === "object";
 }
+function compactPatchBlocksResponse(fullRecord, fieldApiKey, deletedBlockIds) {
+	const fieldValue = fullRecord[fieldApiKey];
+	const envelope = (() => {
+		if (fieldValue === null || fieldValue === void 0) return null;
+		if (typeof fieldValue === "string") try {
+			return JSON.parse(fieldValue);
+		} catch {
+			return null;
+		}
+		if (typeof fieldValue === "object" && !Array.isArray(fieldValue)) return fieldValue;
+		return null;
+	})();
+	if (!envelope) return {
+		recordId: fullRecord.id,
+		status: fullRecord._status ?? null,
+		fieldApiKey,
+		field: null,
+		blocks: {},
+		deleted: deletedBlockIds,
+		blockOrder: []
+	};
+	const blocks = typeof envelope.blocks === "object" && envelope.blocks !== null && !Array.isArray(envelope.blocks) ? envelope.blocks : {};
+	const blockOrder = [];
+	function walkDast(node) {
+		if (typeof node !== "object" || node === null) return;
+		const n = node;
+		if (n.type === "block" && typeof n.item === "string") blockOrder.push(n.item);
+		if (Array.isArray(n.children)) n.children.forEach(walkDast);
+	}
+	const value = envelope.value;
+	if (typeof value === "object" && value !== null) walkDast(value.document);
+	return {
+		recordId: fullRecord.id,
+		status: fullRecord._status ?? null,
+		fieldApiKey,
+		field: envelope,
+		blocks,
+		deleted: deletedBlockIds,
+		blockOrder
+	};
+}
 function parseValidators(value) {
 	if (value == null || value === "") return {};
 	if (typeof value === "string") return decodeJsonRecordStringOr(value, {});
@@ -297,10 +276,10 @@ Key validators by field type:
 const UpdateFieldTool = cmsTool("update_field", "Update field properties (label, apiKey, validators, hint)", UpdateFieldInput.fields);
 const DeleteModelTool = cmsTool("delete_model", "Delete a model (fails if referenced)", ModelIdInput.fields);
 const DeleteFieldTool = cmsTool("delete_field", "Delete a field and drop column", FieldIdInput.fields);
-const CreateRecordTool = cmsTool("create_record", `Create a content record. Records on draft-enabled models start as draft — call publish_records to make them visible in GraphQL.
+const CreateRecordTool = cmsTool("create_record", `Create a content record. Records on draft-enabled models start as draft — call set_publish_status to make them visible in GraphQL.
 
 Validation note:
-- For models with drafts (has_draft=true), required-field validation is deferred until publish_records.
+- For models with drafts (has_draft=true), required-field validation is deferred until set_publish_status.
 - For models without drafts (has_draft=false), required fields are enforced during create_record.
 
 Field value formats:
@@ -309,10 +288,20 @@ Field value formats:
 - link: record ID string
 - links: array of record ID strings
 - seo: {"title":"...","description":"...","image":"<asset_id>","twitterCard":"summary_large_image"}
-- structured_text: {"value":{"schema":"dast","document":{...}},"blocks":{"<id>":{"_type":"block_api_key",...}}}
+- structured_text: markdown string, typed nodes array, {markdown:"...",blocks:[...]}, {nodes:[...],blocks:[...]}, or full DAST envelope {"value":{"schema":"dast","document":{...}},"blocks":{...}}
+  Markdown mode is the easiest way to write prose. Standard inline formatting (**bold**, *italic*, \`code\`, ~~strikethrough~~, [links](url)) all work.
+  Special sentinels for CMS references in markdown:
+  - Block refs: <!-- cms:block:BLOCK_ID --> (on its own line)
+  - Inline items: <!-- cms:inlineItem:RECORD_ID -->
+  - Inline blocks: <!-- cms:inlineBlock:BLOCK_ID -->
+  - Record links: [link text](itemLink:RECORD_ID)
+  When using {markdown, blocks}, the blocks array/map provides block data and sentinels place them in the document.
+  Those block field values are persisted by the same create_record/update_record call — you do not need a follow-up patch_blocks call just to save the initial block payload.
 - color: {"red":255,"green":0,"blue":0,"alpha":255}
 - lat_lon: {"latitude":64.13,"longitude":-21.89}`, CreateRecordInput.fields);
-const UpdateRecordTool = cmsTool("update_record", "Update record fields. For singletons, recordId can be omitted — the single record is found automatically.", UpdateRecordInput.fields);
+const UpdateRecordTool = cmsTool("update_record", `Update record fields. For singletons, recordId can be omitted — the single record is found automatically.
+
+Accepts all the same field value formats as create_record, including markdown mode for structured_text. For editorial content edits, prefer markdown mode over hand-assembled DAST — it's simpler and less error-prone.`, UpdateRecordInput.fields);
 const PatchBlocksTool = cmsTool("patch_blocks", `Partially update blocks in a structured text field without resending the entire content tree.
 
 You can target block IDs from either:
@@ -320,26 +309,34 @@ You can target block IDs from either:
 - nested structured_text sub-fields stored inside those blocks
 
 Patch map semantics for each block ID:
-- string value (the block ID) → keep block unchanged
 - object with field overrides → merge into existing block (only specified fields updated)
 - null → delete block and auto-prune from the relevant DAST tree
 
-Block IDs not in the patch map are kept unchanged.
+Block IDs not in the patch map are kept unchanged. Omit a block ID to leave it as-is.
 
 If a nested block ID appears in multiple nested structured_text locations, the tool will fail and ask you to patch the parent block explicitly.
 
 Optionally provide a new top-level DAST \`value\`. If omitted, the existing DAST is preserved (with deleted top-level blocks auto-pruned).
 
+Use \`append\` to insert new blocks without reconstructing the DAST. Each entry is a record with \`_type\` and field values. New block IDs are auto-generated, DAST block nodes are appended to the end, and the response includes \`_appendedIds\`. Cannot be combined with \`value\`.
+
+For blocks_only structured_text fields, you can pass an \`order\` array of block IDs to reorder blocks without constructing a full DAST document. The order array replaces the DAST children list. Cannot be combined with \`value\`. All block IDs in \`order\` must exist in the merged blocks map, and all merged blocks must appear in \`order\`.
+
 Example — update one block's description, delete another, keep the rest:
-{ blocks: { "block-1": "block-1", "block-2": { "description": "New text" }, "block-3": null } }`, PatchBlocksInput.fields);
+{ blocks: { "block-2": { "description": "New text" }, "block-3": null } }
+
+Example — append a new block while patching an existing one:
+{ blocks: { "block-2": { "description": "Updated" } }, append: [{ "_type": "venue", "name": "New Place" }] }
+
+Example — reorder blocks on a blocks_only field:
+{ order: ["block-3", "block-1", "block-2"], blocks: {} }`, PatchBlocksInput.fields);
 const DeleteRecordTool = cmsTool("delete_record", "Delete a record", DeleteRecordInput.fields);
-const GetRecordTool = cmsTool("get_record", "Get a single record by modelApiKey + recordId. Useful after search_content when you need the full materialized record, including structured_text fields, before patch_blocks or update_record.", GetRecordInput.fields);
-const QueryRecordsTool = cmsTool("query_records", "List records for a model. Structured_text fields are materialized for inspection, including nested blocks inside parent block fields. Useful for finding record IDs before update_record, patch_blocks, publish_records, or record_versions.", QueryRecordsInput.fields);
+const GetRecordTool = cmsTool("get_record", "Get a single record by modelApiKey + recordId. Useful after search_content when you need the full materialized record, including structured_text fields, before patch_blocks or update_record. This is a workspace/content-management read tool, not a substitute for final live verification via GraphQL or the site URL.", GetRecordInput.fields);
+const QueryRecordsTool = cmsTool("query_records", "List records for a model. Structured_text fields are materialized for inspection, including nested blocks inside parent block fields. Useful for finding record IDs before update_record, patch_blocks, set_publish_status, or record_versions. Use GraphQL or the site URL for final public/live verification after publishing.", QueryRecordsInput.fields);
 const BulkCreateRecordsTool = cmsTool("bulk_create_records", `Create multiple records in one operation (up to 1000). Much faster than calling create_record in a loop.
 
 All records must belong to the same model. Slugs are auto-generated. Returns {created, records}, where records is an array of objects like {id}.`, BulkCreateRecordsInput.fields);
-const PublishRecordsTool = cmsTool("publish_records", "Publish one or more records. Required/unique validation is enforced at publish time for draft-enabled models. Pass recordIds as an array, even for a single record.", PublishRecordsInput.fields);
-const UnpublishRecordsTool = cmsTool("unpublish_records", "Unpublish one or more records.", PublishRecordsInput.fields);
+const SetPublishStatusTool = cmsTool("set_publish_status", "Publish or unpublish one or more records. Pass recordIds as an array, even for a single record. Required-field validation is enforced at publish time for draft-enabled models.", SetPublishStatusInput.fields);
 const ScheduleTool = cmsTool("schedule", `Schedule a record to publish or unpublish at a future ISO datetime, or clear both schedules.
 
 action: "publish" | "unpublish" | "clear"
@@ -354,37 +351,6 @@ action: "list" | "get" | "restore"
 const ReorderRecordsTool = cmsTool("reorder_records", "Reorder records in a sortable/tree model by providing ordered record IDs", ReorderInput.fields);
 const RemoveBlockTool = cmsTool("remove_block", "Remove a block type entirely (cleans DAST trees, deletes blocks, drops table), or remove it from a specific field's whitelist (provide fieldId).", RemoveBlockInput.fields);
 const RemoveLocaleTool = cmsTool("remove_locale", "Remove a locale and strip it from all localized field values", LocaleIdInput.fields);
-const BuildStructuredTextTool = cmsTool("build_structured_text", `Build a StructuredText value from typed nodes or markdown, plus optional block definitions.
-
-Two modes:
-1. Typed nodes (provide "nodes"): precise control over document structure
-2. Markdown (provide "markdown"): natural formatting for prose-heavy content
-
-Workflow: prepare blocks first, then reference them in nodes or markdown.
-
-blocks: [{id: "v1", type: "venue", data: {name: "Chickpea", image: "asset_id"}}]
-
-Typed nodes (text structure referencing blocks by ID):
-- paragraph: {type:"paragraph", text:"Inline **markdown** and [links](url) supported"}
-- heading: {type:"heading", level:2, text:"Section Title"}
-- code: {type:"code", code:"const x = 1", language:"typescript"}
-- blockquote: {type:"blockquote", text:"Quote text"}
-- list: {type:"list", style:"bulleted"|"numbered", items:["First","Second"]}
-- thematicBreak: {type:"thematicBreak"}
-- block: {type:"block", ref:"v1"} — places a block defined in the blocks array
-
-Markdown mode: write standard markdown. Place blocks with sentinels: <!-- cms:block:BLOCK_ID -->
-
-Inline markdown in text fields: **bold**, *italic*, \`code\`, [links](url), ~~strikethrough~~.
-
-Encoding note: MCP tool arguments are XML-encoded by some clients. If any literal string in your structured text includes angle brackets (for example TypeScript generics like <T>, JSX, or HTML snippets), escape them as Unicode in the JSON string: \u003C and \u003E.
-
-For nested blocks (e.g. sections containing venues), compose bottom-up:
-1. Build inner structured text (venues) → get {value, blocks} result
-2. Use that result as a field value in a parent block's data
-3. Build outer structured text (sections) referencing the parent blocks
-
-IMPORTANT: Call schema_info first to verify which block types are allowed on the target structured_text field (check the structured_text_blocks validator).`, BuildStructuredTextInput.fields);
 const UploadAssetTool = cmsTool("upload_asset", `Register an asset after uploading the original file to R2 out of band.
 
 Upload flow:
@@ -427,6 +393,15 @@ const UpdateSiteSettingsTool = cmsTool("update_site_settings", `Update global si
 Use this tool for fields like siteName, titleSuffix, fallbackSeoTitle, and fallbackSeoDescription.
 If your schema also has a singleton content model named site_settings with fields like tagline or logo, update that record with query_records + update_record instead of this tool.
 When the task is specifically about the singleton record, avoid mixing both surfaces unless the user explicitly asks for both.`, UpdateSiteSettingsInput.fields);
+const EditorTokensTool = cmsTool("editor_tokens", `Manage editor tokens: create, list, or revoke.
+
+action: "create" | "list" | "revoke"
+- create: provide name, optional expiresIn (seconds). Returns token for restricted write access (no schema mutations).
+- list: returns all non-expired editor tokens.
+- revoke: provide tokenId to revoke.`, EditorTokensInput.fields);
+const GetPreviewUrlTool = cmsTool("get_preview_url", `Generate a preview URL for a draft record. The model must have a canonicalPathTemplate set (e.g. /posts/{slug}).
+
+Returns a fully assembled URL with a short-lived preview token when siteUrl is configured, or the previewPath and token separately otherwise.`, GetPreviewUrlInput.fields);
 const AdminTools = [
 	SchemaInfoTool,
 	CreateModelTool,
@@ -442,14 +417,12 @@ const AdminTools = [
 	GetRecordTool,
 	QueryRecordsTool,
 	BulkCreateRecordsTool,
-	PublishRecordsTool,
-	UnpublishRecordsTool,
+	SetPublishStatusTool,
 	ScheduleTool,
 	RecordVersionsTool,
 	ReorderRecordsTool,
 	RemoveBlockTool,
 	RemoveLocaleTool,
-	BuildStructuredTextTool,
 	UploadAssetTool,
 	ImportAssetFromUrlTool,
 	ListAssetsTool,
@@ -459,12 +432,8 @@ const AdminTools = [
 	ReindexSearchTool,
 	GetSiteSettingsTool,
 	UpdateSiteSettingsTool,
-	cmsTool("editor_tokens", `Manage editor tokens: create, list, or revoke.
-
-action: "create" | "list" | "revoke"
-- create: provide name, optional expiresIn (seconds). Returns token for restricted write access (no schema mutations).
-- list: returns all non-expired editor tokens.
-- revoke: provide tokenId to revoke.`, EditorTokensInput.fields)
+	EditorTokensTool,
+	GetPreviewUrlTool
 ];
 const EditorTools = [
 	SchemaInfoTool,
@@ -475,23 +444,30 @@ const EditorTools = [
 	GetRecordTool,
 	QueryRecordsTool,
 	BulkCreateRecordsTool,
-	PublishRecordsTool,
-	UnpublishRecordsTool,
+	SetPublishStatusTool,
 	ScheduleTool,
 	RecordVersionsTool,
 	ReorderRecordsTool,
-	BuildStructuredTextTool,
 	UploadAssetTool,
 	ImportAssetFromUrlTool,
 	ListAssetsTool,
 	ReplaceAssetTool,
-	SchemaIOTool,
 	SearchContentTool,
 	GetSiteSettingsTool,
-	UpdateSiteSettingsTool
+	UpdateSiteSettingsTool,
+	GetPreviewUrlTool
 ];
 const CmsToolkit = Toolkit.make(...AdminTools);
 const EditorToolkit = Toolkit.make(...EditorTools);
+/** Tool metadata for Code Mode — extracted without MCP protocol overhead */
+function getToolMeta(mode = "admin") {
+	const toolkit = mode === "editor" ? EditorToolkit : CmsToolkit;
+	return Object.values(toolkit.tools).map((tool) => ({
+		name: tool.name,
+		description: tool.description ?? "",
+		inputSchema: toMcpInputSchema(tool)
+	}));
+}
 function createGuideResource() {
 	return McpServer.resource({
 		uri: "agent-cms://guide",
@@ -505,7 +481,7 @@ Server boundary:
   - Editor MCP: /mcp/editor — content/publishing/assets/search only. If a schema-mutation tool is missing, you are probably on the editor MCP and should switch surfaces instead of retrying.
 
 Workflow order:
-  schema_info -> create_model -> create_field -> create_record -> publish_records
+  schema_info -> create_model -> create_field -> create_record -> set_publish_status
 
 Naming conventions:
   - api_key: snake_case (e.g. blog_post, cover_image)
@@ -521,22 +497,30 @@ Field value formats (composite types):
   - link: record ID string
   - links: array of record ID strings
   - seo: {"title":"...","description":"...","image":"<asset_id>","twitterCard":"summary_large_image"}
-  - structured_text: {"value":{"schema":"dast","document":{...}},"blocks":{"<id>":{"_type":"block_api_key",...}}}
+  - structured_text: markdown string, typed nodes array, {markdown:"...",blocks:[...]}, {nodes:[...],blocks:[...]}, or full DAST envelope {"value":{"schema":"dast","document":{...}},"blocks":{...}}
+    Prefer markdown mode for prose-heavy content. Inline formatting, links, and block placement all work. Initial block payloads are persisted by the same create_record/update_record call; patch_blocks is for later targeted edits, not for finishing initial block creation:
+    - Standard markdown: **bold**, *italic*, \`code\`, ~~strike~~, [links](url)
+    - Block refs: <!-- cms:block:BLOCK_ID --> (own line)
+    - Record links: [link text](itemLink:RECORD_ID)
+    - Inline items: <!-- cms:inlineItem:RECORD_ID -->
+    - Inline blocks: <!-- cms:inlineBlock:BLOCK_ID -->
   - color: {"red":255,"green":0,"blue":0,"alpha":255}
   - lat_lon: {"latitude":64.13,"longitude":-21.89}
 
 Structured text editing notes:
   - patch_blocks can target both top-level blocks and nested blocks inside structured_text sub-fields.
   - If the same nested block ID exists in multiple locations, patch_blocks will ask you to patch the parent block explicitly.
+  - patch_blocks supports an \`append\` array to insert new blocks without rebuilding the DAST. Each entry needs \`_type\` plus field values. New block nodes are appended to the end of the document. The response includes \`_appendedIds\` with the generated IDs.
   - get_record is the fastest way to inspect one known record's full materialized structured_text after search_content returns its id.
   - query_records materializes structured_text fields for inspection; on published records, _published_snapshot remains useful as a raw snapshot of what is live.
 
 Draft/publish lifecycle:
-  Records on draft-enabled models start as drafts. create_record returns the created draft record object, including its top-level id. Call publish_records with that recordId to make it visible in GraphQL.
-  Use publish_records and unpublish_records for both single and bulk operations — just pass an array of recordIds.
+  Records on draft-enabled models start as drafts. create_record returns the created draft record object, including its top-level id. Call set_publish_status with action "publish" and that recordId to make it visible in GraphQL.
+  Use set_publish_status for both publish and unpublish, single and bulk operations — just pass an array of recordIds and the desired action.
   Required-field validation for draft-enabled models happens at publish time, not create_record time.
   Edits after publishing create a new draft version — publish again to update.
   GraphQL serves published content by default; use X-Include-Drafts header for previews.
+  If a task says to verify what is live or publicly visible, do that via GraphQL or the site URL after publishing — not via query_records/get_record, which show workspace state rather than the public delivery surface.
 
 Singletons and site settings:
   - If a singleton exists as a normal content model in your schema (for example a site_settings record with fields like tagline), treat it like content. Use update_record without recordId for direct singleton edits, or query_records + update_record if you need to inspect first.
@@ -556,7 +540,7 @@ Asset upload flow:
 Tool argument encoding:
   - Some MCP clients XML-encode tool arguments before they reach the server.
   - If a literal string value contains angle brackets (for example TypeScript generics like <T>, JSX, or inline HTML), escape them inside the JSON string as \u003C and \u003E.
-  - This matters most for build_structured_text code nodes and any create_record/update_record payload carrying code snippets.
+  - This matters most for create_record/update_record payloads carrying code snippets in structured_text fields.
 
 Raw HTTP / JSON-RPC access:
   - Endpoint: POST <mount>/mcp for admin, POST <mount>/mcp/editor for editor
@@ -570,13 +554,25 @@ Raw HTTP / JSON-RPC access:
     .result.content[0].text | fromjson
   - For single-record tools like import_asset_from_url, create_record, and get_record, that parsed payload is the object itself, so use payload.id directly rather than looking for nested arrays
 
+Draft preview:
+  Models can have a canonicalPathTemplate (e.g. /posts/{slug}) for preview URLs.
+  Tool responses include _previewPath when a template is set.
+  Use get_preview_url to generate a fully assembled preview link with a short-lived token.
+
 Slug fields:
   Set validator {"slug_source": "title"} to auto-generate from a source field.
   Create the slug field AFTER the source field.
 
 Pluralization:
   category -> allCategories, blog_post -> allBlogPosts, person -> allPeople
-  Powered by standard English pluralization rules.`)
+  Powered by standard English pluralization rules.
+
+Translation:
+  For translating structured_text fields, work with the markdown representation.
+  Translate the full markdown document — not field by field — to preserve context, tone, and flow.
+  Leave block sentinels (<!-- cms:block:ID -->), record links ([text](itemLink:ID)), and inline refs untouched.
+  The CMS reconstructs DAST from the translated markdown when you update the record.
+  This gives full article context for fluid translations vs. isolated sentence-level machine translation.`)
 	});
 }
 function createSchemaResource() {
@@ -638,7 +634,7 @@ Follow these steps:
 3. Present your plan before executing — list models, fields, and relationships.
 4. Create models first, then fields in order (slug fields after their source).
 5. Create a few sample records to verify the schema works.
-6. Publish the sample records with publish_records.
+6. Publish the sample records with set_publish_status.
 7. Show the GraphQL query that a frontend would use to fetch this content.
    Remember: api_key snake_case -> GraphQL camelCase fields, PascalCase types.`)
 	});
@@ -695,6 +691,34 @@ function createMcpLayer(sqlLayer, options) {
 			url
 		} : asset;
 	}
+	/** Look up canonical_path_template for a model and resolve _previewPath if set */
+	function addPreviewPath(modelApiKey, record) {
+		return Effect.gen(function* () {
+			if (typeof record !== "object" || record === null) return record;
+			const template = (yield* (yield* SqlClient.SqlClient).unsafe("SELECT canonical_path_template FROM models WHERE api_key = ?", [modelApiKey]))[0]?.canonical_path_template;
+			if (!template) return record;
+			const previewPath = resolvePreviewPath(template, record);
+			return {
+				...record,
+				_previewPath: previewPath
+			};
+		});
+	}
+	function addPreviewPathToList(modelApiKey, records) {
+		return Effect.gen(function* () {
+			if (!Array.isArray(records)) return records;
+			const template = (yield* (yield* SqlClient.SqlClient).unsafe("SELECT canonical_path_template FROM models WHERE api_key = ?", [modelApiKey]))[0]?.canonical_path_template;
+			if (!template) return records;
+			return records.map((r) => {
+				if (typeof r !== "object" || r === null) return r;
+				const previewPath = resolvePreviewPath(template, r);
+				return {
+					...r,
+					_previewPath: previewPath
+				};
+			});
+		});
+	}
 	const toolHandlers = {
 		schema_info: withDecoded(SchemaInfoInput, ({ filterByName, filterByType, includeFieldDetails }) => Effect.gen(function* () {
 			const sql = yield* SqlClient.SqlClient;
@@ -735,6 +759,7 @@ function createMcpLayer(sqlLayer, options) {
 						sortable: !!m.sortable,
 						tree: !!m.tree,
 						allLocalesRequired: !!m.all_locales_required,
+						canonicalPathTemplate: m.canonical_path_template ?? null,
 						...includeFieldDetails ? { fields: mFields.map((f) => ({
 							id: f.id,
 							label: f.label,
@@ -760,24 +785,27 @@ function createMcpLayer(sqlLayer, options) {
 		update_field: withDecoded(UpdateFieldInput, ({ fieldId, ...rest }) => updateField(fieldId, rest)),
 		delete_model: withDecoded(ModelIdInput, ({ modelId }) => deleteModel(modelId)),
 		delete_field: withDecoded(FieldIdInput, ({ fieldId }) => deleteField(fieldId)),
-		create_record: withDecoded(CreateRecordInput, (input) => createRecord(input, options?.actor)),
+		create_record: withDecoded(CreateRecordInput, (input) => createRecord(input, options?.actor).pipe(Effect.flatMap((r) => addPreviewPath(input.modelApiKey, r)))),
 		update_record: withDecoded(UpdateRecordInput, ({ recordId, modelApiKey, data }) => {
-			if (recordId) return patchRecord(recordId, {
+			return (recordId ? patchRecord(recordId, {
 				modelApiKey,
 				data
-			}, options?.actor);
-			return updateSingletonRecord(modelApiKey, data, options?.actor);
+			}, options?.actor) : updateSingletonRecord(modelApiKey, data, options?.actor)).pipe(Effect.flatMap((r) => addPreviewPath(modelApiKey, r)));
 		}),
-		patch_blocks: withDecoded(PatchBlocksInput, (input) => patchBlocksForField(input, options?.actor)),
+		patch_blocks: withDecoded(PatchBlocksInput, (input) => patchBlocksForField(input, options?.actor).pipe(Effect.map((record) => {
+			const deletedIds = Object.entries(input.blocks).filter(([, v]) => v === null).map(([k]) => k);
+			return compactPatchBlocksResponse(record, input.fieldApiKey, deletedIds);
+		}))),
 		delete_record: withDecoded(DeleteRecordInput, ({ recordId, modelApiKey }) => removeRecord(modelApiKey, recordId)),
-		get_record: withDecoded(GetRecordInput, ({ recordId, modelApiKey }) => getRecord(modelApiKey, recordId)),
-		query_records: withDecoded(QueryRecordsInput, ({ modelApiKey }) => listRecords(modelApiKey)),
+		get_record: withDecoded(GetRecordInput, ({ recordId, modelApiKey }) => getRecord(modelApiKey, recordId).pipe(Effect.flatMap((r) => addPreviewPath(modelApiKey, r)))),
+		query_records: withDecoded(QueryRecordsInput, ({ modelApiKey }) => listRecords(modelApiKey).pipe(Effect.flatMap((r) => addPreviewPathToList(modelApiKey, r)))),
 		bulk_create_records: withDecoded(BulkCreateRecordsInput, ({ modelApiKey, records }) => bulkCreateRecords({
 			modelApiKey,
 			records
 		}, options?.actor)),
-		publish_records: withDecoded(PublishRecordsInput, ({ recordIds, modelApiKey }) => recordIds.length === 1 ? publishRecord(modelApiKey, recordIds[0], options?.actor) : bulkPublishRecords(modelApiKey, recordIds, options?.actor)),
-		unpublish_records: withDecoded(PublishRecordsInput, ({ recordIds, modelApiKey }) => recordIds.length === 1 ? unpublishRecord(modelApiKey, recordIds[0], options?.actor) : bulkUnpublishRecords(modelApiKey, recordIds, options?.actor)),
+		set_publish_status: withDecoded(SetPublishStatusInput, ({ action, recordIds, modelApiKey }) => {
+			return action === "publish" ? recordIds.length === 1 ? publishRecord(modelApiKey, recordIds[0], options?.actor) : bulkPublishRecords(modelApiKey, recordIds, options?.actor) : recordIds.length === 1 ? unpublishRecord(modelApiKey, recordIds[0], options?.actor) : bulkUnpublishRecords(modelApiKey, recordIds, options?.actor);
+		}),
 		schedule: withDecoded(ScheduleInput, ({ recordId, modelApiKey, action, at }) => {
 			if (action === "clear") return clearSchedule(modelApiKey, recordId, options?.actor);
 			if (action === "publish") return schedulePublish(modelApiKey, recordId, at ?? null, options?.actor);
@@ -807,88 +835,6 @@ function createMcpLayer(sqlLayer, options) {
 			return removeBlockType(blockApiKey);
 		}),
 		remove_locale: withDecoded(LocaleIdInput, ({ localeId }) => removeLocale(localeId)),
-		build_structured_text: withDecoded(BuildStructuredTextInput, ({ markdown, blocks, nodes }) => Effect.sync(() => {
-			const blockMap = {};
-			for (const b of blocks ?? []) blockMap[b.id] = {
-				_type: b.type,
-				...b.data
-			};
-			if (markdown != null) {
-				const doc = markdownToDast(markdown);
-				const refs = collectBlockRefs(doc.document);
-				assertKnownBlockRefs(blockMap, refs);
-				assertNoUnusedBlocks(blockMap, refs);
-				return {
-					value: doc,
-					blocks: blockMap
-				};
-			}
-			const children = [];
-			for (const node of nodes ?? []) switch (node.type) {
-				case "paragraph":
-					children.push({
-						type: "paragraph",
-						children: parseInlineSpans(node.text)
-					});
-					break;
-				case "heading":
-					children.push({
-						type: "heading",
-						level: node.level,
-						children: parseInlineSpans(node.text)
-					});
-					break;
-				case "code":
-					children.push({
-						type: "code",
-						code: node.code,
-						...node.language ? { language: node.language } : {}
-					});
-					break;
-				case "blockquote":
-					children.push({
-						type: "blockquote",
-						children: [{
-							type: "paragraph",
-							children: parseInlineSpans(node.text)
-						}]
-					});
-					break;
-				case "list":
-					children.push({
-						type: "list",
-						style: node.style ?? "bulleted",
-						children: node.items.map((item) => ({
-							type: "listItem",
-							children: [{
-								type: "paragraph",
-								children: parseInlineSpans(item)
-							}]
-						}))
-					});
-					break;
-				case "thematicBreak":
-					children.push({ type: "thematicBreak" });
-					break;
-				case "block":
-					children.push({
-						type: "block",
-						item: node.ref
-					});
-					break;
-			}
-			assertKnownBlockRefs(blockMap, collectBlockRefs(children));
-			return {
-				value: {
-					schema: "dast",
-					document: {
-						type: "root",
-						children
-					}
-				},
-				blocks: blockMap
-			};
-		})),
 		upload_asset: withDecoded(CreateAssetInput, (input) => createAsset(input, options?.actor).pipe(Effect.map(withAssetUrl))),
 		import_asset_from_url: withDecoded(ImportAssetFromUrlInput, (input) => importAssetFromUrl(input, options?.actor).pipe(Effect.map(withAssetUrl))),
 		list_assets: () => listAssets().pipe(Effect.map((assets) => assets.map((a) => {
@@ -911,6 +857,29 @@ function createMcpLayer(sqlLayer, options) {
 		reindex_search: withDecoded(ReindexSearchInput, ({ modelApiKey }) => reindexAll(modelApiKey)),
 		get_site_settings: () => getSiteSettings(),
 		update_site_settings: withDecoded(UpdateSiteSettingsInput, updateSiteSettings),
+		get_preview_url: withDecoded(GetPreviewUrlInput, ({ recordId, modelApiKey }) => Effect.gen(function* () {
+			const model = yield* getModelByApiKey(modelApiKey);
+			if (!model.canonical_path_template) return yield* Effect.fail({
+				_tag: "ValidationError",
+				message: `Model '${modelApiKey}' has no canonicalPathTemplate configured`
+			});
+			const record = yield* getRecord(modelApiKey, recordId);
+			const recordData = typeof record === "object" && record !== null ? record : {};
+			const previewPath = resolvePreviewPath(model.canonical_path_template, recordData);
+			const { token, expiresAt } = yield* createPreviewToken();
+			const siteUrl = options?.siteUrl;
+			if (siteUrl) return {
+				url: `${siteUrl.replace(/\/$/, "")}/api/draft-mode/enable?token=${encodeURIComponent(token)}&redirect=${encodeURIComponent(previewPath)}`,
+				previewPath,
+				token,
+				expiresAt
+			};
+			return {
+				previewPath,
+				token,
+				expiresAt
+			};
+		})),
 		editor_tokens: withDecoded(EditorTokensInput, ({ action, name, expiresIn, tokenId }) => {
 			if (action === "list") return listEditorTokens();
 			if (action === "create") {
@@ -978,16 +947,6 @@ function createMcpLayer(sqlLayer, options) {
 	return Layer.merge(serverLayer, registeredContent).pipe(Layer.provide(fullLayer));
 }
 //#endregion
-//#region src/mcp/http-transport.ts
-/**
-* Create a cached Web Standard handler for the Effect-native MCP server.
-*/
-function createMcpHttpHandler(sqlLayer, options) {
-	const mcpLayer = createMcpLayer(sqlLayer, options);
-	const { handler } = HttpLayerRouter.toWebHandler(mcpLayer, { disableLogger: true });
-	return handler;
-}
-//#endregion
-export { createMcpHttpHandler };
+export { getToolMeta as n, createMcpLayer as t };
 
-//# sourceMappingURL=http-transport-DbFCI6Cs.mjs.map
+//# sourceMappingURL=server-D0XqvDjU.mjs.map