@goodandready/dsh-image-gen 0.11.38 → 0.11.39

package/lib/client.js

@@ -396,6 +396,7 @@ window.__ModuleLoader__.load({
       // Backward-compat aliases for tests
       { field: 'localComfyUrl', spec: textField('localComfyUrl'), kind: 'text', labelKey: 'f.localComfyUrl', hintKey: 'f.localComfyUrlHint', placeholderKey: 'p.localComfyUrl', when: ['local'], tab: 'provider' },
       { field: 'localA1111Url', spec: textField('localA1111Url'), kind: 'text', labelKey: 'f.localA1111Url', hintKey: 'f.localA1111UrlHint', placeholderKey: 'p.localA1111Url', when: ['local'], tab: 'provider' },
+      { field: 'comfyTemplate', spec: selectField('comfyTemplate', ['', 'txt2img_sdxl', 'img2img_sdxl', 'face_instantid', 'upscale_esrgan']), kind: 'select', options: ['', 'txt2img_sdxl', 'img2img_sdxl', 'face_instantid', 'upscale_esrgan'], labelKey: 'f.comfyTemplate', hintKey: 'f.comfyTemplateHint', when: ['local'], tab: 'provider' },
       { field: 'comfyWorkflowJson', spec: jsonField('comfyWorkflowJson'), kind: 'text', labelKey: 'f.comfyWorkflowJson', hintKey: 'f.comfyWorkflowJsonHint', placeholderKey: 'p.comfyWorkflowJson', when: ['local'], tab: 'provider' },
 
       // Provider: Codex / Grok
@@ -2875,6 +2876,8 @@ window.__ModuleLoader__.load({
       'vault.search': 'Search prompt or tags...',
       'vault.seed': 'Seed',
       'vault.title': 'Asset Browser & Vault',
+      'f.comfyTemplate': 'ComfyUI Workflow Template',
+      'f.comfyTemplateHint': 'Pre-vetted workflow template (e.g. SDXL txt2img, img2img, InstantID face transfer, RealESRGAN upscaler).',
     }
     const zh = {
       'card.actionRemoveBg': '移除背景',
@@ -3182,6 +3185,8 @@ window.__ModuleLoader__.load({
       'vault.search': '搜索提示词或标签...',
       'vault.seed': '种子',
       'vault.title': '图像素材库与浏览器',
+      'f.comfyTemplate': 'ComfyUI 工作流模板',
+      'f.comfyTemplateHint': '经过验证的预设工作流模板（例如 SDXL 文生图、图生图、InstantID 人脸迁移、RealESRGAN 放大器）。',
     }
     // Dual compatibility with DSH 0.1.5-rc.3 (settingsScope) and 0.1.6+ (configForms) (#291, #295)
     const inject = ['slots', 'locale', 'sessions']

package/lib/comfy-catalog.js

@@ -0,0 +1,433 @@
+// lib/comfy-catalog.js — Vetted ComfyUI workflow catalog with dependency validation (#433)
+import { interpolateComfyWorkflow, validateComfyWorkflow } from './comfy-workflow-helpers.js'
+
+/**
+ * Catalog of vetted ComfyUI workflow templates.
+ * Based on official Comfy-Org workflow templates under Apache-2.0 license.
+ */
+export const COMFY_TEMPLATES = [
+  {
+    id: 'txt2img_sdxl',
+    name: 'SDXL Text to Image',
+    description: 'High-quality direct text-to-image synthesis using SDXL Base architecture.',
+    version: '1.0.0',
+    source: 'Comfy-Org/workflow_templates',
+    license: 'Apache-2.0',
+    category: 'generation',
+    requiredNodes: [
+      'KSampler',
+      'CheckpointLoaderSimple',
+      'EmptyLatentImage',
+      'CLIPTextEncode',
+      'VAEDecode',
+      'SaveImage',
+    ],
+    requiredModels: [
+      'sd_xl_base_1.0.safetensors',
+    ],
+    inputs: [
+      { name: 'prompt', type: 'string', required: true, description: 'Positive prompt description' },
+      { name: 'negativePrompt', type: 'string', default: 'blurry, low quality, artifacts', description: 'Negative prompt' },
+      { name: 'width', type: 'number', default: 1024, description: 'Image width in pixels' },
+      { name: 'height', type: 'number', default: 1024, description: 'Image height in pixels' },
+      { name: 'steps', type: 'number', default: 25, description: 'Sampling steps' },
+      { name: 'cfg', type: 'number', default: 7.0, description: 'Classifier-free guidance scale' },
+      { name: 'seed', type: 'number', default: 0, description: 'RNG seed' },
+    ],
+    graph: {
+      '3': {
+        class_type: 'KSampler',
+        inputs: {
+          seed: '{{seed}}',
+          steps: '{{steps}}',
+          cfg: '{{cfg}}',
+          sampler_name: 'euler',
+          scheduler: 'normal',
+          denoise: 1,
+          model: ['4', 0],
+          positive: ['6', 0],
+          negative: ['7', 0],
+          latent_image: ['5', 0],
+        },
+      },
+      '4': {
+        class_type: 'CheckpointLoaderSimple',
+        inputs: { ckpt_name: '{{model}}' },
+      },
+      '5': {
+        class_type: 'EmptyLatentImage',
+        inputs: { width: '{{width}}', height: '{{height}}', batch_size: 1 },
+      },
+      '6': {
+        class_type: 'CLIPTextEncode',
+        inputs: { text: '{{prompt}}', clip: ['4', 1] },
+      },
+      '7': {
+        class_type: 'CLIPTextEncode',
+        inputs: { text: '{{negativePrompt}}', clip: ['4', 1] },
+      },
+      '8': {
+        class_type: 'VAEDecode',
+        inputs: { samples: ['3', 0], vae: ['4', 2] },
+      },
+      '9': {
+        class_type: 'SaveImage',
+        inputs: { filename_prefix: 'dsh_sdxl', images: ['8', 0] },
+      },
+    },
+  },
+  {
+    id: 'img2img_sdxl',
+    name: 'SDXL Image to Image Refinement',
+    description: 'Refines and restyles existing images with guided prompt and adjustable denoise strength.',
+    version: '1.0.0',
+    source: 'Comfy-Org/workflow_templates',
+    license: 'Apache-2.0',
+    category: 'editing',
+    requiredNodes: [
+      'KSampler',
+      'CheckpointLoaderSimple',
+      'LoadImage',
+      'VAEEncode',
+      'CLIPTextEncode',
+      'VAEDecode',
+      'SaveImage',
+    ],
+    requiredModels: [
+      'sd_xl_base_1.0.safetensors',
+    ],
+    inputs: [
+      { name: 'image', type: 'string', required: true, description: 'Base image path or base64' },
+      { name: 'prompt', type: 'string', required: true, description: 'Refinement guidance prompt' },
+      { name: 'negativePrompt', type: 'string', default: 'low quality, artifacts' },
+      { name: 'denoise', type: 'number', default: 0.65, description: 'Denoising transformation strength' },
+      { name: 'steps', type: 'number', default: 25 },
+      { name: 'cfg', type: 'number', default: 7.0 },
+      { name: 'seed', type: 'number', default: 0 },
+    ],
+    graph: {
+      '1': {
+        class_type: 'LoadImage',
+        inputs: { image: '{{image}}' },
+      },
+      '2': {
+        class_type: 'VAEEncode',
+        inputs: { pixels: ['1', 0], vae: ['4', 2] },
+      },
+      '3': {
+        class_type: 'KSampler',
+        inputs: {
+          seed: '{{seed}}',
+          steps: '{{steps}}',
+          cfg: '{{cfg}}',
+          sampler_name: 'euler',
+          scheduler: 'normal',
+          denoise: '{{denoise}}',
+          model: ['4', 0],
+          positive: ['6', 0],
+          negative: ['7', 0],
+          latent_image: ['2', 0],
+        },
+      },
+      '4': {
+        class_type: 'CheckpointLoaderSimple',
+        inputs: { ckpt_name: '{{model}}' },
+      },
+      '6': {
+        class_type: 'CLIPTextEncode',
+        inputs: { text: '{{prompt}}', clip: ['4', 1] },
+      },
+      '7': {
+        class_type: 'CLIPTextEncode',
+        inputs: { text: '{{negativePrompt}}', clip: ['4', 1] },
+      },
+      '8': {
+        class_type: 'VAEDecode',
+        inputs: { samples: ['3', 0], vae: ['4', 2] },
+      },
+      '9': {
+        class_type: 'SaveImage',
+        inputs: { filename_prefix: 'dsh_img2img', images: ['8', 0] },
+      },
+    },
+  },
+  {
+    id: 'face_instantid',
+    name: 'Facial Identity InstantID Transfer',
+    description: 'Transfers facial identity and likeness from reference photo onto synthesized character.',
+    version: '1.0.0',
+    source: 'InstantID/ComfyUI',
+    license: 'Apache-2.0',
+    category: 'identity',
+    requiredNodes: [
+      'KSampler',
+      'CheckpointLoaderSimple',
+      'LoadImage',
+      'ApplyInstantID',
+      'InstantIDModelLoader',
+      'SaveImage',
+    ],
+    requiredModels: [
+      'ip-adapter-instantid_sdxl.bin',
+    ],
+    inputs: [
+      { name: 'face_image', type: 'string', required: true, description: 'Source portrait image for identity extraction' },
+      { name: 'prompt', type: 'string', required: true, description: 'Scene and clothing prompt' },
+      { name: 'face_weight', type: 'number', default: 0.8, description: 'Facial identity similarity weight (0.0 - 1.0)' },
+      { name: 'steps', type: 'number', default: 30 },
+      { name: 'seed', type: 'number', default: 0 },
+    ],
+    graph: {
+      '1': {
+        class_type: 'LoadImage',
+        inputs: { image: '{{face_image}}' },
+      },
+      '2': {
+        class_type: 'InstantIDModelLoader',
+        inputs: { instantid_file: 'ip-adapter-instantid_sdxl.bin' },
+      },
+      '3': {
+        class_type: 'ApplyInstantID',
+        inputs: {
+          instantid: ['2', 0],
+          image: ['1', 0],
+          model: ['4', 0],
+          positive: ['6', 0],
+          negative: ['7', 0],
+          weight: '{{face_weight}}',
+        },
+      },
+      '4': {
+        class_type: 'CheckpointLoaderSimple',
+        inputs: { ckpt_name: '{{model}}' },
+      },
+      '5': {
+        class_type: 'EmptyLatentImage',
+        inputs: { width: 1024, height: 1024, batch_size: 1 },
+      },
+      '6': {
+        class_type: 'CLIPTextEncode',
+        inputs: { text: '{{prompt}}', clip: ['4', 1] },
+      },
+      '7': {
+        class_type: 'CLIPTextEncode',
+        inputs: { text: '{{negativePrompt}}', clip: ['4', 1] },
+      },
+      '8': {
+        class_type: 'KSampler',
+        inputs: {
+          seed: '{{seed}}',
+          steps: '{{steps}}',
+          cfg: 7,
+          sampler_name: 'euler',
+          scheduler: 'normal',
+          denoise: 1,
+          model: ['3', 0],
+          positive: ['3', 1],
+          negative: ['3', 2],
+          latent_image: ['5', 0],
+        },
+      },
+      '9': {
+        class_type: 'VAEDecode',
+        inputs: { samples: ['8', 0], vae: ['4', 2] },
+      },
+      '10': {
+        class_type: 'SaveImage',
+        inputs: { filename_prefix: 'dsh_faceid', images: ['9', 0] },
+      },
+    },
+  },
+  {
+    id: 'upscale_esrgan',
+    name: 'Real-ESRGAN Model Upscaler',
+    description: 'High-fidelity 4x super-resolution restoration via dedicated Real-ESRGAN neural upscaler.',
+    version: '1.0.0',
+    source: 'Comfy-Org/workflow_templates',
+    license: 'Apache-2.0',
+    category: 'upscale',
+    requiredNodes: [
+      'LoadImage',
+      'UpscaleModelLoader',
+      'ImageUpscaleWithModel',
+      'SaveImage',
+    ],
+    requiredModels: [
+      'RealESRGAN_x4plus.pth',
+    ],
+    inputs: [
+      { name: 'image', type: 'string', required: true, description: 'Source low-resolution image' },
+      { name: 'upscale_model', type: 'string', default: 'RealESRGAN_x4plus.pth', description: 'Upscaler model filename' },
+    ],
+    graph: {
+      '1': {
+        class_type: 'LoadImage',
+        inputs: { image: '{{image}}' },
+      },
+      '2': {
+        class_type: 'UpscaleModelLoader',
+        inputs: { model_name: '{{upscale_model}}' },
+      },
+      '3': {
+        class_type: 'ImageUpscaleWithModel',
+        inputs: {
+          upscale_model: ['2', 0],
+          image: ['1', 0],
+        },
+      },
+      '4': {
+        class_type: 'SaveImage',
+        inputs: { filename_prefix: 'dsh_upscale', images: ['3', 0] },
+      },
+    },
+  },
+]
+
+/**
+ * Returns summary list of all vetted ComfyUI templates.
+ */
+export function getComfyTemplates() {
+  return COMFY_TEMPLATES.map((t) => ({
+    id: t.id,
+    name: t.name,
+    description: t.description,
+    version: t.version,
+    source: t.source,
+    license: t.license,
+    category: t.category,
+    requiredNodes: [...t.requiredNodes],
+    requiredModels: [...t.requiredModels],
+    inputs: t.inputs.map((inp) => ({ ...inp })),
+  }))
+}
+
+/**
+ * Returns full template definition by ID or null.
+ */
+export function getComfyTemplate(id) {
+  if (!id) return null
+  return COMFY_TEMPLATES.find((t) => t.id === id) || null
+}
+
+/**
+ * Validates whether the ComfyUI server satisfies the dependencies required by a workflow template (#433).
+ * Explicitly distinguishes server reachability failures from missing node/model dependencies.
+ *
+ * @param {string} baseURL ComfyUI server address (e.g. http://127.0.0.1:8188)
+ * @param {object} template Template definition from getComfyTemplate
+ * @param {object} options
+ * @returns {Promise<{ ok: boolean, missingNodes: string[], missingModels: string[], error?: string }>}
+ */
+export function createComfyDependencyValidator({ fetchImpl = fetch, timeoutMs = 8000 } = {}) {
+  return async function validateComfyServerDependencies(baseURL, template) {
+    const base = String(baseURL || '').replace(/\/+$/, '')
+    if (!base) {
+      throw new Error('ComfyUI server URL is not configured')
+    }
+    if (!template) {
+      throw new Error('Template is required for dependency validation')
+    }
+
+    let objectInfo
+    try {
+      const controller = typeof AbortController !== 'undefined' ? new AbortController() : null
+      const timer = controller ? setTimeout(() => controller.abort(new Error('timeout')), timeoutMs) : null
+      const res = await fetchImpl(`${base}/object_info`, {
+        signal: controller ? controller.signal : undefined,
+      })
+      if (timer) clearTimeout(timer)
+      if (!res.ok) {
+        throw new Error(`HTTP ${res.status} from /object_info`)
+      }
+      objectInfo = await res.json()
+    } catch (err) {
+      // Re-throw server reachability error without masking it as a missing model error
+      const msg = err?.name === 'AbortError' ? 'connection timed out' : (err?.message || String(err))
+      throw new Error(`ComfyUI server is unreachable at ${base} (${msg})`)
+    }
+
+    if (!objectInfo || typeof objectInfo !== 'object') {
+      throw new Error(`ComfyUI server at ${base} returned invalid object_info`)
+    }
+
+    const availableNodes = new Set(Object.keys(objectInfo))
+    const missingNodes = (template.requiredNodes || []).filter((node) => !availableNodes.has(node))
+
+    // Model validation: inspect choices provided in CheckpointLoaderSimple or UpscaleModelLoader
+    const missingModels = []
+    if (template.requiredModels && template.requiredModels.length > 0) {
+      const ckptInfo = objectInfo.CheckpointLoaderSimple
+      const availableCkpts = Array.isArray(ckptInfo?.input?.required?.ckpt_name?.[0])
+        ? new Set(ckptInfo.input.required.ckpt_name[0])
+        : null
+
+      const upscaleInfo = objectInfo.UpscaleModelLoader
+      const availableUpscalers = Array.isArray(upscaleInfo?.input?.required?.model_name?.[0])
+        ? new Set(upscaleInfo.input.required.model_name[0])
+        : null
+
+      for (const model of template.requiredModels) {
+        if (model.endsWith('.pth') || model.endsWith('.pt')) {
+          if (availableUpscalers && !availableUpscalers.has(model)) {
+            missingModels.push(model)
+          }
+        } else if (model.endsWith('.safetensors') || model.endsWith('.ckpt')) {
+          if (availableCkpts && !availableCkpts.has(model)) {
+            missingModels.push(model)
+          }
+        }
+      }
+    }
+
+    if (missingNodes.length > 0 || missingModels.length > 0) {
+      const errors = []
+      if (missingNodes.length > 0) errors.push(`missing custom nodes: ${missingNodes.join(', ')}`)
+      if (missingModels.length > 0) errors.push(`missing model files: ${missingModels.join(', ')}`)
+      return {
+        ok: false,
+        missingNodes,
+        missingModels,
+        error: `ComfyUI dependencies missing for template "${template.name}": ${errors.join('; ')}`,
+      }
+    }
+
+    return {
+      ok: true,
+      missingNodes: [],
+      missingModels: [],
+    }
+  }
+}
+
+/**
+ * Prepares an executable ComfyUI workflow graph from a vetted template and user parameters.
+ *
+ * @param {string} templateId
+ * @param {object} params
+ * @returns {object} validated, interpolated workflow graph
+ */
+export function prepareComfyWorkflowFromTemplate(templateId, params = {}) {
+  const template = getComfyTemplate(templateId)
+  if (!template) {
+    throw new Error(`ComfyUI template "${templateId}" not found`)
+  }
+
+  // Validate required inputs
+  for (const input of template.inputs) {
+    if (input.required && (params[input.name] === undefined || params[input.name] === null || params[input.name] === '')) {
+      throw new Error(`Template "${template.name}" requires input "${input.name}"`)
+    }
+  }
+
+  // Apply default inputs if omitted
+  const merged = {}
+  for (const input of template.inputs) {
+    if (input.default !== undefined) {
+      merged[input.name] = input.default
+    }
+  }
+  Object.assign(merged, params)
+
+  const graph = interpolateComfyWorkflow(template.graph, merged)
+  return validateComfyWorkflow(graph)
+}

package/lib/config-schema.js

@@ -215,6 +215,11 @@ export const Config = z.object({
     .description('CFG scale for local generation.')
     .default(7.0)
     .volatile(),
+  comfyTemplate: z
+    .string()
+    .description('Vetted ComfyUI workflow template identifier (e.g. "txt2img_sdxl", "img2img_sdxl", "face_instantid", "upscale_esrgan").')
+    .default('')
+    .volatile(),
   comfyWorkflowJson: z
     .string()
     .description('Custom ComfyUI API workflow JSON template with {{prompt}}, {{seed}}, etc. placeholders.')

package/lib/index.js

@@ -48,6 +48,8 @@ import { registerLiveProgressRoutes } from './live-progress.js'
 import { registerSettingsRoutes } from './settings-route.js'
 import { clearAllAnchors } from './anchor-helpers.js'
 import { clearSpendReservations } from './cost-meter.js'
+import { getAllRecipes, getRecipe } from './recipes.js'
+import { getComfyTemplates, getComfyTemplate, createComfyDependencyValidator } from './comfy-catalog.js'
 import { resetLoopGuard, getLoopGuardState } from './loop-guard.js'
 import { Config, plainConfig, volatileConfig, publicConfig, ensureConfig } from './config-schema.js'
 import { resolveSource } from './resolve-source.js'
@@ -434,6 +436,35 @@ export function apply(ctx, rawConfig) {
   // Vault route (#159)
   registerVaultRoutes(ctx)
 
+  // Recipes & Comfy templates routes (#432, #433)
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-image-gen/recipes',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') {
+        res.writeHead(405, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ error: 'GET only' }))
+        return
+      }
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify({ ok: true, recipes: getAllRecipes() }))
+    },
+  }), 'dsh-image-gen: recipes route')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-image-gen/comfy/templates',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') {
+        res.writeHead(405, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ error: 'GET only' }))
+        return
+      }
+      res.writeHead(200, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify({ ok: true, templates: getComfyTemplates() }))
+    },
+  }), 'dsh-image-gen: comfy templates route')
+
   // Live events route (#379)
   registerLiveProgressRoutes(ctx)
 

package/lib/providers/backends/local.js

@@ -9,6 +9,12 @@ import {
   interpolateComfyWorkflow,
   buildDefaultComfyWorkflow,
 } from '../../comfy-workflow-helpers.js'
+import {
+  getComfyTemplate,
+  getComfyTemplates,
+  createComfyDependencyValidator,
+  prepareComfyWorkflowFromTemplate,
+} from '../../comfy-catalog.js'
 
 function resolveWebSocket() {
   if (typeof window !== 'undefined' && window.WebSocket) return window.WebSocket
@@ -108,7 +114,35 @@ export function createLocalGenerator(deps, job) {
     }
     const promptId = `dsh-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`
     let workflowGraph
-    if (cfg.comfyWorkflowJson) {
+    const activeTemplateId = job.comfyTemplate || cfg.comfyTemplate
+    if (activeTemplateId) {
+      const template = getComfyTemplate(activeTemplateId)
+      if (!template) {
+        throw new Error(`Unknown ComfyUI template "${activeTemplateId}". Available templates: ${getComfyTemplates().map((t) => t.id).join(', ')}`)
+      }
+      const validator = createComfyDependencyValidator({ fetchImpl, timeoutMs: 8000 })
+      const depCheck = await validator(base, template)
+      if (!depCheck.ok) {
+        throw new Error(depCheck.error)
+      }
+      const faceData = job.faceReference && job.faceReference.bytes
+        ? Buffer.from(job.faceReference.bytes).toString('base64')
+        : (job.faceReference?.url || '')
+      workflowGraph = prepareComfyWorkflowFromTemplate(activeTemplateId, {
+        prompt: promptArg,
+        negativePrompt: negativePrompt || '',
+        seed: seedArg ?? 0,
+        width,
+        height,
+        steps: cfg.localSteps ?? 20,
+        cfg: cfg.localCfg ?? 7,
+        model: cfg.localModel,
+        image: source && source.bytes ? Buffer.from(source.bytes).toString('base64') : '',
+        face_image: faceData,
+        face_weight: job.faceStrength ?? 0.75,
+        ...(job.templateParams || {}),
+      })
+    } else if (cfg.comfyWorkflowJson) {
       const template = validateComfyWorkflow(cfg.comfyWorkflowJson)
       const faceData = job.faceReference && job.faceReference.bytes
         ? Buffer.from(job.faceReference.bytes).toString('base64')

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,
+  })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-image-gen",
-  "version": "0.11.38",
+  "version": "0.11.39",
   "description": "Image generation for DeepSeek Harness: a generate_image tool with pluggable providers — the FAL queue, any OpenAI-compatible images API, or a ChatGPT/Grok subscription with no API key at all. The picture is shown inline in the conversation; the model receives either a link (works with any chat model) or the image itself (needs dsh-vision-bridge or a vision-capable model).",
   "keywords": [
     "deepseek-harness",