agent-cms 0.1.0

package/dist/http-transport-DbFCI6Cs.mjs

@@ -0,0 +1,993 @@
+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 { 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";
+import * as Toolkit from "@effect/ai/Toolkit";
+//#region src/services/site-settings-service.ts
+const fieldMap = {
+	siteName: "site_name",
+	titleSuffix: "title_suffix",
+	noIndex: "no_index",
+	faviconId: "favicon_id",
+	facebookPageUrl: "facebook_page_url",
+	twitterAccount: "twitter_account",
+	fallbackSeoTitle: "fallback_seo_title",
+	fallbackSeoDescription: "fallback_seo_description",
+	fallbackSeoImageId: "fallback_seo_image_id",
+	fallbackSeoTwitterCard: "fallback_seo_twitter_card"
+};
+function mapMissingTable(error) {
+	if ((error instanceof Error ? error.message : String(error)).includes("no such table: site_settings")) return new SchemaEngineError({
+		message: "site_settings table not found. Run setup/migrations before using site settings.",
+		cause: error
+	});
+	return new SchemaEngineError({
+		message: "Failed to access site settings",
+		cause: error
+	});
+}
+function getSiteSettings() {
+	return Effect.gen(function* () {
+		const rows = yield* (yield* SqlClient.SqlClient).unsafe("SELECT * FROM site_settings LIMIT 1");
+		return rows.length > 0 ? rows[0] : { message: "No site settings configured yet. Use update_site_settings to create them." };
+	}).pipe(Effect.mapError(mapMissingTable));
+}
+function updateSiteSettings(args) {
+	return Effect.gen(function* () {
+		const sql = yield* SqlClient.SqlClient;
+		const sets = [];
+		const params = [];
+		for (const [key, value] of Object.entries(args)) {
+			const col = fieldMap[key];
+			sets.push(`"${col}" = ?`);
+			params.push(typeof value === "boolean" ? value ? 1 : 0 : value);
+		}
+		if (sets.length === 0) return yield* new ValidationError({ message: "No fields to update" });
+		sets.push(`"updated_at" = datetime('now')`);
+		yield* sql.unsafe(`INSERT OR IGNORE INTO site_settings (id) VALUES ('default')`);
+		yield* sql.unsafe(`UPDATE site_settings SET ${sets.join(", ")} WHERE id = 'default'`, params);
+		return (yield* sql.unsafe("SELECT * FROM site_settings WHERE id = 'default'"))[0];
+	}).pipe(Effect.mapError((error) => {
+		if (error instanceof ValidationError) return error;
+		return mapMissingTable(error);
+	}));
+}
+//#endregion
+//#region src/mcp/server.ts
+/**
+* Effect-native MCP (Model Context Protocol) server for agent-cms.
+* 3-layer architecture: Discovery -> Schema -> Content
+*/
+const JsonRecord = Schema.Record({
+	key: Schema.String,
+	value: Schema.Unknown
+});
+const CommonDependencies = [
+	SqlClient.SqlClient,
+	VectorizeContext,
+	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),
+	apiKey: Schema.optional(Schema.String),
+	singleton: Schema.optional(Schema.Boolean),
+	sortable: Schema.optional(Schema.Boolean),
+	hasDraft: Schema.optional(Schema.Boolean),
+	allLocalesRequired: Schema.optional(Schema.Boolean)
+});
+const UpdateFieldInput = Schema.Struct({
+	fieldId: Schema.String,
+	label: Schema.optional(Schema.String),
+	apiKey: Schema.optional(Schema.String),
+	validators: Schema.optional(JsonRecord),
+	hint: Schema.optional(Schema.String)
+});
+const ModelIdInput = Schema.Struct({ modelId: Schema.String });
+const FieldIdInput = Schema.Struct({ fieldId: Schema.String });
+const LocaleIdInput = Schema.Struct({ localeId: Schema.String });
+const SchemaInfoInput = Schema.Struct({
+	filterByName: Schema.optional(Schema.String),
+	filterByType: Schema.optional(Schema.Literal("model", "block")),
+	includeFieldDetails: Schema.optionalWith(Schema.Boolean, { default: () => true })
+});
+const UpdateRecordInput = Schema.Struct({
+	recordId: Schema.optional(Schema.String),
+	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
+});
+const QueryRecordsInput = Schema.Struct({ modelApiKey: Schema.String });
+const BulkCreateRecordsInput = Schema.Struct({
+	modelApiKey: Schema.String,
+	records: Schema.Array(JsonRecord)
+});
+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 ScheduleInput = Schema.Struct({
+	recordId: Schema.String,
+	modelApiKey: Schema.String,
+	action: Schema.Literal("publish", "unpublish", "clear"),
+	at: Schema.optional(Schema.NullOr(Schema.String))
+});
+const RecordVersionsInput = Schema.Struct({
+	action: Schema.Literal("list", "get", "restore"),
+	modelApiKey: Schema.String,
+	recordId: Schema.String,
+	versionId: Schema.optional(Schema.String)
+});
+const RemoveBlockInput = Schema.Struct({
+	blockApiKey: Schema.String,
+	fieldId: Schema.optional(Schema.String)
+});
+const ReplaceAssetInput = Schema.Struct({
+	assetId: Schema.String,
+	...CreateAssetInput.fields
+});
+const SchemaIOInput = Schema.Struct({
+	action: Schema.Literal("export", "import"),
+	schema: Schema.optional(ImportSchemaInput)
+});
+const UpdateSiteSettingsInput = Schema.Struct({
+	siteName: Schema.optional(Schema.String),
+	titleSuffix: Schema.optional(Schema.String),
+	noIndex: Schema.optional(Schema.Boolean),
+	faviconId: Schema.optional(Schema.String),
+	facebookPageUrl: Schema.optional(Schema.String),
+	twitterAccount: Schema.optional(Schema.String),
+	fallbackSeoTitle: Schema.optional(Schema.String),
+	fallbackSeoDescription: Schema.optional(Schema.String),
+	fallbackSeoImageId: Schema.optional(Schema.String),
+	fallbackSeoTwitterCard: Schema.optional(Schema.String)
+});
+const EditorTokensInput = Schema.Struct({
+	action: Schema.Literal("create", "list", "revoke"),
+	name: Schema.optional(Schema.String),
+	expiresIn: Schema.optional(Schema.Number.pipe(Schema.int(), Schema.positive())),
+	tokenId: Schema.optional(Schema.String)
+});
+const GetRecordInput = 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) {
+	let tool = AiTool.make(name, {
+		description,
+		parameters: parameters ?? {},
+		success: Schema.Unknown,
+		failure: Schema.Unknown,
+		dependencies: CommonDependencies
+	});
+	const isReadonly = name.startsWith("query_") || name.startsWith("get_") || name === "schema_info" || name === "build_structured_text" || 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 parseValidators(value) {
+	if (value == null || value === "") return {};
+	if (typeof value === "string") return decodeJsonRecordStringOr(value, {});
+	if (typeof value === "object" && !Array.isArray(value)) return value;
+	return {};
+}
+function withDecoded(schema, handler) {
+	return (params) => Schema.decodeUnknown(schema)(params).pipe(Effect.flatMap(handler));
+}
+function toMcpInputSchema(tool) {
+	const inputSchema = AiTool.getJsonSchema(tool);
+	return typeof inputSchema === "object" && "type" in inputSchema && inputSchema.type === "object" ? inputSchema : {
+		type: "object",
+		properties: {},
+		additionalProperties: false
+	};
+}
+function pickToolkitHandlers(toolkit, handlers) {
+	const filtered = {};
+	for (const name of Object.keys(toolkit.tools)) filtered[name] = handlers[name];
+	return filtered;
+}
+const SchemaInfoTool = cmsTool("schema_info", "Get the complete CMS schema in one call — models, block types, fields, relations. The primary tool for understanding the content model. Use filterByName to find a specific model.", SchemaInfoInput.fields);
+const CreateModelTool = cmsTool("create_model", "Create a content model or block type. Use isBlock:true for block types (embeddable in StructuredText). Use singleton:true for models with exactly one record (e.g. site settings). After creating a model, add fields with create_field.", CreateModelInput.fields);
+const UpdateModelTool = cmsTool("update_model", "Update model properties (name, apiKey, singleton, sortable, hasDraft, allLocalesRequired, ordering). Set ordering to a default sort like 'title_ASC', '_createdAt_DESC', '_position_ASC', or null to clear.", UpdateModelInput.fields);
+const CreateFieldTool = cmsTool("create_field", `Add a field to a model. Auto-migrates the database table (adds column).
+
+Key validators by field type:
+- slug: {"slug_source": "title"} — auto-generates from source field
+- string/text/slug: {"enum": ["draft","review","published"]} — restrict allowed values
+- string/text/slug: {"length": {"min": 10, "max": 160}} — character count limits
+- integer/float: {"number_range": {"min": 1, "max": 5}} — numeric bounds
+- string/text/slug: {"format": "email"} or {"format": "url"} or {"format": {"custom_pattern": "^[A-Z]{2}\\\\d{4}$"}} — string format checks
+- date/date_time: {"date_range": {"min": "now"}} — temporal bounds
+- link: {"item_item_type": ["model_api_key"]} — target model
+- links: {"items_item_type": ["model_api_key"]} — target model
+- structured_text: {"structured_text_blocks": ["block_api_key"]} — allowed block types
+- any field: {"required": true} — field is required (provide default_value for existing records)`, {
+	modelId: Schema.String,
+	...CreateFieldInput.fields
+});
+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.
+
+Validation note:
+- For models with drafts (has_draft=true), required-field validation is deferred until publish_records.
+- For models without drafts (has_draft=false), required fields are enforced during create_record.
+
+Field value formats:
+- media: asset ID string, or {"upload_id":"<asset_id>","alt":"...","title":"...","focal_point":{"x":0.5,"y":0.2},"custom_data":{...}}
+- media_gallery: array of asset IDs and/or media override objects
+- 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",...}}}
+- 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 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:
+- the field's top-level \`blocks\` map, or
+- 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.
+
+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).
+
+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);
+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 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 ScheduleTool = cmsTool("schedule", `Schedule a record to publish or unpublish at a future ISO datetime, or clear both schedules.
+
+action: "publish" | "unpublish" | "clear"
+- publish/unpublish: provide at (ISO datetime string)
+- clear: at is ignored`, ScheduleInput.fields);
+const RecordVersionsTool = cmsTool("record_versions", `Manage record versions: list all versions, get a snapshot, or restore a previous version.
+
+action: "list" | "get" | "restore"
+- list: returns all version snapshots for a record, newest first
+- get: returns a specific version snapshot (provide versionId)
+- restore: restores a previous version (provide versionId). Current state is versioned first, so restore is always reversible.`, RecordVersionsInput.fields);
+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:
+1. Upload the original file to R2
+2. Call this tool with the r2Key, filename, mimeType, and image dimensions
+3. The asset metadata is registered and can be referenced in media fields by its ID`, CreateAssetInput.fields);
+const ImportAssetFromUrlTool = cmsTool("import_asset_from_url", `Download an asset from a public URL, store it in R2, and register it in one step.
+
+Use this when you have an image URL and want an agent-friendly path.
+
+Flow:
+1. Provide the source URL
+2. The CMS fetches the file (following normal public HTTP redirects), stores it in R2, and creates the asset record
+3. Use the returned asset ID in media fields (e.g. {image: "<asset_id>"})
+
+The response includes id, r2Key, url (full public URL), and metadata. The id is what you pass to media fields — the CMS validates that the asset exists when creating/updating records.`, ImportAssetFromUrlInput.fields);
+const ListAssetsTool = cmsTool("list_assets", "List all assets with their IDs, filenames, and R2 keys");
+const ReplaceAssetTool = cmsTool("replace_asset", `Replace an asset's file metadata while keeping the same ID and URL. All content references remain stable.
+
+Flow:
+1. Upload the new original file to R2
+2. Call this tool with the asset ID and new file metadata
+3. The asset URL stays the same — no broken links in content`, ReplaceAssetInput.fields);
+const SchemaIOTool = cmsTool("schema_io", `Export or import the full CMS schema as portable JSON.
+
+action: "export" | "import"
+- export: returns schema JSON (models, fields, locales). No IDs — references use api_keys.
+- import: creates all locales, models, and fields in dependency order from provided schema. Use on a fresh/empty CMS.
+  Schema format: { "version": 1, "locales": [...], "models": [{ "name", "apiKey", "fields": [...] }] }`, SchemaIOInput.fields);
+const SearchContentTool = cmsTool("search_content", `Search content records. Supports keyword search (FTS5), semantic search (Vectorize), or hybrid (both combined with rank fusion).
+
+Keyword mode: phrases ("exact match"), prefix (word*), boolean (AND/OR).
+Semantic mode: finds conceptually related content even when vocabulary differs (requires AI+Vectorize bindings).
+Hybrid mode (default when Vectorize available): combines both for best results.
+Results include modelApiKey, recordId, title when available, rank, and snippet.`, SearchInput.fields);
+const ReindexSearchTool = cmsTool("reindex_search", "Rebuild FTS5 + Vectorize search indexes. Use after deploying search to a CMS with existing content, or to recover from index drift. Scoped to a single model or all content models.", ReindexSearchInput.fields);
+const GetSiteSettingsTool = cmsTool("get_site_settings", "Get global site settings from the built-in site_settings table (site name, title suffix, global SEO, favicon, social accounts). This is separate from any content-model singleton also named site_settings.");
+const UpdateSiteSettingsTool = cmsTool("update_site_settings", `Update global site settings in the built-in site_settings table. These power the _site GraphQL query (globalSeo, faviconMetaTags).
+
+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 AdminTools = [
+	SchemaInfoTool,
+	CreateModelTool,
+	UpdateModelTool,
+	CreateFieldTool,
+	UpdateFieldTool,
+	DeleteModelTool,
+	DeleteFieldTool,
+	CreateRecordTool,
+	UpdateRecordTool,
+	PatchBlocksTool,
+	DeleteRecordTool,
+	GetRecordTool,
+	QueryRecordsTool,
+	BulkCreateRecordsTool,
+	PublishRecordsTool,
+	UnpublishRecordsTool,
+	ScheduleTool,
+	RecordVersionsTool,
+	ReorderRecordsTool,
+	RemoveBlockTool,
+	RemoveLocaleTool,
+	BuildStructuredTextTool,
+	UploadAssetTool,
+	ImportAssetFromUrlTool,
+	ListAssetsTool,
+	ReplaceAssetTool,
+	SchemaIOTool,
+	SearchContentTool,
+	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)
+];
+const EditorTools = [
+	SchemaInfoTool,
+	CreateRecordTool,
+	UpdateRecordTool,
+	PatchBlocksTool,
+	DeleteRecordTool,
+	GetRecordTool,
+	QueryRecordsTool,
+	BulkCreateRecordsTool,
+	PublishRecordsTool,
+	UnpublishRecordsTool,
+	ScheduleTool,
+	RecordVersionsTool,
+	ReorderRecordsTool,
+	BuildStructuredTextTool,
+	UploadAssetTool,
+	ImportAssetFromUrlTool,
+	ListAssetsTool,
+	ReplaceAssetTool,
+	SchemaIOTool,
+	SearchContentTool,
+	GetSiteSettingsTool,
+	UpdateSiteSettingsTool
+];
+const CmsToolkit = Toolkit.make(...AdminTools);
+const EditorToolkit = Toolkit.make(...EditorTools);
+function createGuideResource() {
+	return McpServer.resource({
+		uri: "agent-cms://guide",
+		name: "agent-cms-guide",
+		description: "Orientation guide for agents: workflow, naming conventions, field formats, and lifecycle",
+		mimeType: "text/plain",
+		content: Effect.succeed(`agent-cms — Agent Orientation Guide
+
+Server boundary:
+  - Admin MCP: /mcp — includes schema mutation tools like create_model, create_field, delete_model, delete_field, schema_io, and token management.
+  - 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
+
+Naming conventions:
+  - api_key: snake_case (e.g. blog_post, cover_image)
+  - GraphQL types: PascalCase (BlogPost, CoverImageRecord)
+  - GraphQL fields: camelCase (coverImage, blogPost)
+  - GraphQL list queries: allBlogPosts, allCategories
+  - GraphQL single queries: blogPost, category
+  - Block types get "Record" suffix in GraphQL: code_block -> CodeBlockRecord
+
+Field value formats (composite types):
+  - media: asset ID string, or {"upload_id":"<asset_id>","alt":"...","title":"...","focal_point":{"x":0.5,"y":0.2},"custom_data":{...}}
+  - media_gallery: array of asset IDs and/or media override objects
+  - 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",...}}}
+  - 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.
+  - 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.
+  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.
+
+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.
+  - get_site_settings/update_site_settings operate on the built-in global site_settings table used by the _site GraphQL query. That surface uses fields like siteName, titleSuffix, fallbackSeoTitle, and fallbackSeoDescription.
+
+Asset upload flow:
+  Preferred:
+  1. Call import_asset_from_url with a public file URL (normal public redirects are followed automatically)
+  2. The parsed tool payload is the asset object itself; read its top-level id field
+  3. Use that returned asset ID in media/media_gallery fields
+
+  Manual fallback:
+  1. Upload file to R2 out of band
+  2. Register with upload_asset tool (pass r2Key, filename, mimeType, dimensions)
+  3. Use returned asset ID in media/media_gallery fields
+
+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.
+
+Raw HTTP / JSON-RPC access:
+  - Endpoint: POST <mount>/mcp for admin, POST <mount>/mcp/editor for editor
+  - The mount point may be nested (for example /cms/mcp), so scripts should reuse the exact MCP URL already configured in the client instead of assuming root-level /mcp
+  - Auth: Authorization: Bearer <token>
+  - For standalone curl/HTTP scripts, you can call tools/call directly; do not assume an initialize round-trip is required unless your specific client library expects it
+  - Typical tool call body:
+    {"jsonrpc":"2.0","method":"tools/call","params":{"name":"create_record","arguments":{...}},"id":1}
+  - Tool results usually come back in result.content[0].text as a JSON string payload
+  - jq extraction example:
+    .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
+
+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.`)
+	});
+}
+function createSchemaResource() {
+	return McpServer.resource({
+		uri: "agent-cms://schema",
+		name: "agent-cms-schema",
+		description: "Current CMS schema: models, fields, and locales as JSON",
+		mimeType: "application/json",
+		content: Effect.gen(function* () {
+			const sql = yield* SqlClient.SqlClient;
+			const models = yield* sql.unsafe("SELECT * FROM models ORDER BY is_block, created_at");
+			const fields = yield* sql.unsafe("SELECT * FROM fields ORDER BY model_id, position");
+			const locales = yield* sql.unsafe("SELECT * FROM locales ORDER BY position");
+			const fieldsByModel = /* @__PURE__ */ new Map();
+			for (const f of fields) {
+				const list = fieldsByModel.get(f.model_id) ?? [];
+				list.push(f);
+				fieldsByModel.set(f.model_id, list);
+			}
+			return encodeJson({
+				locales: locales.map((l) => ({
+					code: l.code,
+					position: l.position,
+					fallbackLocaleId: l.fallback_locale_id
+				})),
+				models: models.map((m) => ({
+					id: m.id,
+					name: m.name,
+					apiKey: m.api_key,
+					isBlock: !!m.is_block,
+					singleton: !!m.singleton,
+					fields: (fieldsByModel.get(m.id) ?? []).map((f) => ({
+						id: f.id,
+						apiKey: f.api_key,
+						label: f.label,
+						type: f.field_type,
+						localized: !!f.localized,
+						validators: parseValidators(f.validators)
+					}))
+				}))
+			});
+		})
+	});
+}
+function createSetupContentModelPrompt() {
+	return McpServer.prompt({
+		name: "setup-content-model",
+		description: "Guide an agent through designing and creating content models from a description",
+		parameters: SetupContentModelPromptInput,
+		content: ({ description }) => Effect.succeed(`Set up content models for: ${description}
+
+Follow these steps:
+1. Call schema_info to check existing models — avoid duplicates.
+2. Design the models and fields needed. Consider:
+   - Which are content models vs block types (for StructuredText embedding)?
+   - Which fields need slug (add after the source field with slug_source validator)?
+   - Which fields reference other models (link/links with item_item_type validator)?
+   - Which fields need structured_text (with structured_text_blocks validator for allowed blocks)?
+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.
+7. Show the GraphQL query that a frontend would use to fetch this content.
+   Remember: api_key snake_case -> GraphQL camelCase fields, PascalCase types.`)
+	});
+}
+function createGenerateGraphqlQueriesPrompt() {
+	return McpServer.prompt({
+		name: "generate-graphql-queries",
+		description: "Generate GraphQL queries for a content model with proper naming conventions",
+		parameters: GenerateGraphqlQueriesPromptInput,
+		content: ({ modelApiKey }) => Effect.succeed(`Generate GraphQL queries for the "${modelApiKey}" model.
+
+Steps:
+1. Call schema_info with filterByName "${modelApiKey}" to get the full field list.
+2. Map field names from snake_case (api_key) to camelCase (GraphQL).
+3. Generate these queries:
+   a. List query: all_<pluralized> with pagination, filtering, and ordering
+   b. Single query: <model_api_key> by ID or filter
+   c. Meta query: _all_<pluralized>_meta for total count
+4. For each field type, use the right GraphQL fragment:
+   - media -> { url width height alt title }
+   - structured_text -> { value blocks { ... on <BlockType>Record { id <fields> } } }
+   - link -> { id <fields of target model> }
+   - links -> same as link but array
+   - seo -> { title description image { url } twitterCard }
+   - color -> { red green blue alpha hex }
+   - lat_lon -> { latitude longitude }
+5. Include both a "full" query with all fields and a "list" query with essential fields only.`)
+	});
+}
+function createMcpLayer(sqlLayer, options) {
+	const mode = options?.mode ?? "admin";
+	const path = options?.path ?? (mode === "editor" ? "/mcp/editor" : "/mcp");
+	const toolkitAny = mode === "editor" ? EditorToolkit : CmsToolkit;
+	const defaultVectorizeLayer = Layer.succeed(VectorizeContext, Option.none());
+	const defaultHooksLayer = Layer.succeed(HooksContext, Option.none());
+	const defaultAssetImportLayer = Layer.succeed(AssetImportContext, {
+		r2Bucket: options?.r2Bucket,
+		fetch: options?.fetch ?? globalThis.fetch
+	});
+	const fullLayer = Layer.merge(Layer.merge(Layer.merge(defaultVectorizeLayer, defaultHooksLayer), defaultAssetImportLayer), sqlLayer);
+	const serverLayer = McpServer.layerHttpRouter({
+		name: mode === "editor" ? "agent-cms-editor" : "agent-cms",
+		version: "0.1.0",
+		path
+	});
+	function assetUrl(r2Key) {
+		if (!options?.assetBaseUrl) return void 0;
+		return `${options.assetBaseUrl.replace(/\/$/, "")}/${r2Key}`;
+	}
+	function withAssetUrl(asset) {
+		const url = assetUrl(asset.r2Key);
+		return url ? {
+			...asset,
+			url
+		} : asset;
+	}
+	const toolHandlers = {
+		schema_info: withDecoded(SchemaInfoInput, ({ filterByName, filterByType, includeFieldDetails }) => Effect.gen(function* () {
+			const sql = yield* SqlClient.SqlClient;
+			let modelQuery = "SELECT * FROM models";
+			const conditions = [];
+			const params = [];
+			if (filterByType === "model") conditions.push("is_block = 0");
+			if (filterByType === "block") conditions.push("is_block = 1");
+			if (filterByName) {
+				conditions.push("LOWER(name) LIKE ?");
+				params.push(`%${filterByName.toLowerCase()}%`);
+			}
+			if (conditions.length > 0) modelQuery += ` WHERE ${conditions.join(" AND ")}`;
+			modelQuery += " ORDER BY is_block, created_at";
+			const models = yield* sql.unsafe(modelQuery, params);
+			const allFields = yield* sql.unsafe("SELECT * FROM fields ORDER BY model_id, position");
+			const locales = yield* sql.unsafe("SELECT * FROM locales ORDER BY position");
+			const fieldsByModel = /* @__PURE__ */ new Map();
+			for (const f of allFields) {
+				const list = fieldsByModel.get(f.model_id) ?? [];
+				list.push(f);
+				fieldsByModel.set(f.model_id, list);
+			}
+			return {
+				locales: locales.map((l) => ({
+					code: l.code,
+					position: l.position,
+					fallbackLocaleId: l.fallback_locale_id
+				})),
+				models: models.map((m) => {
+					const mFields = fieldsByModel.get(m.id) ?? [];
+					return {
+						id: m.id,
+						name: m.name,
+						apiKey: m.api_key,
+						isBlock: !!m.is_block,
+						singleton: !!m.singleton,
+						sortable: !!m.sortable,
+						tree: !!m.tree,
+						allLocalesRequired: !!m.all_locales_required,
+						...includeFieldDetails ? { fields: mFields.map((f) => ({
+							id: f.id,
+							label: f.label,
+							apiKey: f.api_key,
+							type: f.field_type,
+							localized: !!f.localized,
+							validators: parseValidators(f.validators),
+							hint: f.hint
+						})) } : {
+							fieldCount: mFields.length,
+							fieldNames: mFields.map((f) => f.api_key)
+						}
+					};
+				})
+			};
+		})),
+		create_model: withDecoded(CreateModelInput, createModel),
+		update_model: withDecoded(UpdateModelInput, ({ modelId, ...rest }) => updateModel(modelId, rest)),
+		create_field: withDecoded(Schema.Struct({
+			modelId: Schema.String,
+			...CreateFieldInput.fields
+		}), ({ modelId, ...rest }) => createField(modelId, rest)),
+		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)),
+		update_record: withDecoded(UpdateRecordInput, ({ recordId, modelApiKey, data }) => {
+			if (recordId) return patchRecord(recordId, {
+				modelApiKey,
+				data
+			}, options?.actor);
+			return updateSingletonRecord(modelApiKey, data, options?.actor);
+		}),
+		patch_blocks: withDecoded(PatchBlocksInput, (input) => patchBlocksForField(input, options?.actor)),
+		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)),
+		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)),
+		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);
+			return scheduleUnpublish(modelApiKey, recordId, at ?? null, options?.actor);
+		}),
+		record_versions: withDecoded(RecordVersionsInput, ({ action, modelApiKey, recordId, versionId }) => {
+			if (action === "list") return listVersions(modelApiKey, recordId);
+			if (action === "get") {
+				if (!versionId) return Effect.fail({
+					_tag: "ValidationError",
+					message: "versionId is required for get action"
+				});
+				return getVersion(versionId);
+			}
+			if (!versionId) return Effect.fail({
+				_tag: "ValidationError",
+				message: "versionId is required for restore action"
+			});
+			return restoreVersion(modelApiKey, recordId, versionId, options?.actor);
+		}),
+		reorder_records: withDecoded(ReorderInput, ({ modelApiKey, recordIds }) => reorderRecords(modelApiKey, recordIds, options?.actor)),
+		remove_block: withDecoded(RemoveBlockInput, ({ blockApiKey, fieldId }) => {
+			if (fieldId) return removeBlockFromWhitelist({
+				fieldId,
+				blockApiKey
+			});
+			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) => {
+			const url = assetUrl(a.r2_key);
+			return url ? {
+				...a,
+				url
+			} : a;
+		}))),
+		replace_asset: withDecoded(ReplaceAssetInput, ({ assetId, ...rest }) => replaceAsset(assetId, rest, options?.actor).pipe(Effect.map(withAssetUrl))),
+		schema_io: withDecoded(SchemaIOInput, ({ action, schema }) => {
+			if (action === "export") return exportSchema();
+			if (!schema) return Effect.fail({
+				_tag: "ValidationError",
+				message: "schema is required for import action"
+			});
+			return importSchema(schema);
+		}),
+		search_content: withDecoded(SearchInput, search),
+		reindex_search: withDecoded(ReindexSearchInput, ({ modelApiKey }) => reindexAll(modelApiKey)),
+		get_site_settings: () => getSiteSettings(),
+		update_site_settings: withDecoded(UpdateSiteSettingsInput, updateSiteSettings),
+		editor_tokens: withDecoded(EditorTokensInput, ({ action, name, expiresIn, tokenId }) => {
+			if (action === "list") return listEditorTokens();
+			if (action === "create") {
+				if (!name) return Effect.fail({
+					_tag: "ValidationError",
+					message: "name is required for create action"
+				});
+				return createEditorToken({
+					name,
+					expiresIn
+				});
+			}
+			if (!tokenId) return Effect.fail({
+				_tag: "ValidationError",
+				message: "tokenId is required for revoke action"
+			});
+			return revokeEditorToken(tokenId);
+		})
+	};
+	const toolkitHandlers = toolkitAny.toLayer(pickToolkitHandlers(toolkitAny, toolHandlers));
+	const toolkitRegistration = Layer.effectDiscard(Effect.gen(function* () {
+		const registry = yield* McpServer.McpServer;
+		const built = yield* toolkitAny;
+		const context = yield* Effect.context();
+		for (const tool of Object.values(built.tools)) {
+			const mcpTool = new McpSchema.Tool({
+				name: tool.name,
+				description: tool.description,
+				inputSchema: toMcpInputSchema(tool),
+				annotations: new McpSchema.ToolAnnotations({
+					...Context.getOption(tool.annotations, AiTool.Title).pipe(Option.map((title) => ({ title })), Option.getOrUndefined),
+					readOnlyHint: Context.get(tool.annotations, AiTool.Readonly),
+					destructiveHint: Context.get(tool.annotations, AiTool.Destructive),
+					idempotentHint: Context.get(tool.annotations, AiTool.Idempotent),
+					openWorldHint: Context.get(tool.annotations, AiTool.OpenWorld)
+				})
+			});
+			yield* registry.addTool({
+				tool: mcpTool,
+				handle(payload) {
+					const params = isToolPayload(payload) ? payload : {};
+					return built.handle(tool.name, params).pipe(Effect.provide(context), Effect.match({
+						onFailure: (error) => new McpSchema.CallToolResult({
+							isError: true,
+							structuredContent: toStructuredContent(error),
+							content: [{
+								type: "text",
+								text: encodeJson(error)
+							}]
+						}),
+						onSuccess: (result) => new McpSchema.CallToolResult({
+							isError: false,
+							structuredContent: toStructuredContent(result.encodedResult),
+							content: [{
+								type: "text",
+								text: encodeJson(result.encodedResult)
+							}]
+						})
+					}));
+				}
+			});
+		}
+	})).pipe(Layer.provide(toolkitHandlers));
+	const registeredContent = Layer.mergeAll(toolkitRegistration, createGuideResource(), createSchemaResource(), createSetupContentModelPrompt(), createGenerateGraphqlQueriesPrompt()).pipe(Layer.provide(serverLayer));
+	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 };
+
+//# sourceMappingURL=http-transport-DbFCI6Cs.mjs.map