@sage-protocol/cli 0.2.9 → 0.3.2

package/dist/cli/services/mcp/quick-start.js

@@ -0,0 +1,287 @@
+const path = require('path');
+const fs = require('fs');
+const { LibraryManager } = require('../../library-manager');
+
+function createQuickStart({
+    libraryManager = new LibraryManager(),
+    logger = console,
+}) {
+
+    function ensureDefaultLibrary() {
+        const pinned = libraryManager.listPinned();
+        // Look for "My Library" or "default"
+        let defaultLib = pinned.find(p => p.name === 'My Library' || p.name === 'default');
+
+        if (!defaultLib) {
+            // Create "My Library"
+            const result = libraryManager.createLibrary('My Library', 'Default library for quick prompts');
+            defaultLib = { cid: result.cid, name: 'My Library' };
+        }
+        return defaultLib;
+    }
+
+    function generateKey(name) {
+        return name.toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+|-+$/g, '');
+    }
+
+    async function quickCreatePrompt({ name, content, description = '', library = '', tags } = {}) {
+        if (!name || !content) {
+            throw new Error('Name and content are required');
+        }
+
+        let targetLib;
+        if (library) {
+            const pinned = libraryManager.listPinned();
+            targetLib = pinned.find(p =>
+                p.name.toLowerCase() === library.toLowerCase() ||
+                p.cid === library
+            );
+            if (!targetLib) {
+                // If library doesn't exist, create it
+                const result = libraryManager.createLibrary(library, '');
+                targetLib = { cid: result.cid, name: library };
+            }
+        } else {
+            targetLib = ensureDefaultLibrary();
+        }
+
+        const key = generateKey(name);
+
+        // Check if key exists
+        const { manifest } = libraryManager.loadPinned(targetLib.cid);
+        if (manifest.prompts?.some(p => p.key === key)) {
+            throw new Error(`Prompt with key "${key}" already exists in library "${targetLib.name}". Use quick_iterate_prompt to update it.`);
+        }
+
+        // Add prompt
+        // We need to use the library manager's internal methods or replicate logic
+        // Since LibraryManager doesn't expose "addPrompt", we'll implement it here for now
+        // In a real refactor, we should move this to LibraryManager
+
+        const libDir = libraryManager.ensureLibrariesDir();
+        const manifestPath = path.join(libDir, `${targetLib.cid}.json`);
+
+        // Create prompt file
+        // We'll store it in a 'prompts' subdirectory next to the manifest if possible, 
+        // but for local libraries, they are flat in ~/.sage/libraries/
+        // Let's create a prompts directory inside ~/.sage/libraries/prompts/
+        const promptsDir = path.join(libDir, 'prompts');
+        if (!fs.existsSync(promptsDir)) {
+            fs.mkdirSync(promptsDir, { recursive: true });
+        }
+
+        const promptFileName = `${targetLib.cid}_${key}.md`;
+        const promptFilePath = path.join(promptsDir, promptFileName);
+        fs.writeFileSync(promptFilePath, content, 'utf8');
+
+        // Normalise tags (optional)
+        let promptTags = [];
+        if (tags !== undefined) {
+            let normalized = tags;
+            if (typeof normalized === 'string') {
+                try {
+                    const parsed = JSON.parse(normalized);
+                    if (Array.isArray(parsed)) {
+                        normalized = parsed;
+                    } else {
+                        normalized = String(normalized)
+                            .split(/[,;]/)
+                            .map((t) => t.trim())
+                            .filter(Boolean);
+                    }
+                } catch {
+                    normalized = String(normalized)
+                        .split(/[,;]/)
+                        .map((t) => t.trim())
+                        .filter(Boolean);
+                }
+            }
+            if (Array.isArray(normalized)) {
+                promptTags = normalized.map((t) => String(t));
+            }
+        }
+
+        // Update manifest
+        if (!manifest.prompts) manifest.prompts = [];
+        manifest.prompts.push({
+            key,
+            name,
+            description,
+            files: [`prompts/${promptFileName}`], // Relative path
+            tags: promptTags,
+            cid: '' // Local prompt
+        });
+
+        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+
+        return {
+            success: true,
+            key,
+            library: targetLib.name,
+            cid: targetLib.cid,
+            message: `Created prompt "${name}" (${key}) in "${targetLib.name}"`
+        };
+    }
+
+  async function quickIteratePrompt({ key, content, name, description, tags }) {
+        if (!key) throw new Error('Key is required');
+
+        // Find the prompt
+        const pinned = libraryManager.listPinned();
+        let found = null;
+        let foundLib = null;
+
+        for (const lib of pinned) {
+            const { manifest } = libraryManager.loadPinned(lib.cid);
+            const prompt = manifest.prompts?.find(p => p.key === key);
+            if (prompt) {
+                found = prompt;
+                const libDir = libraryManager.ensureLibrariesDir();
+                foundLib = { ...lib, manifest, manifestPath: path.join(libDir, `${lib.cid}.json`) };
+                break;
+            }
+        }
+
+        if (!found) {
+            throw new Error(`Prompt with key "${key}" not found. Use quick_create_prompt to create it.`);
+        }
+
+        // Update content if provided
+        if (content) {
+            const libDir = libraryManager.ensureLibrariesDir();
+            let promptFilePath;
+
+            if (found.files && found.files.length > 0) {
+                // Use existing file
+                const relativePath = found.files[0];
+                // Handle potential path issues
+                promptFilePath = path.join(libDir, relativePath);
+
+                // Backup existing
+                if (fs.existsSync(promptFilePath)) {
+                    const backupPath = `${promptFilePath}.v${Date.now()}.bak`;
+                    fs.copyFileSync(promptFilePath, backupPath);
+                }
+            } else {
+                // Create new file if none existed (legacy/imported)
+                const promptsDir = path.join(libDir, 'prompts');
+                if (!fs.existsSync(promptsDir)) fs.mkdirSync(promptsDir, { recursive: true });
+                const promptFileName = `${foundLib.cid}_${key}.md`;
+                promptFilePath = path.join(promptsDir, promptFileName);
+                found.files = [`prompts/${promptFileName}`];
+            }
+
+            fs.writeFileSync(promptFilePath, content, 'utf8');
+        }
+
+        // Update metadata
+        if (name) {
+            found.name = name;
+        }
+        if (typeof description === 'string') {
+            found.description = description;
+        }
+        if (tags !== undefined) {
+            let normalized = tags;
+            if (typeof normalized === 'string') {
+                // Accept JSON array string or comma/space separated list
+                try {
+                    const parsed = JSON.parse(normalized);
+                    if (Array.isArray(parsed)) {
+                        normalized = parsed;
+                    } else {
+                        normalized = String(normalized)
+                          .split(/[,;]/)
+                          .map((t) => t.trim())
+                          .filter(Boolean);
+                    }
+                } catch {
+                    normalized = String(normalized)
+                      .split(/[,;]/)
+                      .map((t) => t.trim())
+                      .filter(Boolean);
+                }
+            }
+            if (Array.isArray(normalized)) {
+                found.tags = normalized.map((t) => String(t));
+            }
+        }
+
+        // Save manifest
+        fs.writeFileSync(foundLib.manifestPath, JSON.stringify(foundLib.manifest, null, 2), 'utf8');
+
+        return {
+            success: true,
+            key,
+            library: foundLib.name,
+            message: `Updated prompt "${key}" (name: ${found.name || name || key})`
+        };
+    }
+
+    async function renamePrompt({ key, newKey, name }) {
+        if (!key) throw new Error('Key is required');
+        if (!newKey && !name) throw new Error('newKey or name required');
+
+        const pinned = libraryManager.listPinned();
+        let found = null;
+        let foundLib = null;
+
+        for (const lib of pinned) {
+            const { manifest } = libraryManager.loadPinned(lib.cid);
+            const prompt = manifest.prompts?.find((p) => p.key === key);
+            if (prompt) {
+                const libDir = libraryManager.ensureLibrariesDir();
+                found = prompt;
+                foundLib = {
+                    ...lib,
+                    manifest,
+                    manifestPath: path.join(libDir, `${lib.cid}.json`),
+                };
+                break;
+            }
+        }
+
+        if (!found || !foundLib) {
+            throw new Error(`Prompt with key "${key}" not found. Use list_prompts or search_prompts to discover keys.`);
+        }
+
+        // Handle key change with collision check
+        let finalKey = key;
+        if (newKey && newKey !== key) {
+            const exists = (foundLib.manifest.prompts || []).some(
+                (p) => p !== found && p.key === newKey,
+            );
+            if (exists) {
+                throw new Error(
+                    `Prompt with key "${newKey}" already exists in library "${foundLib.name}". Choose a different key.`,
+                );
+            }
+            found.key = newKey;
+            finalKey = newKey;
+        }
+
+        if (name) {
+            found.name = name;
+        }
+
+        fs.writeFileSync(foundLib.manifestPath, JSON.stringify(foundLib.manifest, null, 2));
+
+        return {
+            success: true,
+            oldKey: key,
+            key: finalKey,
+            library: foundLib.name,
+            message: `Renamed prompt "${key}" to "${finalKey}" (display name: ${found.name || finalKey})`,
+        };
+    }
+
+    return {
+        quickCreatePrompt,
+        quickIteratePrompt,
+        renamePrompt,
+    };
+}
+
+module.exports = { createQuickStart };

package/dist/cli/services/mcp/stdio-runner.js

@@ -35,12 +35,37 @@ function createStdIoRunner(baseOptions = {}) {
       terminal: false,
     });
 
+    let outputClosed = false;
+    if (output && typeof output.on === 'function') {
+      output.on('error', (err) => {
+        if (err && err.code === 'EPIPE') {
+          // Client closed the pipe; mark closed and let the process exit cleanly.
+          outputClosed = true;
+          try { rl.close(); } catch (_) {}
+        } else if (debugEnabled) {
+          errorWriter(`stdout error: ${err.message || String(err)}`);
+        }
+      });
+    }
+
     const writeJson = (payload) => {
-      const text = typeof payload === 'string' ? payload : JSON.stringify(payload);
-      if (typeof output?.write === 'function') {
-        output.write(`${text}\n`);
-      } else {
-        console.log(text); // eslint-disable-line no-console
+      if (outputClosed) return;
+      try {
+        const text = typeof payload === 'string' ? payload : JSON.stringify(payload);
+        if (typeof output?.write === 'function') {
+          output.write(`${text}\n`);
+        } else {
+          console.log(text); // eslint-disable-line no-console
+        }
+      } catch (err) {
+        if (err && err.code === 'EPIPE') {
+          outputClosed = true;
+          try { rl.close(); } catch (_) {}
+          return;
+        }
+        if (debugEnabled) {
+          errorWriter(`writeJson error: ${err.message || String(err)}`);
+        }
       }
     };
 

package/dist/cli/services/mcp/template-manager.js

@@ -0,0 +1,156 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Simple prompt template manager for MCP flows.
+ *
+ * Templates are defined as JSON data and rendered into concrete prompts
+ * which are persisted using quickStart.quickCreatePrompt.
+ */
+function createTemplateManager({
+  quickStart,
+  fsModule = fs,
+  pathModule = path,
+  logger = console,
+} = {}) {
+  if (!quickStart || typeof quickStart.quickCreatePrompt !== 'function') {
+    throw new Error('TemplateManager requires quickStart.quickCreatePrompt');
+  }
+
+  const defaultTemplatePath = pathModule.join(__dirname, 'templates', 'default-templates.json');
+  let templatesCache = null;
+
+  function loadTemplates() {
+    if (templatesCache) return templatesCache;
+    try {
+      const raw = fsModule.readFileSync(defaultTemplatePath, 'utf8');
+      const parsed = JSON.parse(raw);
+      const list = Array.isArray(parsed) ? parsed : parsed.templates || [];
+      templatesCache = list;
+    } catch (error) {
+      logger?.warn?.('template_manager_load_failed', { path: defaultTemplatePath, err: error.message || String(error) });
+      templatesCache = [];
+    }
+    return templatesCache;
+  }
+
+  function listTemplates({ category, search } = {}) {
+    const all = loadTemplates();
+    const cat = (category || '').toLowerCase();
+    const term = (search || '').toLowerCase();
+    const filtered = all.filter((tpl) => {
+      if (cat && String(tpl.category || '').toLowerCase() !== cat) return false;
+      if (!term) return true;
+      const haystack = [
+        tpl.key || '',
+        tpl.name || '',
+        tpl.description || '',
+        (tpl.metadata && tpl.metadata.suggested_description) || '',
+      ]
+        .join(' ')
+        .toLowerCase();
+      return haystack.includes(term);
+    });
+
+    const items = filtered.map((tpl) => {
+      const vars = Array.isArray(tpl.variables) ? tpl.variables : [];
+      return {
+        key: tpl.key,
+        name: tpl.name,
+        category: tpl.category || '',
+        summary: tpl.description || (tpl.metadata && tpl.metadata.suggested_description) || '',
+        requiredVariables: vars.filter((v) => v && v.required).map((v) => v.name),
+        optionalVariables: vars.filter((v) => v && !v.required).map((v) => v.name),
+      };
+    });
+
+    return { templates: items };
+  }
+
+  function getTemplate({ key }) {
+    const all = loadTemplates();
+    const id = String(key || '').trim();
+    if (!id) {
+      throw new Error('template key is required');
+    }
+    const tpl = all.find((t) => t.key === id);
+    if (!tpl) {
+      throw new Error(`Template not found for key "${key}"`);
+    }
+    return { template: tpl };
+  }
+
+  function renderWithVars(templateString, customize, variables) {
+    let result = String(templateString || '');
+    const vars = Array.isArray(variables) ? variables : [];
+    for (const v of vars) {
+      if (!v || !v.name) continue;
+      const value = customize && Object.prototype.hasOwnProperty.call(customize, v.name)
+        ? String(customize[v.name])
+        : (v.default !== undefined ? String(v.default) : `\${${v.name}}`);
+      const pattern = new RegExp(`\\$\\{${v.name}\\}`, 'g');
+      result = result.replace(pattern, value);
+    }
+    return result;
+  }
+
+  async function createFromTemplate({ template, customize, library, name } = {}) {
+    const { template: tpl } = getTemplate({ key: template });
+    const vars = Array.isArray(tpl.variables) ? tpl.variables : [];
+    const missing = vars
+      .filter((v) => v && v.required)
+      .filter((v) => !customize || customize[v.name] === undefined || customize[v.name] === null || customize[v.name] === '');
+
+    if (missing.length) {
+      const names = missing.map((v) => v.name).join(', ');
+      throw new Error(`Missing required variables for template "${tpl.key}": ${names}`);
+    }
+
+    const content = renderWithVars(tpl.content_template || '', customize, vars);
+
+    const promptName =
+      name ||
+      tpl.name ||
+      (customize && customize.title) ||
+      (customize && customize.project_type && `${customize.project_type} Prompt`) ||
+      tpl.key;
+
+    let description = '';
+    if (tpl.metadata && tpl.metadata.suggested_description) {
+      description = renderWithVars(tpl.metadata.suggested_description, customize, vars);
+    } else {
+      description = tpl.description || '';
+    }
+
+    const defaultTags = Array.isArray(tpl.metadata?.default_tags)
+      ? tpl.metadata.default_tags.map((t) => String(t).trim()).filter(Boolean)
+      : [];
+    const tags = defaultTags;
+
+    const quickResult = await quickStart.quickCreatePrompt({
+      name: promptName,
+      content,
+      description,
+      library,
+      tags,
+    });
+
+    return {
+      success: true,
+      template: tpl.key,
+      variables: customize || {},
+      tags,
+      quickCreate: quickResult,
+    };
+  }
+
+  return {
+    listTemplates,
+    getTemplate,
+    createFromTemplate,
+  };
+}
+
+module.exports = {
+  createTemplateManager,
+};

package/dist/cli/services/mcp/templates/default-templates.json

@@ -0,0 +1,84 @@
+[
+  {
+    "key": "landscape-design-planner",
+    "name": "Landscape Design Planner",
+    "category": "design",
+    "description": "Structured planner for landscape and courtyard design projects.",
+    "variables": [
+      { "name": "project_type", "required": true, "description": "courtyard, garden, patio, deck, etc." },
+      { "name": "region", "required": true, "description": "location or climate zone" },
+      { "name": "style", "required": false, "description": "modern, traditional, cottage, etc.", "default": "modern" },
+      { "name": "budget_range", "required": false, "description": "low, medium, high, or numeric range" }
+    ],
+    "content_template": "You are an experienced landscape designer specializing in ${project_type} projects in ${region}.\n\nYour tasks:\n1. Analyze the site conditions and constraints.\n2. Propose a high-level layout for the ${project_type}.\n3. Recommend materials, planting zones, and functional zones.\n4. Highlight tradeoffs given the budget range (${budget_range}).\n\nRespond with:\n- Site assumptions\n- Layout description\n- Material and planting recommendations\n- Risks and open questions.",
+    "metadata": {
+      "default_tags": ["design", "landscape", "courtyard"],
+      "suggested_description": "${project_type} planning prompt for projects in ${region}."
+    }
+  },
+  {
+    "key": "code-review-assistant",
+    "name": "Code Review Assistant",
+    "category": "development",
+    "description": "Prompt for structured, actionable code review feedback.",
+    "variables": [
+      { "name": "language", "required": true, "description": "primary language or stack" },
+      { "name": "context", "required": false, "description": "repository or feature context", "default": "general" },
+      { "name": "focus_areas", "required": false, "description": "performance, readability, security, etc." }
+    ],
+    "content_template": "You are a senior ${language} engineer performing a code review.\n\nContext: ${context}\nFocus areas: ${focus_areas}\n\nFor the given code, provide:\n1. High-level summary of what the code does.\n2. Strengths.\n3. Issues grouped by severity (critical, important, minor).\n4. Concrete suggestions and examples for improvement.\n5. Any follow-up questions.\n\nBe concise but specific; avoid restating the code.",
+    "metadata": {
+      "default_tags": ["code-review", "development"],
+      "suggested_description": "Structured ${language} code review assistant prompt."
+    }
+  },
+  {
+    "key": "data-analysis-brief",
+    "name": "Data Analysis Brief",
+    "category": "analysis",
+    "description": "Briefing prompt for exploratory or explanatory data analysis.",
+    "variables": [
+      { "name": "dataset_description", "required": true, "description": "what the data represents" },
+      { "name": "audience", "required": false, "description": "decision makers, technical team, etc.", "default": "mixed" },
+      { "name": "primary_question", "required": true, "description": "main question to answer" }
+    ],
+    "content_template": "You are a data analyst preparing a structured analysis plan.\n\nDataset: ${dataset_description}\nAudience: ${audience}\nPrimary question: ${primary_question}\n\nProvide:\n1. Clarifying questions you would ask before analysis.\n2. Proposed analysis steps and methods.\n3. Key metrics and visualizations you would produce.\n4. Potential risks, caveats, or biases.\n5. How you would communicate results to the audience.",
+    "metadata": {
+      "default_tags": ["analysis", "planning"],
+      "suggested_description": "Plan an analysis for ${dataset_description} focusing on ${primary_question}."
+    }
+  },
+  {
+    "key": "writing-assistant",
+    "name": "Writing Assistant",
+    "category": "writing",
+    "description": "General-purpose structured writing assistant prompt.",
+    "variables": [
+      { "name": "piece_type", "required": true, "description": "blog post, email, announcement, etc." },
+      { "name": "topic", "required": true, "description": "subject of the piece" },
+      { "name": "tone", "required": false, "description": "professional, friendly, playful, etc.", "default": "professional" }
+    ],
+    "content_template": "You are an assistant helping draft a ${piece_type} about ${topic} in a ${tone} tone.\n\nProvide:\n1. A suggested outline.\n2. A draft introduction paragraph.\n3. 2–3 key points with short supporting paragraphs.\n4. A concise conclusion or call to action.\n\nKeep the language clear and accessible.",
+    "metadata": {
+      "default_tags": ["writing", "content"],
+      "suggested_description": "${piece_type} assistant prompt for ${topic}."
+    }
+  },
+  {
+    "key": "governance-library-publish-helper",
+    "name": "Governance Library Publish Helper",
+    "category": "governance",
+    "description": "Helper prompt to plan publishing a Sage library to a SubDAO.",
+    "variables": [
+      { "name": "library_name", "required": true, "description": "name of the library being published" },
+      { "name": "subdao_name", "required": false, "description": "name of the target SubDAO" },
+      { "name": "risk_level", "required": false, "description": "low, medium, high", "default": "medium" }
+    ],
+    "content_template": "You are assisting with publishing the \"${library_name}\" library to a Sage SubDAO (${subdao_name}).\n\nFor this publication, outline:\n1. Why this library is valuable to the SubDAO.\n2. Any risks or tradeoffs (risk level: ${risk_level}).\n3. Preconditions for a safe rollout (tests, review, etc.).\n4. A short, clear proposal description for governance.\n\nRespond as a structured brief the proposer can paste into their governance proposal.",
+    "metadata": {
+      "default_tags": ["governance", "library", "publish"],
+      "suggested_description": "Governance brief helper for publishing ${library_name}."
+    }
+  }
+]
+

package/dist/cli/services/mcp/tool-args-validator.js

@@ -61,6 +61,7 @@ function createToolArgsValidator({ zodModule } = {}) {
       manifest: Z.record(Z.any()),
       subdao: Z.string().regex(/^0x[a-fA-F0-9]{40}$/).optional().or(Z.literal('')).default(''),
       description: Z.string().max(280).optional().default(''),
+      dry_run: Z.boolean().optional().default(false),
     }),
     propose_manifest: Z.object({
       cid: Z.string().min(10).max(200),
@@ -69,6 +70,61 @@ function createToolArgsValidator({ zodModule } = {}) {
       promptCount: Z.number().int().min(0).optional(),
       manifest: Z.record(Z.any()).optional(),
     }),
+    improve_prompt: Z.object({
+      key: Z.string().min(1).max(200),
+      library: Z.string().min(1).max(200).optional(),
+      pass: Z.enum(['single', 'deep']).optional().default('single'),
+      focus: Z.enum(['variables', 'edge-cases', 'output-quality', 'reusability', 'all']).optional().default('all'),
+    }),
+    rename_prompt: Z.object({
+      key: Z.string().min(1).max(200),
+      newKey: Z.string().min(1).max(200).optional(),
+      name: Z.string().min(1).max(200).optional(),
+    }),
+    update_library_metadata: Z.object({
+      library: Z.string().min(1).max(200),
+      name: Z.string().min(1).max(200).optional(),
+      description: Z.string().max(1000).optional(),
+      tags: Z.array(Z.string().max(64)).optional(),
+      apply_to_prompts: Z.boolean().optional().default(false),
+      merge_mode: Z.enum(['replace', 'merge']).optional().default('merge'),
+    }),
+    bulk_update_prompts: Z.object({
+      library: Z.string().min(1).max(200),
+      updates: Z.array(
+        Z.object({
+          key: Z.string().min(1).max(200),
+          name: Z.string().min(1).max(200).optional(),
+          description: Z.string().max(2000).optional(),
+          tags: Z.array(Z.string().max(64)).optional(),
+          content: Z.string().optional(),
+        }),
+      )
+        .min(1),
+      dry_run: Z.boolean().optional().default(false),
+    }),
+    list_templates: Z.object({
+      category: Z.string().max(200).optional(),
+      search: Z.string().max(500).optional(),
+    }),
+    get_template: Z.object({
+      key: Z.string().min(1).max(200),
+    }),
+    create_from_template: Z.object({
+      template: Z.string().min(1).max(200),
+      customize: Z.record(Z.any()),
+      library: Z.string().min(1).max(200).optional(),
+      name: Z.string().min(1).max(200).optional(),
+    }),
+    analyze_dependencies: Z.object({
+      library: Z.string().min(1).max(200),
+      analysis_type: Z.enum(['variables', 'all']).optional().default('variables'),
+    }),
+    suggest_subdaos_for_library: Z.object({
+      library: Z.string().min(1).max(200),
+      limit: Z.number().int().min(1).max(20).optional().default(5),
+      mode_filter: Z.enum(['any', 'creator', 'squad', 'community']).optional().default('any'),
+    }),
   };
 
   return function validate(name, args) {

package/dist/cli/services/mcp/trending-formatter.js

@@ -14,7 +14,7 @@ function buildTrendingResponse(suggestions = [], limit = 10) {
   return {
     content: [
       { type: 'text', text },
-      { type: 'json', text: JSON.stringify({ items }, null, 2) },
+      { type: 'text', text: '```json\n' + JSON.stringify({ items }, null, 2) + '\n```' },
     ],
   };
 }

package/dist/cli/services/mcp/unified-prompt-search.js

@@ -76,8 +76,8 @@ function createUnifiedPromptSearcher({
         content: [
           { type: 'text', text },
           {
-            type: 'json',
-            text: JSON.stringify({ total, page: normalizedPage, pageSize: normalizedPageSize, results: pageResults }, null, DEFAULT_INDENT),
+            type: 'text',
+            text: '```json\n' + JSON.stringify({ total, page: normalizedPage, pageSize: normalizedPageSize, results: pageResults }, null, DEFAULT_INDENT) + '\n```',
           },
         ],
       };