@goodandready/dsh-image-gen 0.10.30 → 0.10.32

package/lib/tools/generation.js

@@ -52,6 +52,8 @@ import { calculateGenerationCost, recordSpend, assertBudgetAvailable } from '../
 import { trackAndAssertLoopGuard } from '../loop-guard.js'
 import { sanitizeErrorAndLogs } from '../security.js'
 import { getCachedGeneration, setCachedGeneration } from '../generation-cache.js'
+import { resolveFallbackChain, executeWithFallback } from '../fallback-router.js'
+import { getSessionAnchor, applyAnchorPromptHints } from '../anchor-helpers.js'
 import {
   extractDesignTokens,
   generateCssGradient,
@@ -173,6 +175,14 @@ export function registerGenerationTools(ctx, deps) {
           type: 'boolean',
           description: 'Optional flag to bypass content-addressed cache and force a new API generation.',
         },
+        reference_image: {
+          type: 'string',
+          description: 'Optional reference image (URL, path, or sha256:...) for character or style consistency.',
+        },
+        reference_strength: {
+          type: 'number',
+          description: 'Optional strength of reference anchor influence (0.1 to 1.0).',
+        },
       },
       output: {
         schema: {
@@ -266,7 +276,13 @@ export function registerGenerationTools(ctx, deps) {
         const enhanced = await enhancePrompt(ctx, cfg, args.prompt, exec.signal, provider)
         const effectiveStyle = args.style || cfg.stylePreset
         const styleInfo = resolveStylePreset(effectiveStyle, args.negative_prompt, args.guidance_scale)
-        const effectivePrompt = styleInfo.promptSuffix ? `${enhanced.prompt}, ${styleInfo.promptSuffix}` : enhanced.prompt
+        let effectivePrompt = styleInfo.promptSuffix ? `${enhanced.prompt}, ${styleInfo.promptSuffix}` : enhanced.prompt
+        const activeAnchor = getSessionAnchor(sessionId)
+        if (args.reference_image) {
+          effectivePrompt = `${effectivePrompt}, visual reference anchor`
+        } else if (activeAnchor) {
+          effectivePrompt = applyAnchorPromptHints(activeAnchor, effectivePrompt)
+        }
 
         // #165: Negative prompt sanitizer for diffusion models
         let effectiveNegative = styleInfo.negativePrompt
@@ -419,7 +435,7 @@ export function registerGenerationTools(ctx, deps) {
         const seedBase = args.seed ?? Math.floor(Math.random() * 100000)
         // Fallback cascade: evaluate configured provider, falling back to alternates
         // (fal -> custom -> codex -> grok), accumulating failure diagnostics.
-        const order = fallbackOrder(provider)
+        const order = resolveFallbackChain(provider, cfg.fallbackProviders, PROVIDER_KEYS)
         const qgEnabled = args.quality_gate ?? cfg.qualityGate
         const generators = Object.fromEntries(PROVIDER_KEYS.map((k) => [
           k,
@@ -512,7 +528,7 @@ export function registerGenerationTools(ctx, deps) {
           const tasks = batchPrompts.map((item, i) => async () => {
             const text = typeof item === 'string' ? item : (item && item.text) || ''
             const cached = await checkCache(seedBase + i, text)
-            return cached || await tryGenerate(generators, order, seedBase + i, text)
+            return cached || await executeWithFallback(generators, order, seedBase + i, text, { logger: ctx.logger })
           })
           const parallelResults = await asyncPool(tasks, 3)
           images.push(...parallelResults)
@@ -520,7 +536,7 @@ export function registerGenerationTools(ctx, deps) {
           const count = normalizeCount(args.count)
           const tasks = Array.from({ length: count }, (_, i) => async () => {
             const cached = await checkCache(seedBase + i, effectivePrompt)
-            return cached || await tryGenerate(generators, order, seedBase + i)
+            return cached || await executeWithFallback(generators, order, seedBase + i, effectivePrompt, { logger: ctx.logger })
           })
           const parallelResults = await asyncPool(tasks, 3)
           images.push(...parallelResults)
@@ -538,7 +554,7 @@ export function registerGenerationTools(ctx, deps) {
           cost: first.cost,
           attachmentId: first.attachment?.attachmentId || 'N/A',
         })
-        return toLosslessJson({ summary: dualOutputSummary, channel: provider, provider, model: cfg.model || cfg.customModel, ...first, images })
+        return toLosslessJson({ summary: dualOutputSummary, channel: provider, provider, model: cfg.model || cfg.customModel, _fallback: first._fallback, anchor: activeAnchor ? { label: activeAnchor.label, mode: activeAnchor.mode } : undefined, ...first, images })
       },
     }),
   )

package/lib/tools/style-matrix.js

@@ -0,0 +1,227 @@
+// style-matrix.js — generate_style_matrix tool (#286).
+// Parallel 2×2 style matrix explorer with blind A/B compare and one-click preset selection.
+
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import path from 'node:path'
+import { mkdir, writeFile } from 'node:fs/promises'
+import {
+  ASPECT_RATIOS,
+  PROVIDER_KEYS,
+  buildSidecar,
+  makeProviders,
+  toLosslessJson,
+  saveAttachmentSafe,
+} from '../providers.js'
+import { resolveFallbackChain, executeWithFallback } from '../fallback-router.js'
+import {
+  DEFAULT_MATRIX_STYLES,
+  normalizeMatrixStyles,
+  buildMatrixCellPrompt,
+  formatMatrixMarkdown,
+} from '../style-matrix-helpers.js'
+
+async function asyncPool(tasks, concurrency = 2) {
+  const results = new Array(tasks.length)
+  let nextIdx = 0
+  async function worker() {
+    while (nextIdx < tasks.length) {
+      const idx = nextIdx++
+      results[idx] = await tasks[idx]()
+    }
+  }
+  const workers = Array.from({ length: Math.min(concurrency, tasks.length) }, () => worker())
+  await Promise.all(workers)
+  return results
+}
+
+export function registerStyleMatrixTools(ctx, deps) {
+  const {
+    live,
+    slugify,
+    resolveApiKey,
+  } = deps
+
+  ctx.effect(() => {
+    ctx.tools.register(
+      defineTool({
+        name: 'generate_style_matrix',
+        description:
+          'Generate a 2×2 visual style exploration matrix for a single subject or concept. '
+          + 'Renders 4 distinct artistic styles in parallel for rapid comparison or blind evaluation.',
+        parameters: {
+          prompt: {
+            type: 'string',
+            required: true,
+            description: 'Core subject or scene description to benchmark across styles, e.g. "a lone astronaut sitting on Mars campfire".',
+          },
+          styles: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Optional array of 4 style presets to compare. Defaults to: editorial_photo, flat_vector, clay_3d, cyberpunk.',
+          },
+          aspect_ratio: {
+            type: 'string',
+            enum: ['1:1', '16:9', '4:3', '3:4'],
+            description: 'Aspect ratio for all matrix cells (default: 1:1).',
+          },
+          blind_mode: {
+            type: 'boolean',
+            description: 'When true, masks style names in the initial view to facilitate unbiased visual judging.',
+          },
+          seed: {
+            type: 'integer',
+            description: 'Base seed for the matrix generations.',
+          },
+        },
+        output: {
+          schema: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              matrix_id: { type: 'string' },
+              base_prompt: { type: 'string' },
+              blind_mode: { type: 'boolean' },
+              cells: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  additionalProperties: true,
+                  properties: {
+                    id: { type: 'string' },
+                    style: { type: 'string' },
+                    path: { type: 'string' },
+                    url: { type: 'string' },
+                    seed: { type: 'integer' },
+                    width: { type: 'integer' },
+                    height: { type: 'integer' },
+                    attachment: { type: 'object' },
+                  },
+                },
+              },
+            },
+          },
+          render(args, value) {
+            const summary = formatMatrixMarkdown({
+              basePrompt: value.base_prompt,
+              blindMode: value.blind_mode,
+              cells: value.cells || [],
+            })
+            return [{ type: 'text', text: summary }]
+          },
+        },
+        isConcurrencySafe: () => false,
+        async execute(args, exec) {
+          const cfg = live()
+          if (cfg.enabled === false) {
+            throw new Error('Image generation is disabled in settings.')
+          }
+
+          const basePrompt = String(args.prompt || '').trim()
+          if (!basePrompt) throw new Error('Parameter "prompt" is required.')
+
+          const activeStyles = normalizeMatrixStyles(args.styles)
+          const aspectRatio = args.aspect_ratio || '1:1'
+          const aspectPixels = ASPECT_RATIOS[aspectRatio] || [1024, 1024]
+          const blindMode = Boolean(args.blind_mode)
+          const baseSeed = args.seed ?? Math.floor(Math.random() * 100000)
+
+          const provider = PROVIDER_KEYS.includes(cfg.provider) ? cfg.provider : 'fal'
+          let subscriptionImages
+          try { subscriptionImages = ctx.get && ctx.get('subscriptionImages') } catch (_) { subscriptionImages = undefined }
+
+          const chain = resolveFallbackChain(provider, cfg.fallbackProviders, PROVIDER_KEYS)
+          const quadrantIds = ['A', 'B', 'C', 'D']
+          const matrixId = `matrix-${Date.now().toString(36)}`
+
+          const sessionCwd = exec.agent?.session?.header?.cwd
+          const targetDir = cfg.outputDir || 'generated/images'
+          const outDir = path.resolve(sessionCwd || process.cwd(), targetDir)
+          await mkdir(outDir, { recursive: true })
+
+          const tasks = activeStyles.map((styleName, idx) => async () => {
+            const quadrantId = quadrantIds[idx] || `Q${idx + 1}`
+            const cellSeed = baseSeed + idx * 1013
+            const cellPrompt = buildMatrixCellPrompt(basePrompt, styleName)
+
+            const providers = makeProviders(
+              { fetchImpl: fetch, resolveKey: (ref) => resolveApiKey(ctx, ref), cfg, subscriptionImages },
+              {
+                prompt: cellPrompt,
+                size: 'custom',
+                format: 'png',
+                seed: cellSeed,
+                signal: exec.signal,
+                aspectPixels,
+                aspectRatio,
+              },
+            )
+
+            const gen = await executeWithFallback(providers, chain, cellSeed, cellPrompt, {
+              logger: ctx.logger,
+            })
+
+            const stem = `${slugify(`matrix-${styleName}-${basePrompt}`)}-${Date.now().toString(36)}-${cellSeed}`
+            const filename = `${stem}.png`
+            const { attachment, localUrl } = await saveAttachmentSafe(ctx, {
+              bytes: gen.bytes,
+              mediaType: 'image/png',
+              name: filename,
+            })
+
+            const filePath = path.join(outDir, filename)
+            await writeFile(filePath, gen.bytes)
+
+            await writeFile(
+              path.join(outDir, `${stem}.json`),
+              JSON.stringify(buildSidecar({
+                prompt: cellPrompt,
+                size: `${gen.width || aspectPixels[0]}x${gen.height || aspectPixels[1]}`,
+                format: 'png',
+                seed: cellSeed,
+                provider: gen._fallback?.providerUsed || provider,
+                deliverAs: cfg.deliverAs || 'link',
+                width: gen.width || aspectPixels[0],
+                height: gen.height || aspectPixels[1],
+                mediaType: 'image/png',
+                attachmentId: attachment.attachmentId,
+                url: localUrl,
+                cost: gen.cost,
+              }), null, 2),
+            )
+
+            return {
+              id: quadrantId,
+              index: idx,
+              style: styleName,
+              prompt: cellPrompt,
+              seed: cellSeed,
+              path: filePath,
+              url: localUrl,
+              width: gen.width || aspectPixels[0],
+              height: gen.height || aspectPixels[1],
+              attachment,
+              cost: gen.cost,
+            }
+          })
+
+          const cells = await asyncPool(tasks, 2)
+
+          const summary = formatMatrixMarkdown({
+            basePrompt,
+            blindMode,
+            cells,
+          })
+
+          return toLosslessJson({
+            matrix_id: matrixId,
+            base_prompt: basePrompt,
+            blind_mode: blindMode,
+            aspect_ratio: aspectRatio,
+            cells,
+            summary,
+          })
+        },
+      }),
+    )
+  }, 'dsh-image-gen: tool generate_style_matrix')
+}

package/lib/tools/ui-asset.js

@@ -0,0 +1,238 @@
+// ui-asset.js — generate_ui_asset tool (#284).
+// Specialized generator for UI icons, stickers, illustrations, and layout-aware banners with negative space.
+
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import path from 'node:path'
+import { mkdir, writeFile } from 'node:fs/promises'
+import {
+  ASPECT_RATIOS,
+  PROVIDER_KEYS,
+  buildSidecar,
+  makeProviders,
+  removeBackgroundFal,
+  toLosslessJson,
+  saveAttachmentSafe,
+} from '../providers.js'
+import { resolveFallbackChain, executeWithFallback } from '../fallback-router.js'
+import { buildDualOutputMarkdown } from '../resolve-image.js'
+import {
+  UI_ASSET_TYPES,
+  LAYOUT_COMPOSITIONS,
+  COLOR_MODES,
+  buildUiAssetPrompt,
+} from '../ui-asset-helpers.js'
+
+export function registerUiAssetTools(ctx, deps) {
+  const {
+    live,
+    slugify,
+    resolveApiKey,
+  } = deps
+
+  ctx.effect(() => {
+    ctx.tools.register(
+      defineTool({
+        name: 'generate_ui_asset',
+        description:
+          'Specialized generator for UI elements (icons, illustrations, stickers, badges, banners). '
+          + 'Supports layout-aware composition with empty negative space for typography and automatic background removal.',
+        parameters: {
+          prompt: {
+            type: 'string',
+            required: true,
+            description: 'Subject or motif to generate, e.g. "rocket taking off with smoke trail" or "shopping cart with notification dot".',
+          },
+          asset_type: {
+            type: 'string',
+            enum: UI_ASSET_TYPES,
+            description: 'Type of UI element: icon, illustration, badge, sticker, or hero_banner (default: icon).',
+          },
+          transparent: {
+            type: 'boolean',
+            description: 'When true (default), automatically strips background into a clean transparent PNG.',
+          },
+          layout_composition: {
+            type: 'string',
+            enum: LAYOUT_COMPOSITIONS,
+            description: 'Negative space layout: isolated (centered), left_empty (negative space on left for text), right_empty, top_empty, or center_empty.',
+          },
+          color_mode: {
+            type: 'string',
+            enum: COLOR_MODES,
+            description: 'Color styling: flat (solid fills, default), monochrome, duotone, or full_color.',
+          },
+          aspect_ratio: {
+            type: 'string',
+            enum: ['1:1', '16:9', '9:16', '4:3', '3:4'],
+            description: 'Asset aspect ratio. Defaults to 1:1 (or 16:9 for hero_banner).',
+          },
+          output_name: {
+            type: 'string',
+            description: 'Optional file stem for saved asset.',
+          },
+          seed: {
+            type: 'integer',
+            description: 'Optional seed for reproducible generation.',
+          },
+        },
+        output: {
+          schema: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              path: { type: 'string' },
+              url: { type: 'string' },
+              asset_type: { type: 'string' },
+              layout_composition: { type: 'string' },
+              transparent: { type: 'boolean' },
+              width: { type: 'integer' },
+              height: { type: 'integer' },
+              attachment: {
+                type: 'object',
+                additionalProperties: true,
+              },
+            },
+          },
+          render(args, value) {
+            const summary = `Generated UI ${value.asset_type || 'asset'} (${value.layout_composition || 'isolated'}, ${value.transparent ? 'transparent' : 'opaque'}): ${value.path}`
+            return [{ type: 'text', text: summary }]
+          },
+        },
+        isConcurrencySafe: () => false,
+        async execute(args, exec) {
+          const cfg = live()
+          if (cfg.enabled === false) {
+            throw new Error('Image generation is disabled in settings.')
+          }
+
+          const asset_type = UI_ASSET_TYPES.includes(args.asset_type) ? args.asset_type : 'icon'
+          const layout_composition = LAYOUT_COMPOSITIONS.includes(args.layout_composition) ? args.layout_composition : 'isolated'
+          const color_mode = COLOR_MODES.includes(args.color_mode) ? args.color_mode : 'flat'
+          const transparent = args.transparent !== false
+
+          const defaultRatio = asset_type === 'hero_banner' ? '16:9' : '1:1'
+          const aspectRatio = args.aspect_ratio || defaultRatio
+          const aspectPixels = ASPECT_RATIOS[aspectRatio] || [1024, 1024]
+
+          const synthesizedPrompt = buildUiAssetPrompt({
+            prompt: args.prompt,
+            asset_type,
+            layout_composition,
+            color_mode,
+          })
+
+          const provider = PROVIDER_KEYS.includes(cfg.provider) ? cfg.provider : 'fal'
+          let subscriptionImages
+          try { subscriptionImages = ctx.get && ctx.get('subscriptionImages') } catch (_) { subscriptionImages = undefined }
+
+          const providers = makeProviders(
+            { fetchImpl: fetch, resolveKey: (ref) => resolveApiKey(ctx, ref), cfg, subscriptionImages },
+            {
+              prompt: synthesizedPrompt,
+              size: 'custom',
+              format: 'png',
+              seed: args.seed,
+              signal: exec.signal,
+              aspectPixels,
+              aspectRatio,
+            },
+          )
+
+          const chain = resolveFallbackChain(provider, cfg.fallbackProviders, PROVIDER_KEYS)
+          const seedVal = args.seed ?? Math.floor(Math.random() * 100000)
+
+          const gen = await executeWithFallback(providers, chain, seedVal, synthesizedPrompt, {
+            logger: ctx.logger,
+          })
+
+          let finalBytes = gen.bytes
+          let mediaType = gen.mediaType || 'image/png'
+          let width = gen.width || aspectPixels[0]
+          let height = gen.height || aspectPixels[1]
+
+          // Automatic background removal if requested and image is generated
+          if (transparent && finalBytes) {
+            try {
+              const bgResult = await removeBackgroundFal(
+                { fetchImpl: fetch, resolveKey: (ref) => resolveApiKey(ctx, ref), cfg },
+                { imageBytes: finalBytes, mediaType, signal: exec.signal },
+              )
+              if (bgResult && bgResult.bytes) {
+                finalBytes = bgResult.bytes
+                mediaType = 'image/png'
+                if (bgResult.width) width = bgResult.width
+                if (bgResult.height) height = bgResult.height
+              }
+            } catch (bgErr) {
+              if (ctx.logger && typeof ctx.logger.warn === 'function') {
+                ctx.logger.warn(`[generate_ui_asset] Transparent background removal skipped: ${bgErr.message}`)
+              }
+            }
+          }
+
+          const stem = `${slugify(args.output_name || `${asset_type}-${args.prompt}`)}-${Date.now().toString(36)}-${seedVal}`
+          const filename = `${stem}.png`
+          const { attachment, localUrl } = await saveAttachmentSafe(ctx, {
+            bytes: finalBytes,
+            mediaType: 'image/png',
+            name: filename,
+          })
+
+          const sessionCwd = exec.agent?.session?.header?.cwd
+          const targetDir = cfg.outputDir || 'generated/images'
+          const outDir = path.resolve(sessionCwd || process.cwd(), targetDir)
+          await mkdir(outDir, { recursive: true })
+          const filePath = path.join(outDir, filename)
+          await writeFile(filePath, finalBytes)
+
+          await writeFile(
+            path.join(outDir, `${stem}.json`),
+            JSON.stringify(buildSidecar({
+              prompt: synthesizedPrompt,
+              size: `${width}x${height}`,
+              format: 'png',
+              seed: seedVal,
+              provider: gen._fallback?.providerUsed || provider,
+              deliverAs: cfg.deliverAs || 'link',
+              width,
+              height,
+              mediaType: 'image/png',
+              attachmentId: attachment.attachmentId,
+              url: localUrl,
+              cost: gen.cost,
+            }), null, 2),
+          )
+
+          const dualOutput = buildDualOutputMarkdown({
+            action: 'generated',
+            filePath,
+            width,
+            height,
+            mediaType: 'image/png',
+            seed: seedVal,
+            provider: gen._fallback?.providerUsed || provider,
+            model: cfg.model || cfg.customModel || 'ui-asset',
+            cost: gen.cost,
+            attachmentId: attachment.attachmentId,
+          })
+
+          return toLosslessJson({
+            summary: dualOutput,
+            path: filePath,
+            url: localUrl,
+            asset_type,
+            layout_composition,
+            color_mode,
+            transparent,
+            width,
+            height,
+            seed: seedVal,
+            format: 'png',
+            attachment,
+            _fallback: gen._fallback,
+          })
+        },
+      }),
+    )
+  }, 'dsh-image-gen: tool generate_ui_asset')
+}

package/lib/ui-asset-helpers.js

@@ -0,0 +1,44 @@
+// ui-asset-helpers.js — Helper constants and prompt builder for generate_ui_asset (#284).
+
+export const UI_ASSET_TYPES = ['icon', 'illustration', 'badge', 'sticker', 'hero_banner']
+export const LAYOUT_COMPOSITIONS = ['isolated', 'left_empty', 'right_empty', 'top_empty', 'center_empty']
+export const COLOR_MODES = ['flat', 'monochrome', 'duotone', 'full_color']
+
+/**
+ * Augments the user's prompt with specialized UI design directives and negative space constraints.
+ */
+export function buildUiAssetPrompt({
+  prompt,
+  asset_type = 'icon',
+  layout_composition = 'isolated',
+  color_mode = 'flat',
+}) {
+  const typeMap = {
+    icon: 'crisp minimalist app icon, vector iconographic style, sharp contours, modern UI asset',
+    illustration: 'digital editorial tech illustration, modern flat vector scene, web app asset',
+    badge: 'gamified badge emblem, achievement icon, metallic and enamel accents, clean vector badge',
+    sticker: 'die-cut vector sticker graphic, bold clean outlines, crisp edges, sticker asset',
+    hero_banner: 'marketing website hero illustration, modern corporate SaaS graphic',
+  }
+
+  const layoutMap = {
+    isolated: 'centered single subject, solid plain white background, generous empty padding on all sides, clean isolation',
+    left_empty: 'subject placed strictly on the right half, left 60% entirely empty negative space copy space for headlines and UI text with plain flat background',
+    right_empty: 'subject placed strictly on the left half, right 60% entirely empty negative space copy space for headlines and UI text with plain flat background',
+    top_empty: 'subject anchored at bottom edge, upper 60% completely empty negative space copy space for banner typography',
+    center_empty: 'composition framed around outer borders and corners, center area completely empty negative space for search bar or central logo',
+  }
+
+  const colorMap = {
+    flat: 'flat vector colors, clean solid fills, no photorealism, no noisy textures',
+    monochrome: 'monochromatic single-color palette, high contrast minimal style',
+    duotone: 'two-tone duotone aesthetic, sharp complementary contrast',
+    full_color: 'vibrant modern UI color scheme, harmonious hex accents',
+  }
+
+  const baseType = typeMap[asset_type] || typeMap.icon
+  const layout = layoutMap[layout_composition] || layoutMap.isolated
+  const color = colorMap[color_mode] || colorMap.flat
+
+  return `${String(prompt || '').trim()}, ${baseType}, ${layout}, ${color}`
+}

package/lib/updater.js

@@ -4,6 +4,7 @@ import { readFile } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { basename, dirname, isAbsolute, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { isLoopbackAddress, isPrivateLanAddress, extractHostName } from './security.js'
 
 /**
  * Host-side one-click updater for @goodandready/dsh-image-gen.
@@ -21,31 +22,17 @@ function header(request, name) {
 }
 
 function isLoopback(value) {
-  const address = value?.toLowerCase().replace(/^\[|\]$/g, '')
-  return (
-    address === 'localhost' ||
-    address === 'localhost.' ||
-    address === '::1' ||
-    address?.startsWith('127.') === true ||
-    address?.startsWith('::ffff:127.') === true
-  )
+  return isLoopbackAddress(value)
 }
 
 function isPrivateLan(value) {
-  const address = value?.toLowerCase().replace(/^\[|\]$/g, '')
-  if (!address) return false
-  const ipv4 = address.startsWith('::ffff:') ? address.slice(7) : address
-  return (
-    ipv4.startsWith('192.168.') ||
-    ipv4.startsWith('10.') ||
-    /^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(ipv4)
-  )
+  return isPrivateLanAddress(value)
 }
 
 export function isTrustedUpdateRequest(request) {
   if (header(request, UPDATE_HEADER) !== '1') return false
   const remote = request.socket?.remoteAddress
-  if (!isLoopback(remote) && !isPrivateLan(remote)) return false
+  if (!isLoopbackAddress(remote) && !isPrivateLanAddress(remote)) return false
   const site = header(request, 'sec-fetch-site')
   if (site !== undefined && site !== 'same-origin') return false
   const origin = header(request, 'origin')
@@ -53,10 +40,13 @@ export function isTrustedUpdateRequest(request) {
   if (origin === undefined || host === undefined) return false
   try {
     const url = new URL(origin)
+    const originHostName = extractHostName(url.host)
+    const hostName = extractHostName(host)
     return (
       (url.protocol === 'http:' || url.protocol === 'https:') &&
-      (isLoopback(url.hostname) || isPrivateLan(url.hostname)) &&
-      url.host === host
+      (isLoopbackAddress(originHostName) || isPrivateLanAddress(originHostName)) &&
+      (isLoopbackAddress(hostName) || isPrivateLanAddress(hostName)) &&
+      url.host.toLowerCase() === host.toLowerCase()
     )
   } catch {
     return false

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@goodandready/dsh-image-gen",
-  "version": "0.10.30",
-  "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).",
+  "version": "0.10.32",
+  "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",
     "dsh",