Image Generation¶

const result = await spindle.imageGen.generate({
  prompt: 'A serene mountain landscape at sunset, anime style',
  connection_id: 'optional-connection-id',
})
// result: { imageDataUrl: "data:image/png;base64,...", model: "...", provider: "..." }

const result = await spindle.imageGen.generate({
  prompt: '1girl, fantasy armor, detailed background',
  connection_id: 'my-novelai-connection',
  model: 'nai-diffusion-4-5-full',
  parameters: {
    resolution: '1024x1024',
    steps: 35,
    guidance: 7,
    sampler: 'k_euler_ancestral',
  },
})

const result = await spindle.imageGen.generate({
  prompt: 'A futuristic cityscape',
  parameters: {
    rawRequestOverride: JSON.stringify({
      generationConfig: {
        imageGenerationConfig: { aspectRatio: '21:9' },
      },
    }),
  },
})

let latestPreview: string | undefined

const stream = spindle.imageGen.generateStream({
  connection_id: 'my-swarmui-connection',
  prompt: 'An art-deco observatory under a meteor shower',
  parameters: { steps: 30 },
})

for await (const event of stream) {
  switch (event.type) {
    case 'status':
      // SwarmUI reports percentage-derived progress; ComfyUI may report
      // execution nodes instead of numerical steps.
      spindle.log.info(
        `Progress: ${event.step ?? '?'} / ${event.totalSteps ?? '?'} ` +
        `(node: ${event.nodeId ?? 'n/a'})`,
      )
      break

    case 'preview':
      // A data URL such as data:image/png;base64,...
      // Forward it to your frontend or replace the previous preview in memory.
      latestPreview = event.imageDataUrl
      spindle.sendToFrontend({ type: 'image-preview', imageDataUrl: latestPreview })
      break

    case 'done':
      // Same shape as the result from spindle.imageGen.generate().
      spindle.log.info(`Saved generated image: ${event.result.imageId ?? 'not persisted'}`)
      break
  }
}

const connection = await spindle.imageGen.getConnection('image-connection-id')
if (!connection) throw new Error('Image connection not found')

const providers = await spindle.imageGen.getProviders()
const provider = providers.find((item) => item.id === connection.provider)

if (provider?.capabilities.websocketPreviewStreaming) {
  for await (const event of spindle.imageGen.generateStream({
    connection_id: connection.id,
    prompt: 'A soft watercolor map of a floating city',
  })) {
    if (event.type === 'preview') {
      spindle.sendToFrontend({ type: 'image-preview', imageDataUrl: event.imageDataUrl })
    }
  }
} else {
  const result = await spindle.imageGen.generate({
    connection_id: connection.id,
    prompt: 'A soft watercolor map of a floating city',
  })
  spindle.sendToFrontend({ type: 'image-complete', imageDataUrl: result.imageDataUrl })
}

const controller = new AbortController()
const stream = spindle.imageGen.generateStream({
  prompt: 'A neon-lit forest path',
  signal: controller.signal,
})

setTimeout(() => controller.abort(), 10_000)

try {
  for await (const event of stream) {
    if (event.type === 'preview') {
      spindle.sendToFrontend({ type: 'image-preview', imageDataUrl: event.imageDataUrl })
    }
  }
} catch (err) {
  if (err instanceof DOMException && err.name === 'AbortError') {
    spindle.log.info('Image generation cancelled')
  } else {
    throw err
  }
}

const result = await spindle.imageGen.generate({
  prompt: 'Character portrait for the current scene',
  owner_character_id: 'char-id',
  owner_chat_id: 'chat-id',
})

const relatedImages = await spindle.images.list({
  onlyOwned: true,
  characterId: 'char-id',
  specificity: 'sm',
})

const result = await spindle.imageGen.generate({
  prompt: 'A cozy campfire scene at night',
})

if (result.imageUrl) {
  await spindle.push.send({
    title: 'Scene Generated',
    body: 'A new background image is ready',
    image: result.imageUrl,
  })
}

const thumbUrl = `${result.imageUrl}?size=sm`  // ~300px thumbnail

const providers = await spindle.imageGen.getProviders()

for (const provider of providers) {
  spindle.log.info(`${provider.name} (${provider.id})`)
  spindle.log.info(`  Models: ${provider.capabilities.staticModels?.map(m => m.label).join(', ')}`)
  spindle.log.info(`  Parameters: ${Object.keys(provider.capabilities.parameters).join(', ')}`)
}

const connections = await spindle.imageGen.listConnections()

for (const conn of connections) {
  spindle.log.info(`${conn.name} (${conn.provider}) — model: ${conn.model}`)
}

const conn = await spindle.imageGen.getConnection('connection-id')
if (conn) {
  spindle.log.info(`Using ${conn.name} with model ${conn.model}`)
}

const models = await spindle.imageGen.getModels('connection-id')

for (const model of models) {
  spindle.log.info(`${model.id}: ${model.label}`)
}