InferenceOutputError: Invalid inference output: Expected Blob. Use the 'request' method with the same parameters to do a custom call with no type checking. about huggingface.js HOT 6 CLOSED

import { NextResponse } from "next/server";
import { HfInference } from "@huggingface/inference";

const HF_ACCESS_TOKEN = "hf_<my token>";

export async function GET(request: NextRequest) {
  const prompt = request.nextUrl.searchParams.get("prompt");
  const hf = new HfInference(HF_ACCESS_TOKEN);
  const result = await hf.textToImage({
    inputs: prompt,
    model: "stabilityai/stable-diffusion-2",
    parameters: {
      negative_prompt: "blurry",
    },
  });
  return new Response(result, { headers: { "content-type": "image/jpeg" } });
}

//src/app/api/creation/route.ts

import { NextResponse } from "next/server";
import { streamToBuffer } from "./utils";

// Define the URL and access token for the external API
const API_URL =
  "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-2";

const HF_ACCESS_TOKEN = `Bearer ${process.env.HF_ACCESS_TOKEN}`;

// Define the payload type for POST requests
interface PostRequestPayload {
  prompt: string;
}

/**
 * Handle POST requests.
 * @param request - The incoming Request object.
 * @returns A NextResponse object containing the external API's response.
 */
export async function POST(request: Request): Promise<NextResponse> {
  // Parse the incoming request payload

  try {
    const { prompt }: PostRequestPayload = await request.json();

    // Fetch data from the external API
    const externalResponse = await fetch(API_URL, {
      headers: {
        Authorization: HF_ACCESS_TOKEN,
      },
      method: "POST",
      body: JSON.stringify({
        inputs: prompt,
        parameters: {
          negative_prompt: "ugly, disfigured, deformed",
        },
      }),
    });

    // Read the body of the external response as a blob
    const blob = await externalResponse.blob();

    // Convert the blob to a Buffer
    const bufferData = await streamToBuffer(blob.stream());

    // Create a new NextResponse object with the relevant properties from the external response
    const response = new NextResponse(bufferData, {
      status: externalResponse.status,
      statusText: externalResponse.statusText,
      headers: Object.fromEntries(externalResponse.headers),
    });

    return response;
  } catch (error) {
    console.error(error);
    return new NextResponse("Internal server error", { status: 500 });
  }
}

//src/app/api/creation/utils.ts

/**
 * Convert a ReadableStream to a Buffer.
 * @param readableStream - The ReadableStream to convert.
 * @returns A Buffer containing the stream's data.
 */
export async function streamToBuffer(
  readableStream: ReadableStream<Uint8Array>
): Promise<Buffer> {
  const chunks: Uint8Array[] = [];
  const reader = readableStream.getReader();

  let done = false;
  let value: Uint8Array | undefined;

  while (!done) {
    ({ done, value } = await reader.read());
    if (value) {
      chunks.push(value);
    }
  }

  return Buffer.concat(chunks);
}

  const result = await hf.request({
    inputs: prompt,
    model: "stabilityai/stable-diffusion-2",
    parameters: {
      negative_prompt: "blurry",
    },
  });