@nextblock-cms/cortex 0.14.4 → 0.14.6

package/lib/mcp-tool-registry.d.ts

@@ -0,0 +1,234 @@
+import { createCortexGlobalAgentTools } from './ai-global-agent-tools';
+import { CortexAiMcpScope } from './mcp-tokens';
+/**
+ * Adapts the existing Cortex AI tool registry to the Model Context Protocol.
+ *
+ * This file deliberately owns NO business logic. Every tool exposed over MCP is the
+ * same executor the in-app global agent calls, reached through
+ * `createCortexGlobalAgentTools(context)` — so an external client (Claude Code,
+ * Cursor, …) and the dashboard chat cannot drift apart in validation, revision
+ * recording, or side effects. What this layer adds is only what MCP needs and the
+ * AI SDK path does not:
+ *
+ *   1. JSON Schema. MCP `tools/list` transmits raw JSON Schema; the registry stores Zod.
+ *   2. Scopes. A read-only token must not even *see* the mutating tools.
+ *   3. Aliases. The MCP contract names five tools that already exist here under
+ *      different names (see CORTEX_MCP_TOOL_ALIASES).
+ *   4. MCP result envelopes (`content` / `isError` / `structuredContent`).
+ */
+export type CortexMcpToolContext = Parameters<typeof createCortexGlobalAgentTools>[0];
+/**
+ * Read/write classification for every tool in the registry.
+ *
+ * Exhaustive by construction: `assertCortexMcpToolCoverage` (and a unit test) compares
+ * these keys against the live factory output, so adding a tool to the agent without
+ * classifying it here is a loud failure rather than a silent security hole. New tools
+ * are NOT defaulted to 'read' — an unclassified mutating tool handed to a read-only
+ * token is exactly the bug this table exists to prevent.
+ */
+export declare const CORTEX_MCP_TOOL_KINDS: {
+    readonly create_cms_page: "write";
+    readonly create_cms_post: "write";
+    readonly create_cms_product: "write";
+    readonly create_custom_block: "write";
+    readonly delete_cms_item: "write";
+    readonly delete_custom_block: "write";
+    readonly describe_database_schema: "read";
+    readonly execute_cms_action_plan: "write";
+    readonly execute_database_action_plan: "write";
+    readonly execute_database_mutation: "write";
+    readonly fetch_ecommerce_stats: "read";
+    readonly fetch_url_content: "read";
+    readonly insert_content_block: "write";
+    readonly list_custom_blocks: "read";
+    readonly prepare_delete_cms_item: "read";
+    readonly read_current_cms_item: "read";
+    readonly read_database_records: "read";
+    readonly rewrite_page_draft: "write";
+    readonly search_documentation: "read";
+    readonly search_stock_photos: "read";
+    readonly set_content_images: "write";
+    readonly translate_page: "write";
+    readonly update_cms_item_field: "write";
+    readonly update_content_block: "write";
+    readonly update_current_cms_fields: "write";
+    readonly update_custom_block: "write";
+    readonly update_footer: "write";
+    readonly update_navigation_bar: "write";
+    readonly update_section_column_block: "write";
+};
+export type CortexMcpCanonicalToolName = keyof typeof CORTEX_MCP_TOOL_KINDS;
+/**
+ * MCP-contract tool names that map onto existing executors.
+ *
+ * These are the names the MCP integration promises to external clients. Rather than
+ * fork five 7000-line-file executors to rename them, each alias forwards to the
+ * canonical tool. The alias is what an external model sees first; the canonical name
+ * stays listed too, so nothing is hidden from a client that already knows the
+ * in-app vocabulary.
+ */
+export declare const CORTEX_MCP_TOOL_ALIASES: {
+    readonly generate_jsonb_layout: {
+        readonly canonical: "rewrite_page_draft";
+        readonly description: "Generate a complete, strictly-validated JSONB block layout and write it into a target page or post. Blocks are normalized and validated against the NextBlock block schema, then staged as a Live Draft on the target record — nothing goes live until an editor publishes the draft, and publishing snapshots a revision so the change is reversible. Use for whole-page builds and redesigns. Alias of `rewrite_page_draft`.";
+        readonly title: "Generate JSONB layout";
+    };
+    readonly get_database_schema: {
+        readonly canonical: "describe_database_schema";
+        readonly description: "Return the current CMS database structure: every table Cortex AI may read or mutate, its columns, primary keys, and whether it is read-only. Pair with `list_custom_blocks` for the active data-defined block definitions and with the `cortex://schema/blocks` resource for the built-in block types. Read-only. Alias of `describe_database_schema`.";
+        readonly title: "Get database schema";
+    };
+    readonly query_site_analytics: {
+        readonly canonical: "fetch_ecommerce_stats";
+        readonly description: "Query quantitative site analytics: revenue, order counts, order-status breakdowns, and top-selling products over a time range. Read-only. For inventory levels and post/page metrics that this report does not cover, use `read_database_records` against the `products`, `product_variants`, `posts`, or `pages` tables. Alias of `fetch_ecommerce_stats`.";
+        readonly title: "Query site analytics";
+    };
+    readonly search_stock_media: {
+        readonly canonical: "search_stock_photos";
+        readonly description: "Search free stock media (Pexels, then Unsplash) for contextually relevant imagery, returning direct image URLs with dimensions, alt text, and photographer attribution. Drop a returned `url` straight into an image block's `external_url` or a section background. Read-only and zero cost. Requires a stock provider key in CMS Settings → Cortex AI. Alias of `search_stock_photos`.";
+        readonly title: "Search stock media";
+    };
+    readonly update_site_navigation: {
+        readonly canonical: "update_navigation_bar";
+        readonly description: "Alter the public site navigation: header menu items and their nested child hierarchy, per locale. Use mode \"append\" to add links while preserving the existing menu, \"update\" to rename or re-point one link, and \"replace\" only when rebuilding the whole menu. For footer links and copyright use `update_footer`. Alias of `update_navigation_bar`.";
+        readonly title: "Update site navigation";
+    };
+};
+export type CortexMcpAliasToolName = keyof typeof CORTEX_MCP_TOOL_ALIASES;
+export type CortexMcpToolName = CortexMcpAliasToolName | CortexMcpCanonicalToolName;
+/** Resolve an alias to the executor that actually runs, or pass a canonical name through. */
+export declare function resolveCortexMcpToolName(name: string): CortexMcpCanonicalToolName | null;
+export declare function getCortexMcpToolKind(name: string): CortexAiMcpScope | null;
+/** A token holding `write` implicitly holds `read`; there is no write-without-read tool. */
+export declare function cortexMcpScopesAllow(scopes: readonly CortexAiMcpScope[], name: string): boolean;
+export type CortexMcpToolDefinition = {
+    description: string;
+    inputSchema: Record<string, unknown>;
+    name: string;
+    title: string;
+};
+/**
+ * Guard against the registry and the scope table drifting apart.
+ *
+ * Returns the tools present in one but not the other. Called by the route on every
+ * `tools/list` (cheap — it is a key comparison) so an unclassified tool is dropped
+ * from the listing rather than being exposed with an unknown risk profile.
+ */
+export declare function assertCortexMcpToolCoverage(context?: CortexMcpToolContext): {
+    missingFromRegistry: string[];
+    unclassified: string[];
+};
+/** Build the `tools/list` payload, filtered to what the caller's scopes permit. */
+export declare function buildCortexMcpToolDefinitions(params: {
+    context?: CortexMcpToolContext;
+    scopes: readonly CortexAiMcpScope[];
+}): CortexMcpToolDefinition[];
+export type CortexMcpToolCallResult = {
+    content: Array<{
+        text: string;
+        type: 'text';
+    }>;
+    isError: boolean;
+    structuredContent?: Record<string, unknown>;
+};
+export declare class CortexMcpUnknownToolError extends Error {
+    constructor(name: string);
+}
+export declare class CortexMcpForbiddenToolError extends Error {
+    constructor(name: string);
+}
+/**
+ * Execute one MCP `tools/call`.
+ *
+ * Throws only for *protocol* faults (unknown tool, forbidden scope), which the caller
+ * turns into JSON-RPC error objects. Everything else — validation failures, executor
+ * exceptions — comes back as a successful result carrying `isError: true`, because
+ * that is the encoding MCP defines for tool execution errors and the only one a model
+ * can read and self-correct from.
+ */
+export declare function callCortexMcpTool(params: {
+    args: unknown;
+    context?: CortexMcpToolContext;
+    name: string;
+    scopes: readonly CortexAiMcpScope[];
+}): Promise<CortexMcpToolCallResult>;
+export declare const CORTEX_MCP_RESOURCES: readonly [{
+    readonly description: "The CMS database structure Cortex AI can read and mutate: tables, columns, primary keys, and read-only flags.";
+    readonly mimeType: "application/json";
+    readonly name: "database-schema";
+    readonly title: "NextBlock database schema";
+    readonly uri: "cortex://schema/database";
+}, {
+    readonly description: "The built-in NextBlock block types available when composing page, post, and product layouts.";
+    readonly mimeType: "application/json";
+    readonly name: "block-types";
+    readonly title: "NextBlock block types";
+    readonly uri: "cortex://schema/blocks";
+}, {
+    readonly description: "Data-defined custom block definitions registered in this workspace, keyed by the slug used as a block instance `block_type`.";
+    readonly mimeType: "application/json";
+    readonly name: "custom-blocks";
+    readonly title: "NextBlock custom block definitions";
+    readonly uri: "cortex://schema/custom-blocks";
+}];
+export declare function readCortexMcpResource(params: {
+    context?: CortexMcpToolContext;
+    uri: string;
+}): Promise<{
+    mimeType: string;
+    text: string;
+    uri: string;
+} | null>;
+export declare const CORTEX_MCP_PROMPTS: readonly [{
+    readonly arguments: readonly [{
+        readonly description: "What the page is for, and any brand or tone notes.";
+        readonly name: "brief";
+        readonly required: true;
+    }, {
+        readonly description: "Slug of the page or post to rewrite, e.g. \"home\".";
+        readonly name: "slug";
+        readonly required: true;
+    }];
+    readonly description: "Build or redesign a NextBlock page from a brief, following the section-based layout recipe, and stage it as a reviewable Live Draft.";
+    readonly name: "build-page";
+    readonly title: "Build a NextBlock page";
+}, {
+    readonly arguments: readonly [{
+        readonly description: "Source URL to draw structure and copy from.";
+        readonly name: "url";
+        readonly required: true;
+    }, {
+        readonly description: "Slug of the page to write the result into.";
+        readonly name: "slug";
+        readonly required: true;
+    }];
+    readonly description: "Read an external page and rebuild an equivalent NextBlock page from it, reusing its imagery where available.";
+    readonly name: "clone-from-url";
+    readonly title: "Rebuild a page from a URL";
+}, {
+    readonly arguments: readonly [{
+        readonly description: "Target language code, e.g. \"fr\".";
+        readonly name: "languageCode";
+        readonly required: true;
+    }, {
+        readonly description: "Slug of the page or post to translate.";
+        readonly name: "slug";
+        readonly required: true;
+    }];
+    readonly description: "Translate an existing page or post into another language, preserving its layout and imagery.";
+    readonly name: "translate-content";
+    readonly title: "Translate a page or post";
+}];
+export declare function getCortexMcpPrompt(params: {
+    args?: Record<string, string>;
+    name: string;
+}): {
+    description: string;
+    messages: Array<{
+        content: {
+            text: string;
+            type: 'text';
+        };
+        role: 'user';
+    }>;
+} | null;

package/lib/mcp-tool-registry.es.js

@@ -0,0 +1,300 @@
+import { availableCortexAiBlockTypes as b, createCortexGlobalAgentTools as y } from "./ai-global-agent-tools.es.js";
+import "./zod-config.es.js";
+import { z as k } from "zod";
+const i = {
+  create_cms_page: "write",
+  create_cms_post: "write",
+  create_cms_product: "write",
+  create_custom_block: "write",
+  delete_cms_item: "write",
+  delete_custom_block: "write",
+  describe_database_schema: "read",
+  execute_cms_action_plan: "write",
+  execute_database_action_plan: "write",
+  execute_database_mutation: "write",
+  fetch_ecommerce_stats: "read",
+  fetch_url_content: "read",
+  insert_content_block: "write",
+  list_custom_blocks: "read",
+  prepare_delete_cms_item: "read",
+  read_current_cms_item: "read",
+  read_database_records: "read",
+  rewrite_page_draft: "write",
+  search_documentation: "read",
+  search_stock_photos: "read",
+  set_content_images: "write",
+  translate_page: "write",
+  update_cms_item_field: "write",
+  update_content_block: "write",
+  update_current_cms_fields: "write",
+  update_custom_block: "write",
+  update_footer: "write",
+  update_navigation_bar: "write",
+  update_section_column_block: "write"
+}, u = {
+  generate_jsonb_layout: {
+    canonical: "rewrite_page_draft",
+    description: "Generate a complete, strictly-validated JSONB block layout and write it into a target page or post. Blocks are normalized and validated against the NextBlock block schema, then staged as a Live Draft on the target record — nothing goes live until an editor publishes the draft, and publishing snapshots a revision so the change is reversible. Use for whole-page builds and redesigns. Alias of `rewrite_page_draft`.",
+    title: "Generate JSONB layout"
+  },
+  get_database_schema: {
+    canonical: "describe_database_schema",
+    description: "Return the current CMS database structure: every table Cortex AI may read or mutate, its columns, primary keys, and whether it is read-only. Pair with `list_custom_blocks` for the active data-defined block definitions and with the `cortex://schema/blocks` resource for the built-in block types. Read-only. Alias of `describe_database_schema`.",
+    title: "Get database schema"
+  },
+  query_site_analytics: {
+    canonical: "fetch_ecommerce_stats",
+    description: "Query quantitative site analytics: revenue, order counts, order-status breakdowns, and top-selling products over a time range. Read-only. For inventory levels and post/page metrics that this report does not cover, use `read_database_records` against the `products`, `product_variants`, `posts`, or `pages` tables. Alias of `fetch_ecommerce_stats`.",
+    title: "Query site analytics"
+  },
+  search_stock_media: {
+    canonical: "search_stock_photos",
+    description: "Search free stock media (Pexels, then Unsplash) for contextually relevant imagery, returning direct image URLs with dimensions, alt text, and photographer attribution. Drop a returned `url` straight into an image block's `external_url` or a section background. Read-only and zero cost. Requires a stock provider key in CMS Settings → Cortex AI. Alias of `search_stock_photos`.",
+    title: "Search stock media"
+  },
+  update_site_navigation: {
+    canonical: "update_navigation_bar",
+    description: 'Alter the public site navigation: header menu items and their nested child hierarchy, per locale. Use mode "append" to add links while preserving the existing menu, "update" to rename or re-point one link, and "replace" only when rebuilding the whole menu. For footer links and copyright use `update_footer`. Alias of `update_navigation_bar`.',
+    title: "Update site navigation"
+  }
+};
+function _(e) {
+  return e in u ? u[e].canonical : e in i ? e : null;
+}
+function x(e) {
+  const t = _(e);
+  return t ? i[t] : null;
+}
+function d(e, t) {
+  const o = x(t);
+  return o ? o === "read" ? e.length > 0 : e.includes("write") : !1;
+}
+function p(e) {
+  return e.split("_").map((o, r) => r === 0 ? o.charAt(0).toUpperCase() + o.slice(1) : o).join(" ");
+}
+function m(e) {
+  const t = { additionalProperties: !1, type: "object" };
+  if (!e || typeof e != "object")
+    return t;
+  try {
+    const o = k.toJSONSchema(e, {
+      cycles: "ref",
+      io: "input",
+      reused: "inline",
+      target: "draft-2020-12",
+      unrepresentable: "any"
+    });
+    return delete o.$schema, o.type === "object" ? o : t;
+  } catch {
+    return t;
+  }
+}
+function s(e) {
+  return y(e);
+}
+function j(e) {
+  const t = Object.keys(s(e)), o = Object.keys(i);
+  return {
+    missingFromRegistry: o.filter((r) => !t.includes(r)),
+    unclassified: t.filter((r) => !o.includes(r))
+  };
+}
+function O(e) {
+  const t = s(e.context), o = [];
+  for (const [r, a] of Object.entries(t))
+    !(r in i) || !d(e.scopes, r) || o.push({
+      description: a.description ?? `Cortex AI ${p(r)} tool.`,
+      inputSchema: m(a.inputSchema),
+      name: r,
+      title: p(r)
+    });
+  for (const [r, a] of Object.entries(u)) {
+    const n = t[a.canonical];
+    !n || !d(e.scopes, r) || o.push({
+      description: a.description,
+      inputSchema: m(n.inputSchema),
+      name: r,
+      title: a.title
+    });
+  }
+  return o.sort((r, a) => r.name.localeCompare(a.name));
+}
+function g(e, t) {
+  return { content: [{ text: e, type: "text" }], isError: t };
+}
+function w(e) {
+  return e.issues.map((t) => `${t.path.length > 0 ? t.path.join(".") : "(root)"}: ${t.message}`).join("; ");
+}
+class h extends Error {
+  constructor(t) {
+    super(`Unknown tool: ${t}`), this.name = "CortexMcpUnknownToolError";
+  }
+}
+class v extends Error {
+  constructor(t) {
+    super(
+      `Tool "${t}" requires the "write" scope. This MCP token is read-only — mint a read+write token in CMS Settings → Cortex AI.`
+    ), this.name = "CortexMcpForbiddenToolError";
+  }
+}
+async function N(e) {
+  const t = _(e.name);
+  if (!t)
+    throw new h(e.name);
+  if (!d(e.scopes, e.name))
+    throw new v(e.name);
+  const r = s(e.context)[t];
+  if (!r || typeof r.execute != "function")
+    throw new h(e.name);
+  const a = e.args && typeof e.args == "object" ? e.args : {};
+  if (r.inputSchema && typeof r.inputSchema.safeParse == "function") {
+    const n = r.inputSchema.safeParse(a);
+    if (!n.success)
+      return g(
+        `Invalid arguments for "${e.name}": ${w(n.error)}`,
+        !0
+      );
+  }
+  try {
+    const n = await r.execute(a), c = JSON.stringify(n ?? { success: !0 }, null, 2), l = n && typeof n == "object" && !Array.isArray(n) ? n : null, f = l?.success === !1;
+    return {
+      content: [{ text: c, type: "text" }],
+      isError: f,
+      ...l ? { structuredContent: l } : {}
+    };
+  } catch (n) {
+    const c = n instanceof Error ? n.message : String(n);
+    return g(`Tool "${e.name}" failed: ${c}`, !0);
+  }
+}
+const A = [
+  {
+    description: "The CMS database structure Cortex AI can read and mutate: tables, columns, primary keys, and read-only flags.",
+    mimeType: "application/json",
+    name: "database-schema",
+    title: "NextBlock database schema",
+    uri: "cortex://schema/database"
+  },
+  {
+    description: "The built-in NextBlock block types available when composing page, post, and product layouts.",
+    mimeType: "application/json",
+    name: "block-types",
+    title: "NextBlock block types",
+    uri: "cortex://schema/blocks"
+  },
+  {
+    description: "Data-defined custom block definitions registered in this workspace, keyed by the slug used as a block instance `block_type`.",
+    mimeType: "application/json",
+    name: "custom-blocks",
+    title: "NextBlock custom block definitions",
+    uri: "cortex://schema/custom-blocks"
+  }
+];
+async function B(e) {
+  const t = s(e.context);
+  if (e.uri === "cortex://schema/database") {
+    const o = await t.describe_database_schema?.execute?.({ includeReadOnly: !0 });
+    return {
+      mimeType: "application/json",
+      text: JSON.stringify(o ?? {}, null, 2),
+      uri: e.uri
+    };
+  }
+  if (e.uri === "cortex://schema/blocks")
+    return {
+      mimeType: "application/json",
+      text: JSON.stringify({ blockTypes: b }, null, 2),
+      uri: e.uri
+    };
+  if (e.uri === "cortex://schema/custom-blocks") {
+    const o = await t.list_custom_blocks?.execute?.({});
+    return {
+      mimeType: "application/json",
+      text: JSON.stringify(o ?? {}, null, 2),
+      uri: e.uri
+    };
+  }
+  return null;
+}
+const C = [
+  {
+    arguments: [
+      { description: "What the page is for, and any brand or tone notes.", name: "brief", required: !0 },
+      { description: 'Slug of the page or post to rewrite, e.g. "home".', name: "slug", required: !0 }
+    ],
+    description: "Build or redesign a NextBlock page from a brief, following the section-based layout recipe, and stage it as a reviewable Live Draft.",
+    name: "build-page",
+    title: "Build a NextBlock page"
+  },
+  {
+    arguments: [
+      { description: "Source URL to draw structure and copy from.", name: "url", required: !0 },
+      { description: "Slug of the page to write the result into.", name: "slug", required: !0 }
+    ],
+    description: "Read an external page and rebuild an equivalent NextBlock page from it, reusing its imagery where available.",
+    name: "clone-from-url",
+    title: "Rebuild a page from a URL"
+  },
+  {
+    arguments: [
+      { description: 'Target language code, e.g. "fr".', name: "languageCode", required: !0 },
+      { description: "Slug of the page or post to translate.", name: "slug", required: !0 }
+    ],
+    description: "Translate an existing page or post into another language, preserving its layout and imagery.",
+    name: "translate-content",
+    title: "Translate a page or post"
+  }
+], S = {
+  "build-page": (e) => [
+    `Build the NextBlock page with slug "${e.slug ?? "<slug>"}" from this brief:`,
+    "",
+    e.brief ?? "<brief>",
+    "",
+    "Process:",
+    "1. Call get_database_schema and read_current_cms_item (or read_database_records on `pages`) to ground yourself in what exists.",
+    '2. Compose the page from `section` blocks: one column entry per grid track, the first section a hero, alternating none / theme:"muted" / theme:"primary" backgrounds for rhythm. Use discrete heading blocks rather than <h2> inside text HTML.',
+    "3. Call search_stock_media for real photography; copy each photo's attribution fields onto the image block.",
+    "4. Write the result with generate_jsonb_layout. It stages a Live Draft — tell the user to preview and publish it."
+  ].join(`
+`),
+  "clone-from-url": (e) => [
+    `Rebuild the NextBlock page "${e.slug ?? "<slug>"}" based on ${e.url ?? "<url>"}.`,
+    "",
+    "Process:",
+    "1. Call fetch_url_content on the URL first. Use its headings, text, and mainImage — never invent an image URL.",
+    "2. Map the source structure onto NextBlock `section` blocks; do not copy its markup verbatim.",
+    "3. Write the result with generate_jsonb_layout so it lands as a reviewable Live Draft."
+  ].join(`
+`),
+  "translate-content": (e) => [
+    `Translate the page or post "${e.slug ?? "<slug>"}" into "${e.languageCode ?? "<languageCode>"}".`,
+    "",
+    "Use the translate_page tool: it copies layout, structure, and imagery automatically and links the copy to the original translation group. Supply only the text translations — every visible string, including headings, paragraph text, button labels, image alt text, and captions. Do not rebuild the layout and do not search for new imagery."
+  ].join(`
+`)
+};
+function P(e) {
+  const t = C.find((r) => r.name === e.name), o = S[e.name];
+  return !t || !o ? null : {
+    description: t.description,
+    messages: [
+      { content: { text: o(e.args ?? {}), type: "text" }, role: "user" }
+    ]
+  };
+}
+export {
+  C as CORTEX_MCP_PROMPTS,
+  A as CORTEX_MCP_RESOURCES,
+  u as CORTEX_MCP_TOOL_ALIASES,
+  i as CORTEX_MCP_TOOL_KINDS,
+  v as CortexMcpForbiddenToolError,
+  h as CortexMcpUnknownToolError,
+  j as assertCortexMcpToolCoverage,
+  O as buildCortexMcpToolDefinitions,
+  N as callCortexMcpTool,
+  d as cortexMcpScopesAllow,
+  P as getCortexMcpPrompt,
+  x as getCortexMcpToolKind,
+  B as readCortexMcpResource,
+  _ as resolveCortexMcpToolName
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextblock-cms/cortex",
-  "version": "0.14.4",
+  "version": "0.14.6",
   "publishConfig": {
     "access": "public"
   },
@@ -27,9 +27,9 @@
   },
   "dependencies": {
     "@ai-sdk/openai-compatible": "^2.0.42",
-    "@nextblock-cms/db": "^0.14.4",
-    "@nextblock-cms/ecommerce": "npm:@nextblock-cms/ecom@^0.14.4",
-    "@nextblock-cms/utils": "^0.14.4",
+    "@nextblock-cms/db": "^0.14.6",
+    "@nextblock-cms/ecommerce": "npm:@nextblock-cms/ecom@^0.14.6",
+    "@nextblock-cms/utils": "^0.14.6",
     "ai": "^6.0.170",
     "zod": "^4.3.6"
   },