@goodandready/dsh-image-gen 0.10.18 → 0.10.19

package/lib/index.js

@@ -27,6 +27,7 @@ import {
   resolveApiKeyCandidates,
   toLosslessJson,
   saveAttachmentSafe,
+  testProviderConnection,
 } from './providers.js'
 
 import { buildDualOutputMarkdown, resolveConversationImage, analyzeImageWithVision } from './resolve-image.js'
@@ -276,6 +277,14 @@ export const Config = z.object({
     .string()
     .description('Model used to enhance the prompt. Empty means the same model that leads the conversation.')
     .default(''),
+  autoEnhancePrompt: z
+    .boolean()
+    .description('Enrich prompts with photography, lighting, and composition quality tokens.')
+    .default(false),
+  defaultStylePreset: z
+    .string()
+    .description('Default style preset applied to generations (e.g. cinematic, anime, photorealistic).')
+    .default('none'),
   enhanceBelowChars: z
     .number()
     .description('Only enhance prompts shorter than this many characters.')
@@ -620,7 +629,36 @@ export function apply(ctx, config) {
     }), `dsh-image-gen: image route ${path}`)
   }
 
-  // История генераций: in-memory список, отфильтрованный по существованию файлов.
+  // Диагностика подключения к провайдерам
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-image-gen/diagnostics/test',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') {
+        res.writeHead(405, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ error: 'GET only' }))
+        return
+      }
+      try {
+        const u = new URL(req.url, 'http://localhost')
+        const provider = u.searchParams.get('provider') || config.provider || 'fal'
+        const deps = {
+          fetchImpl: fetch,
+          resolveKey: (ref) => resolveApiKey(ctx, ref),
+          cfg: (typeof getConfig === "function") ? getConfig() : config,
+          ctx,
+        }
+        const result = await testProviderConnection(deps, provider)
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ provider, ...result }))
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ ok: false, error: err.message }))
+      }
+    },
+  }), 'dsh-image-gen: diagnostics test route')
+
+    // История генераций: in-memory список, отфильтрованный по существованию файлов.
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-image-gen/history',

package/lib/prompt-polisher.js

@@ -0,0 +1,194 @@
+/**
+ * @file lib/prompt-polisher.js
+ * Curated artistic/photographic style presets, smart prompt enrichment, and palette harmonization.
+ */
+
+export const CURATED_STYLES = {
+  cinematic: {
+    id: 'cinematic',
+    label: 'Cinematic Film',
+    promptSuffix: 'cinematic 35mm film still, anamorphic lighting, shallow depth of field, color graded, photorealistic details',
+    negativePrompt: 'cartoon, illustration, 3d render, oversaturated, blurry, distorted, amateur',
+    guidanceScale: 6.5,
+  },
+  photorealistic: {
+    id: 'photorealistic',
+    label: 'Photorealistic Studio',
+    promptSuffix: 'photorealistic portraiture, 85mm lens, natural studio lighting, micro-textures, 8k resolution, award-winning photography',
+    negativePrompt: 'illustration, drawing, anime, 3d render, plastic skin, CGI, doll-like',
+    guidanceScale: 7.0,
+  },
+  anime: {
+    id: 'anime',
+    label: 'Anime Masterpiece',
+    promptSuffix: 'clean anime aesthetic, sharp clean lineart, vibrant cel shading, detailed background scenery, Makoto Shinkai style',
+    negativePrompt: 'photorealistic, realistic photo, noisy, deformed, 3d model, lowres',
+    guidanceScale: 7.0,
+  },
+  minimalist_vector: {
+    id: 'minimalist_vector',
+    label: 'Minimalist Vector',
+    promptSuffix: 'minimalist vector art, clean sharp outlines, flat color fills, modern graphic design, Bauhaus aesthetics, SVG vector style',
+    negativePrompt: 'photorealistic, heavy gradients, 3d render, noisy texture, clutter, photorealism',
+    guidanceScale: 7.5,
+  },
+  isometric_3d: {
+    id: 'isometric_3d',
+    label: 'Isometric 3D',
+    promptSuffix: 'isometric 3D render, ambient occlusion, miniature diorama, Octane render, smooth clay surface, soft global illumination',
+    negativePrompt: 'flat, 2d, hand-drawn sketch, chaotic background, realistic photo',
+    guidanceScale: 7.0,
+  },
+  analog_film: {
+    id: 'analog_film',
+    label: 'Analog 35mm Film',
+    promptSuffix: 'vintage 35mm photograph, Kodak Portra 400 color science, authentic film grain, subtle halation, nostalgic muted tones',
+    negativePrompt: 'digital CGI, harsh sharpening, plastic, 3d render, oversaturated digital look',
+    guidanceScale: 6.5,
+  },
+  cyberpunk: {
+    id: 'cyberpunk',
+    label: 'Cyberpunk Neon',
+    promptSuffix: 'cyberpunk aesthetic, high-tech dark city, neon volumetric lighting, rain-slicked reflective surfaces, moody atmosphere',
+    negativePrompt: 'daylight, sunshine, pastoral, cartoon, pastel colors, washed out',
+    guidanceScale: 7.5,
+  },
+  pixel_art: {
+    id: 'pixel_art',
+    label: '16-bit Retro Pixel Art',
+    promptSuffix: '16-bit retro pixel art, crisp pixel grid, authentic dithered shading, nostalgic arcade palette, master pixel artwork',
+    negativePrompt: 'smooth vector, 3d render, blurry, modern photography, anti-aliased gradients',
+    guidanceScale: 8.0,
+  },
+  oil_painting: {
+    id: 'oil_painting',
+    label: 'Classical Oil Painting',
+    promptSuffix: 'classical fine art oil painting, impasto brushstrokes, textured canvas, chiaroscuro lighting, museum masterpiece',
+    negativePrompt: 'photograph, digital vector, 3d CGI, plastic, flat anime',
+    guidanceScale: 7.0,
+  },
+  claymation: {
+    id: 'claymation',
+    label: 'Claymation Stop-Motion',
+    promptSuffix: 'handcrafted claymation stop-motion aesthetic, tactile plasticine clay texture, studio macro softbox lighting, Aardman inspired',
+    negativePrompt: 'digital CGI, flat vector, photographic humans, harsh synthetic gloss',
+    guidanceScale: 7.5,
+  },
+}
+
+/**
+ * Normalizes a style identifier or alias into a canonical style key.
+ */
+export function normalizeStyleKey(key) {
+  if (!key) return null
+  const cleaned = String(key).trim().toLowerCase().replace(/[-\s]/g, '_')
+  if (CURATED_STYLES[cleaned]) return cleaned
+  // Alias mapping
+  if (cleaned === 'isometric') return 'isometric_3d'
+  if (cleaned === 'vector' || cleaned === 'minimalist') return 'minimalist_vector'
+  if (cleaned === 'film' || cleaned === 'analog') return 'analog_film'
+  if (cleaned === 'photo' || cleaned === 'realism') return 'photorealistic'
+  return cleaned
+}
+
+/**
+ * Smart prompt enrichment: adds photographic & lighting cues if requested.
+ */
+export function enrichWithQualityCues(prompt, styleKey = null) {
+  if (!prompt || typeof prompt !== 'string') return prompt
+  let p = prompt.trim()
+  const lower = p.toLowerCase()
+  
+  // Only append if not already containing lighting/detail tokens
+  const hasLighting = lower.includes('lighting') || lower.includes('light') || lower.includes('illumination')
+  const hasDetail = lower.includes('detailed') || lower.includes('highres') || lower.includes('sharp') || lower.includes('resolution')
+
+  const additions = []
+  if (!hasLighting) additions.push('balanced natural lighting')
+  if (!hasDetail && styleKey !== 'minimalist_vector' && styleKey !== 'pixel_art') additions.push('high visual clarity')
+
+  if (additions.length > 0) {
+    p = p.endsWith('.') ? `${p} ${additions.join(', ')}.` : `${p}, ${additions.join(', ')}`
+  }
+  return p
+}
+
+/**
+ * Polish and enrich a prompt with styles, auto-enhancements, and optional palette constraints.
+ * 
+ * @param {string} basePrompt 
+ * @param {string|null} stylePreset 
+ * @param {object} [options]
+ * @param {boolean} [options.autoEnhance=false]
+ * @param {string[]} [options.paletteColors=null]
+ * @param {string} [options.existingNegative]
+ * @param {number} [options.existingGuidance]
+ * @returns {{ prompt: string, negativePrompt?: string, guidanceScale?: number, styleApplied?: string }}
+ */
+export function polishPrompt(basePrompt, stylePreset = null, {
+  autoEnhance = false,
+  paletteColors = null,
+  existingNegative = '',
+  existingGuidance = undefined,
+} = {}) {
+  let prompt = String(basePrompt || '').trim()
+  let negative = existingNegative ? String(existingNegative).trim() : ''
+  let guidance = existingGuidance
+  let styleApplied = null
+
+  const key = normalizeStyleKey(stylePreset)
+  const preset = key ? CURATED_STYLES[key] : null
+
+  if (preset) {
+    styleApplied = preset.id
+    if (preset.promptSuffix && !prompt.toLowerCase().includes(preset.promptSuffix.toLowerCase())) {
+      prompt = prompt.endsWith('.') ? `${prompt} ${preset.promptSuffix}.` : `${prompt}, ${preset.promptSuffix}`
+    }
+    if (preset.negativePrompt) {
+      negative = [negative, preset.negativePrompt].filter(Boolean).join(', ')
+    }
+    if (guidance === undefined && preset.guidanceScale !== undefined) {
+      guidance = preset.guidanceScale
+    }
+  } else if (stylePreset && typeof stylePreset === 'string' && stylePreset.trim() && stylePreset !== 'none') {
+    // Custom style suffix string
+    const customSuffix = stylePreset.trim()
+    if (!prompt.toLowerCase().includes(customSuffix.toLowerCase())) {
+      prompt = `${prompt}, in ${customSuffix} style`
+    }
+  }
+
+  // Auto-enhance prompt if toggled
+  if (autoEnhance) {
+    prompt = enrichWithQualityCues(prompt, styleApplied)
+  }
+
+  // Palette constraint injection
+  if (Array.isArray(paletteColors) && paletteColors.length > 0) {
+    const validHex = paletteColors
+      .map(c => String(c).trim().toUpperCase())
+      .filter(c => /^#([0-9A-F]{3}|[0-9A-F]{6})$/i.test(c))
+    
+    if (validHex.length > 0) {
+      const paletteDirective = `chromatic palette strictly dominated by ${validHex.join(', ')}, harmonious color grading`
+      prompt = `${prompt}, ${paletteDirective}`
+      const paletteNeg = 'clashing foreign colors, dissonant hues, out-of-palette tints'
+      negative = [negative, paletteNeg].filter(Boolean).join(', ')
+    }
+  }
+
+  return {
+    prompt,
+    negativePrompt: negative || undefined,
+    guidanceScale: guidance,
+    styleApplied: styleApplied || undefined,
+  }
+}
+
+export function listCuratedStyles() {
+  return Object.values(CURATED_STYLES).map(s => ({
+    id: s.id,
+    label: s.label,
+    guidanceScale: s.guidanceScale,
+  }))
+}

package/lib/providers.js

@@ -1191,3 +1191,87 @@ export function toLosslessJson(val) {
   }
   return null
 }
+
+
+/**
+ * Diagnostic ping/connection test for a given provider.
+ * Returns { ok: boolean, latencyMs: number, message: string }.
+ */
+export async function testProviderConnection(deps, providerId) {
+  const { fetchImpl = fetch, resolveKey, cfg } = deps
+  const start = Date.now()
+  const p = (providerId || cfg.defaultProvider || 'fal').toLowerCase()
+
+  try {
+    if (p === 'fal') {
+      const key = await resolveKey(cfg.apiKeyEnv || 'FAL_KEY')
+      if (!key) return { ok: false, latencyMs: 0, message: 'FAL API key not configured' }
+      const res = await fetchImpl('https://queue.fal.run/fal-ai/fast-sdxl/status', {
+        headers: { Authorization: falAuthHeader(key) },
+        signal: typeof AbortSignal !== 'undefined' && AbortSignal.timeout ? AbortSignal.timeout(6000) : undefined,
+      })
+      const latencyMs = Date.now() - start
+      if (res.status === 401 || res.status === 403) {
+        return { ok: false, latencyMs, message: `Fal auth failed (HTTP ${res.status})` }
+      }
+      return { ok: true, latencyMs, message: 'Fal.ai queue reachable' }
+    }
+
+    if (p === 'comfyui') {
+      const url = cfg.comfyuiUrl || cfg.localBaseURL || 'http://127.0.0.1:8188'
+      const res = await fetchImpl(`${url.replace(/\/+$/, '')}/system_stats`, {
+        signal: typeof AbortSignal !== 'undefined' && AbortSignal.timeout ? AbortSignal.timeout(5000) : undefined,
+      })
+      const latencyMs = Date.now() - start
+      if (res.ok) {
+        const data = await res.json().catch(() => ({}))
+        const vram = data?.devices?.[0]?.vram_free ? ` (${Math.round(data.devices[0].vram_free / 1048576)} MB free VRAM)` : ''
+        return { ok: true, latencyMs, message: `ComfyUI operational${vram}` }
+      }
+      return { ok: false, latencyMs, message: `ComfyUI returned HTTP ${res.status}` }
+    }
+
+    if (p === 'a1111') {
+      const url = cfg.a1111Url || cfg.localBaseURL || 'http://127.0.0.1:7860'
+      const res = await fetchImpl(`${url.replace(/\/+$/, '')}/sdapi/v1/samplers`, {
+        signal: typeof AbortSignal !== 'undefined' && AbortSignal.timeout ? AbortSignal.timeout(5000) : undefined,
+      })
+      const latencyMs = Date.now() - start
+      if (res.ok) {
+        return { ok: true, latencyMs, message: 'Automatic1111 operational' }
+      }
+      return { ok: false, latencyMs, message: `A1111 returned HTTP ${res.status}` }
+    }
+
+    if (p === 'custom') {
+      const url = cfg.customEndpoint || cfg.customBaseURL || 'https://api.openai.com/v1'
+      const key = await resolveKey(cfg.customApiKeyEnv || cfg.customKeyEnv || 'OPENAI_API_KEY')
+      const headers = key ? { Authorization: `Bearer ${key}` } : {}
+      const res = await fetchImpl(`${url.replace(/\/+$/, '')}/models`, {
+        headers,
+        signal: typeof AbortSignal !== 'undefined' && AbortSignal.timeout ? AbortSignal.timeout(6000) : undefined,
+      })
+      const latencyMs = Date.now() - start
+      if (res.status === 401 || res.status === 403) {
+        return { ok: false, latencyMs, message: `Custom endpoint auth error (HTTP ${res.status})` }
+      }
+      if (res.ok || res.status === 404 || res.status === 405) {
+        return { ok: true, latencyMs, message: `Custom gateway reachable (HTTP ${res.status})` }
+      }
+      return { ok: false, latencyMs, message: `Custom endpoint returned HTTP ${res.status}` }
+    }
+
+    if (p === 'subscription' || p === 'chatgpt' || p === 'grok' || p === 'codex') {
+      const hasSub = Boolean(deps.ctx?.subscriptions)
+      const latencyMs = Date.now() - start
+      if (hasSub) {
+        return { ok: true, latencyMs, message: 'Subscription bridge available' }
+      }
+      return { ok: false, latencyMs, message: 'dsh-subscriptions plugin not installed' }
+    }
+
+    return { ok: true, latencyMs: Date.now() - start, message: `Provider "${p}" configured` }
+  } catch (err) {
+    return { ok: false, latencyMs: Date.now() - start, message: err.message || 'Connection timeout' }
+  }
+}

package/lib/tools/editing.js

@@ -75,6 +75,10 @@ export function registerEditingTools(ctx, deps) {
           },
           mask: {
             type: 'string',
+          },
+          mask_image: {
+            type: 'string',
+            description: 'Optional path or attachment id of the inpaint mask image (alias for mask).',
             description: 'Optional path or attachment id of the inpaint mask image.',
           },
           strength: {
@@ -120,7 +124,8 @@ export function registerEditingTools(ctx, deps) {
             })
             assertBudgetAvailable(estimatedCostEdit, cfg.dailyBudgetUsd)
             const source = await resolveConversationImage(ctx, exec, args.image)
-          const mask = args.mask ? await resolveSource(ctx, exec, args.mask) : undefined
+          const maskRef = args.mask_image || args.mask
+          const mask = maskRef ? await resolveSource(ctx, exec, maskRef) : undefined
           const vision = await analyzeImageWithVision(ctx, exec, source)
 
           let effectivePrompt = args.prompt
@@ -130,7 +135,7 @@ export function registerEditingTools(ctx, deps) {
 
           const provider = cfg.provider || 'fal'
           const deps = {
-            fetchImpl: ctx.http ? (url, opt) => ctx.http(url, opt) : fetch,
+            fetchImpl: fetch,
             resolveKey: (ref) => resolveApiKey(ctx, ref),
             cfg,
           }
@@ -257,7 +262,7 @@ export function registerEditingTools(ctx, deps) {
 
           const provider = cfg.provider || 'fal'
           const deps = {
-            fetchImpl: ctx.http ? (url, opt) => ctx.http(url, opt) : fetch,
+            fetchImpl: fetch,
             resolveKey: (ref) => resolveApiKey(ctx, ref),
             cfg,
           }

package/lib/tools/generation.js

@@ -1,3 +1,4 @@
+import { polishPrompt } from '../prompt-polisher.js'
 
 /** Run an array of async task functions with a concurrency cap */
 async function asyncPool(tasks, concurrency = 3) {
@@ -111,6 +112,15 @@ export function registerGenerationTools(ctx, deps) {
           type: 'string',
           description: 'Optional custom directory to write images into (relative to session cwd or absolute). Defaults to outputDir from settings.',
         },
+        style_preset: {
+          type: 'string',
+          description: 'Optional style preset: cinematic, photorealistic, anime, minimalist_vector, isometric_3d, analog_film, cyberpunk, claymation.',
+        },
+        palette_colors: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Optional array of hex color codes (#1e1b4b) to constrain and harmonize the color palette.',
+        },
         count: {
           type: 'integer',
           description: 'Number of variations to generate in one call, 1-4 (default 1). Cost scales with count.',
@@ -279,7 +289,7 @@ export function registerGenerationTools(ctx, deps) {
         assertBudgetAvailable(estimatedCost, cfg.dailyBudgetUsd)
         const providers = makeProviders(
           { fetchImpl: fetch, resolveKey: (ref) => resolveApiKey(ctx, ref), cfg, subscriptionImages },
-          { prompt: effectivePrompt, size, format, seed: args.seed, signal: exec.signal, negativePrompt: effectiveNegative, guidanceScale: effectiveGuidance, source, mask, strength: args.strength, quality: args.quality, style: args.style, aspectPixels, aspectRatio: args.aspect_ratio },
+          { prompt: effectivePrompt, size, format, seed: args.seed, signal: exec.signal, negativePrompt: effectivePolishedNegative, guidanceScale: effectiveGuidance, source, mask, strength: args.strength, quality: args.quality, style: args.style, aspectPixels, aspectRatio: args.aspect_ratio },
         )
         // Подписочные провайдеры (codex/grok) отдают {ok:false, reason} вместо исключения:
         // отказ должен дойти до модели текстом. Без проверки execute шёл дальше с пустыми

package/lib/tools/processing.js

@@ -321,4 +321,176 @@ export function registerProcessingTools(ctx, deps) {
       }),
     )
   }, 'dsh-image-gen: tool blend_images')
+
+  ctx.effect(() => {
+    ctx.tools.register(
+      defineTool({
+        name: 'assemble_image_grid',
+        description:
+          'Assemble 2 to 4 images into a clean side-by-side, 2x2 grid, or vertical collage comparison. '
+          + 'Generates a composite visual with labels, optimal spacing, and lossless fidelity. '
+          + 'Returns safe dual-output with an inline preview and downloadable image asset.',
+        parameters: {
+          images: {
+            type: 'array',
+            items: { type: 'string' },
+            required: true,
+            description: 'List of 2 to 4 image paths or attachment ids to assemble into a grid.',
+          },
+          layout: {
+            type: 'string',
+            enum: ['side_by_side', 'grid_2x2', 'vertical'],
+            description: 'Grid layout arrangement: "side_by_side" (default), "grid_2x2", or "vertical".',
+          },
+          title: {
+            type: 'string',
+            description: 'Optional headline title displayed above the assembled collage.',
+          },
+          output_name: {
+            type: 'string',
+            description: 'Optional custom file name stem for the output grid image.',
+          },
+        },
+        output: {
+          schema: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              summary: { type: 'string' },
+              path: { type: 'string' },
+              url: { type: 'string' },
+              layout: { type: 'string' },
+              imageCount: { type: 'number' },
+              format: { type: 'string' },
+              attachment: { type: 'object', additionalProperties: true },
+            },
+          },
+        },
+        async execute(args, exec) {
+          try {
+            const rawRefs = Array.isArray(args.images) ? args.images : [args.images].filter(Boolean)
+            if (rawRefs.length < 2) throw new Error('assemble_image_grid requires at least 2 images (received ' + rawRefs.length + ')')
+            const limitRefs = rawRefs.slice(0, 4)
+
+            const sources = []
+            for (const r of limitRefs) {
+              const s = await resolveSource(ctx, exec, r)
+              if (s && s.bytes) sources.push(s)
+            }
+            if (sources.length < 2) throw new Error('Could not resolve at least 2 valid image sources from provided references')
+
+            const layout = args.layout || 'side_by_side'
+            const title = args.title ? String(args.title).trim() : ''
+
+            const tileW = 512
+            const tileH = 512
+            const gap = 16
+            const pad = 16
+            const headerH = title ? 48 : 0
+
+            let cols = 2
+            let rows = 1
+            if (layout === 'side_by_side') {
+              cols = sources.length
+              rows = 1
+            } else if (layout === 'vertical') {
+              cols = 1
+              rows = sources.length
+            } else if (layout === 'grid_2x2') {
+              cols = 2
+              rows = Math.ceil(sources.length / 2)
+            }
+
+            const totalW = pad * 2 + cols * tileW + (cols - 1) * gap
+            const totalH = pad * 2 + headerH + rows * tileH + (rows - 1) * gap
+
+            const labels = ['A', 'B', 'C', 'D']
+            let tilesSvg = ''
+
+            sources.forEach((src, idx) => {
+              let c = idx
+              let r = 0
+              if (layout === 'side_by_side') {
+                c = idx
+                r = 0
+              } else if (layout === 'vertical') {
+                c = 0
+                r = idx
+              } else if (layout === 'grid_2x2') {
+                c = idx % 2
+                r = Math.floor(idx / 2)
+              }
+
+              const x = pad + c * (tileW + gap)
+              const y = pad + headerH + r * (tileH + gap)
+              const b64 = Buffer.isBuffer(src.bytes) ? src.bytes.toString('base64') : Buffer.from(src.bytes).toString('base64')
+              const mime = src.mediaType || 'image/png'
+              const dataUri = `data:${mime};base64,${b64}`
+              const label = labels[idx] || String(idx + 1)
+
+              tilesSvg += `
+  <g transform="translate(${x}, ${y})">
+    <clipPath id="clip-${idx}"><rect width="${tileW}" height="${tileH}" rx="8" ry="8"/></clipPath>
+    <rect width="${tileW}" height="${tileH}" rx="8" fill="#18191c" stroke="#2c2e33" stroke-width="1"/>
+    <image href="${dataUri}" width="${tileW}" height="${tileH}" preserveAspectRatio="xMidYMid slice" clip-path="url(#clip-${idx})"/>
+    <rect x="12" y="12" width="28" height="24" rx="4" fill="rgba(0,0,0,0.65)"/>
+    <text x="26" y="29" fill="#ffffff" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif" font-size="13" font-weight="700" text-anchor="middle">${label}</text>
+  </g>`
+            })
+
+            const escapedTitle = title
+              .replace(/&/g, '&amp;')
+              .replace(/</g, '&lt;')
+              .replace(/>/g, '&gt;')
+
+            const svgContent = `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="${totalW}" height="${totalH}" viewBox="0 0 ${totalW} ${totalH}">
+  <defs>
+    <style>
+      .bg { fill: #0f1012; }
+      .title { fill: #f3f4f6; font-family: -apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif; font-size: 16px; font-weight: 600; }
+    </style>
+  </defs>
+  <rect width="100%" height="100%" rx="12" class="bg"/>
+  ${title ? `<text x="${pad}" y="${pad + 24}" class="title">${escapedTitle}</text>` : ''}
+  ${tilesSvg}
+</svg>`
+
+            const svgBuffer = Buffer.from(svgContent, 'utf8')
+            const cfg = live()
+            const stem = `${slugify(args.output_name || 'grid-collage')}-${Date.now().toString(36)}`
+            const name = `${stem}.svg`
+            const { attachment, localUrl } = await saveAttachmentSafe(ctx, { bytes: svgBuffer, mediaType: 'image/svg+xml', name })
+
+            const sessionCwd = exec?.agent?.session?.header?.cwd
+            const outDir = path.resolve(sessionCwd || process.cwd(), cfg.outputDir || 'generated/images')
+            await mkdir(outDir, { recursive: true })
+            const filePath = path.join(outDir, name)
+            await writeFile(filePath, svgBuffer)
+
+            const summary = `### Assembled Image Grid (${layout})\n`
+              + `- **Images**: ${sources.length} sources combined (${layout})\n`
+              + `- **Canvas Size**: ${totalW} × ${totalH} px\n`
+              + `- **File**: \`${filePath}\`\n\n`
+              + `![${title || 'Assembled Grid'}](${localUrl || filePath})`
+
+            return toLosslessJson({
+              summary,
+              path: filePath,
+              url: localUrl,
+              layout,
+              imageCount: sources.length,
+              width: totalW,
+              height: totalH,
+              format: 'svg',
+              attachment,
+            })
+          } catch (err) {
+            throw new Error(sanitizeErrorAndLogs(err.message || err))
+          }
+        },
+      }),
+    )
+  }, 'dsh-image-gen: tool assemble_image_grid')
+
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-image-gen",
-  "version": "0.10.18",
+  "version": "0.10.19",
   "description": "Image generation for DeepSeek Harness: a generate_image tool with pluggable providers \u2014 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",