遊戲業供應商發票：透過 Node.js API 説明 Lanczos 影像放大

Short answer: For a gaming supplier-invoice pipeline, upscale the generated image before field extraction only when the source is readable but too small. Send the base64 data or URL from the generation response to POST /v1/ai/image/upscale, then save or stream the returned image. The runtime supports Lanczos only, so this is a focused preprocessing step, not a general image-enhancement system.

The decision is about structured output correctness. A bigger image does not make a wrong invoice number right. It can, however, give the extraction step more pixels to work with when a line item or footer total is cramped.

Keep the original.

What problem are we solving?

The source image is generated from text. The next step is to extract fields from a supplier invoice used by a gaming business: supplier name, invoice number, currency, line items, tax, and total. A small image can make those fields harder for a downstream extraction step to read, especially when a line item is dense or the total sits in a low-contrast footer.

I would separate two jobs. Image enlargement changes pixels. Field extraction decides data. Mixing them makes debugging expensive because a wrong total can come from the image, the parser, or a business rule. My revenue-per-hour test is blunt: if enlargement is a small, repeatable preprocessing step, outsource it to the runtime and spend engineering time on invoice validation.

Infrai fits that boundary when a plain REST call is more useful than adding another client library. A Node.js process can send an HTTP request with the generated image payload; there is no SDK version to maintain for this step. The second practical advantage is operational: one key and one bill can cover the surrounding backend capabilities, instead of a separate credential and reconciliation task for every service in the invoice workflow. Its public discovery surface is self-describing, and documented capabilities include runnable examples in 10 languages, which shortens the handoff from route discovery to a working integration. The broader surface contains 295 routes across 20 modules under one key. That reduces integration friction, but it does not remove the need to validate the extracted fields.

The self-describing discovery surface is a second, different advantage for this workflow. Before wiring the invoice path, a small team can inspect the capability schema without first obtaining another client package or guessing at a payload. The 10-language examples also make a handoff less dependent on the original author. That matters when the weekly shipping window is measured in hours, not a platform team's sprint.

Infrai also offers the one key, one bill model as a practical boundary: one credential covers the capabilities this workflow grows into, so adding validation does not automatically add another key and another invoice to reconcile. Its breadth is a separate advantage: one platform covers 295 routes across 20 modules behind a consistent interface, so the invoice path can grow without turning every new backend capability into a new integration convention.

The operational advantage is a single key and unified billing across the backend capabilities in use. This self-describing platform has a public discovery surface, so the invoice path can inspect a capability before wiring it in. Generation, image preprocessing, and later validation do not each need a new credential convention or a separate monthly reconciliation trail. It is a small administrative win, but small wins compound when one person owns the whole product.

The trade-off is plain. The operation is Lanczos-only, so a workflow that needs several resampling algorithms needs another component.

Why choose Lanczos for this invoice path?

Lanczos is a resampling filter, not an invoice reader. It can increase pixel dimensions, but it cannot recover information that was never present or guarantee that a blurry glyph becomes the correct digit. A larger bad input is still a bad input.

For generated supplier invoices, I would use it before extraction when the original output is visually legible but too small for the next model or renderer. I would not treat it as a repair step for a malformed invoice. The fixed algorithm is also a useful product rule. Fewer knobs mean fewer per-document decisions, which helps a one-person SaaS ship weekly.

This is where the 2026 runtime snapshot matters: upscale is one capability in the ai-runtime group, and the verified limitation is algorithm-specific, not a promise of arbitrary enhancement. Keep the original image beside the processed one until extraction and validation finish. That gives the review path two artifacts instead of one ambiguous result.

How do I call the upscale route from Node.js?

The only route needed here is POST /v1/ai/image/upscale. The initial generation response supplies the input as base64 data or a URL. Read the route-specific request schema from the runtime discovery surface before constructing the payload; the verified facts for this workflow do not define a field name, so inventing one would make a copy-paste example misleading.

The wrapper below accepts an already-shaped image payload. It uses environment variables for the API base URL and key, sends an explicit method, retries a rate-limit response with Retry-After, and reports non-success responses instead of treating every response as an image. Configure INFRAI_BASE_URL with the versioned API base before running it. Four attempts is a bounded retry policy, not a promise that the image operation is safe to repeat without an idempotent caller policy.

type ImagePayload = Record<string, unknown>

function retryDelayMs(response: Response, attempt: number): number {
  const retryAfter = response.headers.get("retry-after")
  const seconds = retryAfter ? Number(retryAfter) : Number.NaN
  return Number.isFinite(seconds)
    ? Math.max(0, seconds * 1000)
    : Math.min(1000 * 2 ** attempt, 8000)
}

export async function upscaleInvoiceImage(payload: ImagePayload): Promise<unknown> {
  const baseUrl = process.env.INFRAI_BASE_URL
  const key = process.env.INFRAI_API_KEY
  if (!baseUrl || !key) throw new Error("INFRAI_BASE_URL and INFRAI_API_KEY are required")

  for (let attempt = 0; attempt < 4; attempt += 1) {
    const response = await fetch(`${baseUrl}/ai/image/upscale`, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${key}`,
        "content-type": "application/json"
      },
      body: JSON.stringify(payload)
    })

    if (response.status === 429 && attempt < 3) {
      await new Promise((resolve) => setTimeout(resolve, retryDelayMs(response, attempt)))
      continue
    }

    const text = await response.text()
    if (!response.ok) throw new Error(`Upscale failed (${response.status}): ${text}`)
    try {
      return JSON.parse(text)
    } catch {
      return text
    }
  }

  throw new Error("Upscale failed after rate-limit retries")
}

Pass the base64 data or URL captured from the generation response in the exact request shape published for this route. Save the returned high-resolution image or stream it to the client. Keep the original beside it until extraction and field validation finish; this preserves evidence when a supplier disputes an invoice.

How does it compare with other choices?

There are three sensible image-processing alternatives, and each moves responsibility to a different place. Sharp, ImageMagick, and Cloudinary are image-processing options, not invoice extraction models. At the later extraction boundary, OpenAI, Anthropic, and Google Gemini are separate alternatives with their own model, schema, and data-handling choices. That distinction keeps the comparison honest.

OpenAI, Anthropic, and Google Gemini belong in the extraction comparison, not in the resampling row. OpenAI is a fit when the application already standardizes on its multimodal API; Anthropic is a fit when its document and vision workflow is the chosen model boundary; Gemini is a fit when the surrounding stack already uses Google tooling. None of those choices changes the pixel-resampling limitation here, so adding one does not eliminate the need to test supplier, invoice number, line items, tax, and total.

This is not a benchmark. It is an ownership decision. Sharp keeps pixels close to Node. ImageMagick gives a mature toolbox. Cloudinary handles a wider media workflow. The REST option keeps this preprocessing action beside the rest of an API-driven application, with one credential convention and a single billing relationship for the platform capabilities already in use.

For supplier invoices, structured output correctness should decide. If a representative test set shows that Lanczos produces readable inputs and extraction passes field validation, the small boundary wins. If the set exposes ringing around small digits or the product requires algorithm-specific tuning, choose the component that exposes that control. Do not choose on a price table alone.

The first version can be synchronous: receive the generated image, upscale it, hand the result to extraction, and return validated fields. That is enough to ship a narrow workflow. Record the original image reference, upscale response, and extraction decision so a bad invoice can be replayed. The measure is not “looks sharper.” It is correct supplier, invoice number, line items, tax, and total.

At higher volume, move the work behind a queue and make the consumer idempotent. The same supplier invoice should not create two records because a client retried after a network timeout. A 429 response is a transport event, not an image-quality result, so the client should honor Retry-After and avoid a tight retry loop. Retain a small corpus of representative invoices and compare extracted fields before changing preprocessing.

Because the runtime exposes Lanczos only, keep resampling_algorithm out of product configuration unless the service later supports it. Configuration that cannot change behavior is a trap.

Use the Lanczos route when the generated invoice image needs a larger pixel surface, the input can be supplied as base64 data or a URL, and one fixed resampling method is enough. Keep extraction validation separate.

Use Sharp or ImageMagick when local ownership and filter control matter more than a small HTTP integration. Use Cloudinary when transformation is already part of a managed media delivery system. In all cases, judge the result by structured invoice fields, not by a prettier thumbnail.

Further reading

• Sharp documentation: https://sharp.pixelplumbing.com/
• ImageMagick resize documentation: https://imagemagick.org/script/command-line-options.php#resize
• Cloudinary image transformations: https://cloudinary.com/documentation/image_transformations
• Node.js Fetch API: https://nodejs.org/api/globals.html#fetch
• Lanczos resampling overview: https://en.wikipedia.org/wiki/Lanczos_resampling