@goodandready/dsh-image-gen 0.11.38 → 0.11.40

package/lib/register-tools.js

@@ -19,6 +19,9 @@ 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 { registerCapabilityTools } from './tools/capabilities.js'
+import { registerProjectProfileTools } from './tools/project-profiles.js'
 import {
   createLiveProgressSession,
   publishLiveProgress,
@@ -38,6 +41,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 +78,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 +141,22 @@ 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 })
+    }
+    if (Boolean(sets.capabilities)) {
+      registerCapabilityTools(targetCtx, deps)
+    }
+    if (Boolean(sets.profiles)) {
+      registerProjectProfileTools(targetCtx, deps)
+    }
   }
 
   function dispose() {

package/lib/tools/capabilities.js

@@ -0,0 +1,139 @@
+import {
+  getCapabilityRegistry,
+  recommendModelForTask,
+  validateModelCapability,
+} from '../capabilities.js'
+
+/**
+ * Registers capability-based model selection tools (#434).
+ */
+export function registerCapabilityTools(ctx, deps = {}) {
+  ctx.tools.register({
+    name: 'select_image_model',
+    description: 'Recommends the best provider and model based on required task capabilities (text rendering, inpainting, face preservation, cost limits).',
+    parameters: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        operations: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Required operations, e.g. ["txt2img", "inpaint", "img2img"].',
+        },
+        textRendering: {
+          type: 'boolean',
+          description: 'Whether native high-precision text rendering is required.',
+        },
+        facePreservation: {
+          type: 'boolean',
+          description: 'Whether facial identity likeness preservation is required.',
+        },
+        maskInpainting: {
+          type: 'boolean',
+          description: 'Whether pixel-accurate inpainting mask support is required.',
+        },
+        referenceConditioning: {
+          type: 'boolean',
+          description: 'Whether reference image guidance is required.',
+        },
+        controlnet: {
+          type: 'boolean',
+          description: 'Whether structural ControlNet guidance is required.',
+        },
+        minResolution: {
+          type: 'number',
+          description: 'Minimum resolution in pixels (e.g. 1024 or 2048).',
+        },
+        maxCostUSD: {
+          type: 'number',
+          description: 'Maximum estimated cost in USD per generation.',
+        },
+      },
+    },
+    output: {
+      render(args, value) {
+        if (!value?.ok) {
+          return [{ type: 'text', text: `Capability selection: ${value?.message || 'No matching model found.'}` }]
+        }
+        const rec = value.recommended
+        return [
+          {
+            type: 'text',
+            text: `Recommended Model: ${rec.displayName} (${rec.provider}/${rec.modelId})\nReason: ${value.recommendationReason}\nEstimated Cost: $${rec.estimatedCostUSD} (Source: ${rec.pricingSource})`,
+          },
+        ]
+      },
+    },
+    async execute(args) {
+      const requirements = {
+        operations: args.operations || [],
+        textRendering: Boolean(args.textRendering),
+        facePreservation: Boolean(args.facePreservation),
+        maskInpainting: Boolean(args.maskInpainting),
+        referenceConditioning: Boolean(args.referenceConditioning),
+        controlnet: Boolean(args.controlnet),
+        minResolution: args.minResolution || 0,
+        maxCost: args.maxCostUSD || Infinity,
+      }
+
+      // Check configured provider list from deps or runtime
+      const configuredProviders = deps.cfg?.provider ? [deps.cfg.provider] : null
+      return recommendModelForTask(requirements, { configuredProviders })
+    },
+  })
+
+  ctx.tools.register({
+    name: 'validate_model_features',
+    description: 'Pre-flight check if a model or provider supports specific generation features before running the task.',
+    parameters: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        provider: {
+          type: 'string',
+          description: 'Provider name (fal, gemini, replicate, local, seedream).',
+        },
+        modelId: {
+          type: 'string',
+          description: 'Specific model identifier.',
+        },
+        operation: {
+          type: 'string',
+          description: 'Requested operation (txt2img, img2img, inpaint).',
+        },
+        requiresMask: {
+          type: 'boolean',
+          description: 'Whether operation requires inpainting mask.',
+        },
+        requiresReference: {
+          type: 'boolean',
+          description: 'Whether operation requires reference image.',
+        },
+        requiresFacePreservation: {
+          type: 'boolean',
+          description: 'Whether operation requires face preservation.',
+        },
+        requiresTextRender: {
+          type: 'boolean',
+          description: 'Whether operation requires text rendering.',
+        },
+      },
+      required: ['provider'],
+    },
+    output: {
+      render(args, value) {
+        return [
+          {
+            type: 'text',
+            text: value.valid
+              ? `Validation PASSED for ${args.provider}: ${value.model?.displayName}`
+              : `Validation FAILED (${value.status}): ${value.reason}`,
+          },
+        ]
+      },
+    },
+    async execute(args) {
+      return validateModelCapability(args.provider, args.modelId, args)
+    },
+  })
+}

package/lib/tools/project-profiles.js

@@ -0,0 +1,139 @@
+import {
+  getAllProjectProfiles,
+  getProjectProfileById,
+  saveCustomProfile,
+  deleteCustomProfile,
+  resolveEffectiveParams,
+} from '../project-profiles.js'
+
+/**
+ * Registers project visual profile management tools (#435).
+ */
+export function registerProjectProfileTools(ctx, deps = {}) {
+  ctx.tools.register({
+    name: 'manage_project_profiles',
+    description: 'Manages visual project and series profiles (list, get, save, delete) for consistent styling across generation sets.',
+    parameters: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['list', 'get', 'save', 'delete'],
+          description: 'Action to perform: list all profiles, get by id, save (create/update), or delete.',
+        },
+        id: {
+          type: 'string',
+          description: 'Profile ID for get or delete actions.',
+        },
+        profile: {
+          type: 'object',
+          additionalProperties: true,
+          description: 'Profile specification object for save action (id, name, palette, stylePrompt, negativePrompt, format, rules).',
+        },
+      },
+      required: ['action'],
+    },
+    output: {
+      render(args, value) {
+        if (args.action === 'list') {
+          const list = Array.isArray(value) ? value : []
+          return [
+            {
+              type: 'text',
+              text: `Project Profiles (${list.length}):\n` +
+                list.map((p) => `- [${p.id}] ${p.name} (v${p.version || '1.0.0'}) ${p.builtin ? '(builtin)' : '(custom)'}`).join('\n'),
+            },
+          ]
+        }
+        if (args.action === 'get') {
+          return [
+            {
+              type: 'text',
+              text: value ? `Profile [${value.id}] ${value.name}:\nStyle: "${value.stylePrompt || ''}"\nPalette: ${(value.palette || []).join(', ')}` : 'Profile not found.',
+            },
+          ]
+        }
+        if (args.action === 'save') {
+          return [{ type: 'text', text: `Saved profile [${value?.id}] ${value?.name} successfully.` }]
+        }
+        if (args.action === 'delete') {
+          return [{ type: 'text', text: value ? `Deleted profile ${args.id}.` : `Profile ${args.id} not found or cannot be deleted.` }]
+        }
+        return [{ type: 'text', text: JSON.stringify(value) }]
+      },
+    },
+    async execute(args) {
+      const storagePath = deps.profilesPath || null
+      if (args.action === 'list') {
+        return getAllProjectProfiles(storagePath)
+      }
+      if (args.action === 'get') {
+        return getProjectProfileById(args.id, storagePath)
+      }
+      if (args.action === 'save') {
+        return saveCustomProfile(args.profile, storagePath)
+      }
+      if (args.action === 'delete') {
+        return deleteCustomProfile(args.id, storagePath)
+      }
+      throw new Error(`Unknown action: ${args.action}`)
+    },
+  })
+
+  ctx.tools.register({
+    name: 'resolve_project_profile_params',
+    description: 'Calculates effective generation parameters by cascading request overrides over a project visual profile and system defaults.',
+    parameters: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        profileId: {
+          type: 'string',
+          description: 'Identifier of the project visual profile.',
+        },
+        prompt: {
+          type: 'string',
+          description: 'Specific image request prompt.',
+        },
+        negativePrompt: {
+          type: 'string',
+          description: 'Specific negative prompt overrides.',
+        },
+        size: {
+          type: 'string',
+          description: 'Specific dimensions (e.g. 1024x1024 or 1280x720).',
+        },
+        format: {
+          type: 'string',
+          description: 'Output format (webp, png, jpeg).',
+        },
+      },
+      required: ['profileId'],
+    },
+    output: {
+      render(args, value) {
+        return [
+          {
+            type: 'text',
+            text: `Effective Parameters for Profile [${value?.appliedProfile?.name || args.profileId}]:\n` +
+              `Prompt: "${value?.effectiveParams?.prompt || ''}"\n` +
+              `Negative: "${value?.effectiveParams?.negativePrompt || ''}"\n` +
+              `Dimensions: ${value?.effectiveParams?.size} (${value?.effectiveParams?.format})\n` +
+              `Provenance: ${JSON.stringify(value?.provenance || {})}`,
+          },
+        ]
+      },
+    },
+    async execute(args) {
+      const storagePath = deps.profilesPath || null
+      const requestParams = {
+        prompt: args.prompt,
+        negativePrompt: args.negativePrompt,
+        size: args.size,
+        format: args.format,
+      }
+      return resolveEffectiveParams(requestParams, args.profileId, storagePath)
+    },
+  })
+}

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.40",
   "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",