@goodandready/dsh-image-gen 0.11.37 → 0.11.39

package/lib/recipes.js

@@ -0,0 +1,410 @@
+// lib/recipes.js — Sequential image recipe pipelines with step tracking & cost safety (#432)
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+/**
+ * Built-in sequential recipe pipelines.
+ */
+export const BUILTIN_RECIPES = [
+  {
+    id: 'product_card',
+    name: 'Product Card Suite',
+    description: 'Generates product photography, cleanly removes background, and upscales for print or web presentation.',
+    version: '1.0.0',
+    category: 'e-commerce',
+    inputs: [
+      { name: 'prompt', type: 'string', required: true, description: 'Product and materials description' },
+      { name: 'size', type: 'string', default: '1024x1024', description: 'Initial generation dimensions' },
+      { name: 'scale', type: 'number', default: 2, description: 'Upscaling factor (2 or 4)' },
+    ],
+    steps: [
+      {
+        id: 'generate',
+        tool: 'generate_image',
+        description: 'Generate product visual',
+        params: {
+          prompt: '{{inputs.prompt}}, studio lighting, clean product shot',
+          size: '{{inputs.size}}',
+        },
+        estimatedCost: 0.02,
+      },
+      {
+        id: 'remove_bg',
+        tool: 'remove_background',
+        description: 'Remove background to transparent alpha',
+        params: {
+          image: '{{steps.generate.path}}',
+        },
+        estimatedCost: 0.01,
+      },
+      {
+        id: 'upscale',
+        tool: 'upscale_image',
+        description: 'Upscale transparent asset',
+        params: {
+          image: '{{steps.remove_bg.path}}',
+          scale: '{{inputs.scale}}',
+        },
+        estimatedCost: 0.02,
+      },
+    ],
+  },
+  {
+    id: 'social_promo',
+    name: 'Social Media Promo Banner',
+    description: 'Synthesizes theme graphic and smart crops to social widescreen (16:9) format.',
+    version: '1.0.0',
+    category: 'marketing',
+    inputs: [
+      { name: 'prompt', type: 'string', required: true, description: 'Promo announcement concept' },
+      { name: 'aspect', type: 'string', default: '16:9', description: 'Social crop aspect ratio' },
+    ],
+    steps: [
+      {
+        id: 'generate',
+        tool: 'generate_image',
+        description: 'Synthesize promo visual',
+        params: {
+          prompt: '{{inputs.prompt}}',
+          size: '1024x1024',
+        },
+        estimatedCost: 0.02,
+      },
+      {
+        id: 'crop',
+        tool: 'smart_crop_image',
+        description: 'Smart crop to destination ratio',
+        params: {
+          image: '{{steps.generate.path}}',
+          aspect: '{{inputs.aspect}}',
+        },
+        estimatedCost: 0.00,
+      },
+    ],
+  },
+  {
+    id: 'vector_asset',
+    name: 'Vector Asset Pipeline',
+    description: 'Generates clean icon concept, traces raster to vector paths, and produces scalable SVG.',
+    version: '1.0.0',
+    category: 'graphics',
+    inputs: [
+      { name: 'prompt', type: 'string', required: true, description: 'Icon concept prompt' },
+      { name: 'colors', type: 'number', default: 8, description: 'Palette color count for tracing' },
+    ],
+    steps: [
+      {
+        id: 'generate',
+        tool: 'generate_image',
+        description: 'Generate minimalist graphic',
+        params: {
+          prompt: '{{inputs.prompt}}, minimalist clean vector style, solid plain background',
+          size: '1024x1024',
+        },
+        estimatedCost: 0.02,
+      },
+      {
+        id: 'vectorize',
+        tool: 'vectorize_image',
+        description: 'Trace raster into clean vector paths',
+        params: {
+          image: '{{steps.generate.path}}',
+          mode: 'color',
+          colors: '{{inputs.colors}}',
+        },
+        estimatedCost: 0.00,
+      },
+    ],
+  },
+  {
+    id: 'character_pipeline',
+    name: 'Character Turnaround Pipeline',
+    description: 'Synthesizes character concept and generates multi-angle model turnaround sheet.',
+    version: '1.0.0',
+    category: 'creative',
+    inputs: [
+      { name: 'character_name', type: 'string', required: true, description: 'Name of the character' },
+      { name: 'prompt', type: 'string', required: true, description: 'Character description and attire' },
+    ],
+    steps: [
+      {
+        id: 'concept',
+        tool: 'generate_image',
+        description: 'Generate key character portrait',
+        params: {
+          prompt: '{{inputs.prompt}}, full body concept character art',
+          size: '1024x1024',
+        },
+        estimatedCost: 0.02,
+      },
+      {
+        id: 'turnaround',
+        tool: 'generate_character_sheet',
+        description: 'Generate model turnaround sheet',
+        params: {
+          character_name: '{{inputs.character_name}}',
+          reference_image: '{{steps.concept.path}}',
+          views: 'front,side,back',
+        },
+        estimatedCost: 0.03,
+      },
+    ],
+  },
+]
+
+function getRecipesFilePath() {
+  const base = process.env.DSH_HOME || path.join(os.homedir(), '.dsh')
+  return path.join(base, 'dsh-image-gen', 'recipes.json')
+}
+
+/**
+ * Loads custom recipes from local storage file.
+ */
+export function loadCustomRecipes() {
+  const filePath = getRecipesFilePath()
+  try {
+    if (!fs.existsSync(filePath)) return []
+    const content = fs.readFileSync(filePath, 'utf8')
+    const list = JSON.parse(content)
+    return Array.isArray(list) ? list : []
+  } catch (_) {
+    return []
+  }
+}
+
+/**
+ * Saves a user recipe to local storage.
+ */
+export function saveCustomRecipe(recipe) {
+  if (!recipe || typeof recipe !== 'object') {
+    throw new Error('Recipe must be an object')
+  }
+  if (!recipe.id || typeof recipe.id !== 'string') {
+    throw new Error('Recipe must have a valid string "id"')
+  }
+  if (!recipe.name || typeof recipe.name !== 'string') {
+    throw new Error('Recipe must have a valid string "name"')
+  }
+  if (!Array.isArray(recipe.steps) || recipe.steps.length === 0) {
+    throw new Error('Recipe must have a non-empty array of "steps"')
+  }
+
+  // Validate step format
+  for (let i = 0; i < recipe.steps.length; i++) {
+    const s = recipe.steps[i]
+    if (!s || !s.tool || typeof s.tool !== 'string') {
+      throw new Error(`Recipe step #${i + 1} missing required "tool" name`)
+    }
+  }
+
+  const list = loadCustomRecipes().filter((r) => r.id !== recipe.id)
+  const item = {
+    ...recipe,
+    custom: true,
+    updatedAt: new Date().toISOString(),
+  }
+  list.push(item)
+
+  const filePath = getRecipesFilePath()
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, JSON.stringify(list, null, 2), 'utf8')
+  return item
+}
+
+/**
+ * Deletes a user recipe by ID.
+ */
+export function deleteCustomRecipe(id) {
+  const list = loadCustomRecipes()
+  const filtered = list.filter((r) => r.id !== id)
+  if (filtered.length === list.length) return false
+  const filePath = getRecipesFilePath()
+  fs.writeFileSync(filePath, JSON.stringify(filtered, null, 2), 'utf8')
+  return true
+}
+
+/**
+ * Returns merged list of all available recipes (built-in + custom).
+ */
+export function getAllRecipes() {
+  const custom = loadCustomRecipes()
+  const customIds = new Set(custom.map((c) => c.id))
+  const builtins = BUILTIN_RECIPES.filter((b) => !customIds.has(b.id)).map((b) => ({
+    ...b,
+    builtin: true,
+  }))
+  return [...builtins, ...custom]
+}
+
+/**
+ * Retrieves a recipe by ID.
+ */
+export function getRecipe(id) {
+  if (!id) return null
+  return getAllRecipes().find((r) => r.id === id) || null
+}
+
+/**
+ * Interpolates recipe step parameters using context containing inputs and prior step results.
+ */
+export function interpolateRecipeParams(rawParams, context = {}) {
+  const { inputs = {}, steps = {} } = context
+
+  function resolveRef(str) {
+    if (typeof str !== 'string') return str
+    const trimmed = str.trim()
+
+    // Handle exact number matches
+    if (/^\{\{inputs\.([a-zA-Z0-9_.-]+)\}\}$/.test(trimmed)) {
+      const key = trimmed.slice(9, -2)
+      return inputs[key] !== undefined ? inputs[key] : ''
+    }
+
+    // General replacements
+    let out = str.replace(/\{\{inputs\.([a-zA-Z0-9_.-]+)\}\}/g, (_, k) => {
+      return inputs[k] !== undefined ? String(inputs[k]) : ''
+    })
+
+    out = out.replace(/\{\{steps\.([a-zA-Z0-9_.-]+)\.([a-zA-Z0-9_.-]+)\}\}/g, (_, stepId, prop) => {
+      const stepData = steps[stepId]
+      if (!stepData) return ''
+      // Try direct property or nested image/attachment properties
+      if (stepData[prop] !== undefined) return String(stepData[prop])
+      if (prop === 'path' && stepData.images?.[0]?.path) return String(stepData.images[0].path)
+      if (prop === 'url' && stepData.images?.[0]?.url) return String(stepData.images[0].url)
+      if (prop === 'path' && stepData.attachment?.path) return String(stepData.attachment.path)
+      if (prop === 'path' && stepData.svgPath) return String(stepData.svgPath)
+      return ''
+    })
+
+    return out
+  }
+
+  function transform(val) {
+    if (typeof val === 'string') return resolveRef(val)
+    if (Array.isArray(val)) return val.map(transform)
+    if (val && typeof val === 'object') {
+      const res = {}
+      for (const [k, v] of Object.entries(val)) {
+        res[k] = transform(v)
+      }
+      return res
+    }
+    return val
+  }
+
+  return transform(rawParams)
+}
+
+/**
+ * Executes a sequential image recipe pipeline (#432).
+ *
+ * @param {string|object} recipeOrId Recipe ID or full recipe object
+ * @param {object} userInputs User provided arguments (e.g. prompt, image, aspect)
+ * @param {object} env Runtime tools environment
+ * @param {Function} env.toolDispatcher Function (toolName, params) => Promise<result>
+ * @param {Function} [env.assertBudget] Function (amount) => throws if insufficient budget
+ * @param {Function} [env.onProgress] Function ({ stage, progress })
+ * @returns {Promise<object>} Recipe execution summary and final artifact
+ */
+export async function executeRecipe(recipeOrId, userInputs = {}, env = {}) {
+  const { toolDispatcher, assertBudget, onProgress } = env
+  if (typeof toolDispatcher !== 'function') {
+    throw new Error('Recipe runner requires a toolDispatcher function')
+  }
+
+  const recipe = typeof recipeOrId === 'string' ? getRecipe(recipeOrId) : recipeOrId
+  if (!recipe) {
+    throw new Error(`Recipe "${recipeOrId}" not found`)
+  }
+
+  // 1. Validate required inputs
+  const mergedInputs = {}
+  for (const inp of recipe.inputs || []) {
+    if (inp.default !== undefined) mergedInputs[inp.name] = inp.default
+  }
+  Object.assign(mergedInputs, userInputs)
+
+  for (const inp of recipe.inputs || []) {
+    if (inp.required && (mergedInputs[inp.name] === undefined || mergedInputs[inp.name] === null || mergedInputs[inp.name] === '')) {
+      throw new Error(`Recipe "${recipe.name}" missing required input: "${inp.name}"`)
+    }
+  }
+
+  // 2. Pre-flight dry run: estimate total budget and verify tools exist before executing paid requests
+  let totalEstimatedCost = 0
+  for (let i = 0; i < recipe.steps.length; i++) {
+    const step = recipe.steps[i]
+    totalEstimatedCost += Number(step.estimatedCost || 0)
+  }
+
+  if (typeof assertBudget === 'function' && totalEstimatedCost > 0) {
+    assertBudget(totalEstimatedCost)
+  }
+
+  // 3. Sequential step execution
+  const completedSteps = []
+  const stepContext = {
+    inputs: mergedInputs,
+    steps: {},
+  }
+
+  for (let i = 0; i < recipe.steps.length; i++) {
+    const step = recipe.steps[i]
+    const stepId = step.id || String(i)
+    const stepDescription = step.description || `Step ${i + 1}: ${step.tool}`
+
+    onProgress?.({
+      stage: `Step ${i + 1}/${recipe.steps.length}: ${step.tool}`,
+      progress: Math.round((i / recipe.steps.length) * 100),
+    })
+
+    const interpolated = interpolateRecipeParams(step.params || {}, stepContext)
+
+    const startTime = Date.now()
+    let result
+    try {
+      result = await toolDispatcher(step.tool, interpolated)
+    } catch (err) {
+      const failedErr = new Error(`Recipe "${recipe.name}" failed at step ${i + 1} (${step.tool}): ${err.message}`)
+      failedErr.recipeId = recipe.id
+      failedErr.failedStepIndex = i
+      failedErr.failedStepTool = step.tool
+      failedErr.completedSteps = completedSteps
+      throw failedErr
+    }
+
+    const durationMs = Date.now() - startTime
+    const record = {
+      stepIndex: i,
+      stepId,
+      tool: step.tool,
+      description: stepDescription,
+      params: interpolated,
+      durationMs,
+      result,
+    }
+
+    completedSteps.push(record)
+    stepContext.steps[stepId] = result
+    stepContext.steps[String(i)] = result
+  }
+
+  onProgress?.({
+    stage: 'Recipe completed',
+    progress: 100,
+  })
+
+  const lastResult = completedSteps[completedSteps.length - 1]?.result
+
+  return {
+    ok: true,
+    recipeId: recipe.id,
+    recipeName: recipe.name,
+    stepsCount: recipe.steps.length,
+    completedSteps,
+    finalResult: lastResult,
+    totalEstimatedCost: +totalEstimatedCost.toFixed(4),
+  }
+}

package/lib/register-tools.js

@@ -19,6 +19,7 @@ import { registerThemePairTools } from './tools/theme-pair.js'
 import { registerCharacterSheetTools } from './tools/character-sheet.js'
 import { registerVisionOcrTools } from './tools/vision-ocr.js'
 import { registerDiagramTools } from './tools/diagram.js'
+import { registerRecipeTools } from './tools/recipes.js'
 import {
   createLiveProgressSession,
   publishLiveProgress,
@@ -38,6 +39,13 @@ export function registerAllTools(ctx, deps) {
   const registeredNames = new Set()
 
   const originalToolsRegister = ctx?.tools?.register ? ctx.tools.register.bind(ctx.tools) : null
+    const toolMap = new Map()
+  const toolDispatcher = async (name, params, exec) => {
+    const fn = toolMap.get(name)
+    if (!fn) throw new Error(`Tool "${name}" is not registered in current toolset profile`)
+    return fn(params, exec)
+  }
+
   const wrappedTools = originalToolsRegister ? Object.create(ctx.tools, {
     register: {
       value: (def) => {
@@ -68,6 +76,7 @@ export function registerAllTools(ctx, deps) {
         }
         const res = originalToolsRegister(wrappedDef)
         registeredNames.add(def.name)
+        toolMap.set(def.name, (p, e) => originalExecute(p, e))
         if (typeof res === 'function') {
           activeDisposers.push(res)
         } else {
@@ -130,12 +139,16 @@ export function registerAllTools(ctx, deps) {
       registerResponsiveTools(targetCtx, deps)
     }
 
-    // 5. Creative toolset
+    // 5. Creative toolset & Recipes (#432, #433)
     if (creative) {
       registerSketchTools(targetCtx, deps)
       registerSpritesheetTools(targetCtx, deps)
       registerPatternTools(targetCtx, deps)
     }
+
+    if (Boolean(sets.recipes)) {
+      registerRecipeTools(targetCtx, { ...deps, toolDispatcher })
+    }
   }
 
   function dispose() {

package/lib/tools/recipes.js

@@ -0,0 +1,250 @@
+// lib/tools/recipes.js — Tools for running recipes & validating ComfyUI workflows (#432, #433)
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import {
+  getAllRecipes,
+  getRecipe,
+  saveCustomRecipe,
+  deleteCustomRecipe,
+  executeRecipe,
+} from '../recipes.js'
+import {
+  getComfyTemplates,
+  getComfyTemplate,
+  createComfyDependencyValidator,
+  prepareComfyWorkflowFromTemplate,
+} from '../comfy-catalog.js'
+
+/**
+ * Registers recipe execution and workflow catalog tools.
+ *
+ * @param {object} ctx cordis context
+ * @param {object} deps shared runtime dependencies
+ */
+export function registerRecipeTools(ctx, deps) {
+  const { config, toolDispatcher, assertBudget } = deps
+
+  // 1. run_image_recipe (#432)
+  ctx.tools.register({
+    name: 'run_image_recipe',
+    description: 'Executes a repeatable sequential image recipe pipeline (e.g. product_card, social_promo, vector_asset, character_pipeline). Runs each step, validates budget and prerequisites, and provides intermediate and final results.',
+    parameters: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['recipe_id'],
+      properties: {
+        recipe_id: {
+          type: 'string',
+          description: 'Identifier of the recipe (e.g. "product_card", "social_promo", "vector_asset", "character_pipeline", or custom recipe ID).',
+        },
+        inputs: {
+          type: 'object',
+          additionalProperties: true,
+          description: 'Input arguments required by the recipe (e.g. prompt, image, aspect, scale, character_name).',
+        },
+      },
+    },
+    output: {
+      render(args, value) {
+        const steps = value?.completedSteps || []
+        const lines = [
+          `### Recipe: ${value?.recipeName || 'Recipe'} (${value?.recipeId || ''})`,
+          `Steps completed: ${steps.length}/${value?.stepsCount || 0} (Est. cost: $${value?.totalEstimatedCost || 0})`,
+          '',
+        ]
+        for (const step of steps) {
+          lines.push(`- **Step ${step.stepIndex + 1}: ${step.tool}** (${step.durationMs}ms) — ${step.description}`)
+        }
+        return [{ type: 'text', text: lines.join('\n') }]
+      },
+    },
+    execute: async (args) => {
+      const { recipe_id, inputs = {} } = args || {}
+      if (!recipe_id) throw new Error('recipe_id is required')
+
+      const res = await executeRecipe(recipe_id, inputs, {
+        toolDispatcher,
+        assertBudget,
+      })
+
+      return res
+    },
+    render(args, value) {
+      const steps = value?.completedSteps || []
+      const lines = [
+        `### Recipe: ${value?.recipeName || 'Recipe'} (${value?.recipeId || ''})`,
+        `Steps completed: ${steps.length}/${value?.stepsCount || 0} (Est. cost: $${value?.totalEstimatedCost || 0})`,
+        '',
+      ]
+      for (const step of steps) {
+        lines.push(`- **Step ${step.stepIndex + 1}: ${step.tool}** (${step.durationMs}ms) — ${step.description}`)
+      }
+      return [{ type: 'text', text: lines.join('\n') }]
+    },
+    isConcurrencySafe: () => false,
+  })
+
+  // 2. manage_image_recipes (#432)
+  ctx.tools.register({
+    name: 'manage_image_recipes',
+    description: 'Lists, inspects, saves, or deletes sequential image generation recipes.',
+    parameters: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['action'],
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['list', 'get', 'save', 'delete'],
+          description: 'Recipe management action.',
+        },
+        recipe_id: {
+          type: 'string',
+          description: 'Recipe ID (required for get and delete).',
+        },
+        recipe: {
+          type: 'object',
+          additionalProperties: true,
+          description: 'Complete recipe object to save (required for action="save"). Must specify id, name, inputs, and steps.',
+        },
+      },
+    },
+    output: {
+      render(args, value) {
+        if (args?.action === 'list') {
+          const list = value?.recipes || []
+          const lines = [`Found ${list.length} available image recipes:`, '']
+          for (const r of list) {
+            lines.push(`- **${r.id}** (${r.name}): ${r.description} [${r.steps?.length || 0} steps]`)
+          }
+          return [{ type: 'text', text: lines.join('\n') }]
+        }
+        return [{ type: 'text', text: JSON.stringify(value || {}, null, 2) }]
+      },
+    },
+    execute: async (args) => {
+      const { action, recipe_id, recipe } = args || {}
+      if (action === 'list') {
+        return { ok: true, recipes: getAllRecipes() }
+      }
+      if (action === 'get') {
+        if (!recipe_id) throw new Error('recipe_id is required for action="get"')
+        const found = getRecipe(recipe_id)
+        if (!found) throw new Error(`Recipe "${recipe_id}" not found`)
+        return { ok: true, recipe: found }
+      }
+      if (action === 'save') {
+        if (!recipe) throw new Error('recipe object is required for action="save"')
+        const saved = saveCustomRecipe(recipe)
+        return { ok: true, recipe: saved, message: `Recipe "${saved.id}" saved successfully` }
+      }
+      if (action === 'delete') {
+        if (!recipe_id) throw new Error('recipe_id is required for action="delete"')
+        const deleted = deleteCustomRecipe(recipe_id)
+        if (!deleted) throw new Error(`Custom recipe "${recipe_id}" not found or cannot be deleted`)
+        return { ok: true, deleted: true, recipe_id }
+      }
+      throw new Error(`Unsupported action "${action}"`)
+    },
+    render(args, value) {
+      if (args?.action === 'list') {
+        const list = value?.recipes || []
+        const lines = [`Found ${list.length} available image recipes:`, '']
+        for (const r of list) {
+          lines.push(`- **${r.id}** (${r.name}): ${r.description} [${r.steps?.length || 0} steps]`)
+        }
+        return [{ type: 'text', text: lines.join('\n') }]
+      }
+      return [{ type: 'text', text: JSON.stringify(value || {}, null, 2) }]
+    },
+    isConcurrencySafe: () => true,
+  })
+
+  // 3. validate_comfy_workflow (#433)
+  ctx.tools.register({
+    name: 'validate_comfy_workflow',
+    description: 'Validates a vetted ComfyUI template or custom workflow graph against the connected ComfyUI server dependencies and models.',
+    parameters: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        template_id: {
+          type: 'string',
+          description: 'Identifier of the vetted ComfyUI template (e.g. "txt2img_sdxl", "img2img_sdxl", "face_instantid", "upscale_esrgan").',
+        },
+        base_url: {
+          type: 'string',
+          description: 'ComfyUI server address (defaults to configured localBaseURL).',
+        },
+      },
+    },
+    output: {
+      render(args, value) {
+        if (value?.templateId) {
+          const status = value.ok ? 'READY' : 'MISSING DEPENDENCIES'
+          const lines = [
+            `### ComfyUI Template: ${value.templateName} [${status}]`,
+            `Server: ${value.serverUrl}`,
+          ]
+          if (value.missingNodes?.length) lines.push(`- Missing Nodes: ${value.missingNodes.join(', ')}`)
+          if (value.missingModels?.length) lines.push(`- Missing Models: ${value.missingModels.join(', ')}`)
+          if (value.ok) lines.push('All required custom nodes and model assets are available on the ComfyUI host.')
+          return [{ type: 'text', text: lines.join('\n') }]
+        }
+        const list = value?.templates || []
+        const lines = [`Vetted ComfyUI Templates (${list.length}):`, '']
+        for (const t of list) lines.push(`- **${t.id}**: ${t.name} (${t.description})`)
+        return [{ type: 'text', text: lines.join('\n') }]
+      },
+    },
+    execute: async (args) => {
+      const { template_id, base_url } = args || {}
+      const targetBase = base_url || config?.localBaseURL || 'http://127.0.0.1:8188'
+
+      if (template_id) {
+        const template = getComfyTemplate(template_id)
+        if (!template) {
+          throw new Error(`ComfyUI template "${template_id}" not found. Available: ${getComfyTemplates().map((t) => t.id).join(', ')}`)
+        }
+
+        const validator = createComfyDependencyValidator()
+        const check = await validator(targetBase, template)
+        return {
+          ok: check.ok,
+          templateId: template.id,
+          templateName: template.name,
+          requiredNodes: template.requiredNodes,
+          requiredModels: template.requiredModels,
+          missingNodes: check.missingNodes,
+          missingModels: check.missingModels,
+          serverUrl: targetBase,
+          error: check.error,
+        }
+      }
+
+      // If no template specified, return catalog summary
+      return {
+        ok: true,
+        templates: getComfyTemplates(),
+        serverUrl: targetBase,
+      }
+    },
+    render(args, value) {
+      if (value?.templateId) {
+        const status = value.ok ? 'READY' : 'MISSING DEPENDENCIES'
+        const lines = [
+          `### ComfyUI Template: ${value.templateName} [${status}]`,
+          `Server: ${value.serverUrl}`,
+        ]
+        if (value.missingNodes?.length) lines.push(`- Missing Nodes: ${value.missingNodes.join(', ')}`)
+        if (value.missingModels?.length) lines.push(`- Missing Models: ${value.missingModels.join(', ')}`)
+        if (value.ok) lines.push('All required custom nodes and model assets are available on the ComfyUI host.')
+        return [{ type: 'text', text: lines.join('\n') }]
+      }
+      const list = value?.templates || []
+      const lines = [`Vetted ComfyUI Templates (${list.length}):`, '']
+      for (const t of list) lines.push(`- **${t.id}**: ${t.name} (${t.description})`)
+      return [{ type: 'text', text: lines.join('\n') }]
+    },
+    isConcurrencySafe: () => true,
+  })
+}