v3 to v4 Migration Guide

[rattrayalex]

v4 is a complete rewrite of the SDK. To see what's new, see the release notes.

Installation

First, update your package.json to specify v4:

  "openai": "^4.0.0"

and run npm install or equivalent to download the new version.

Automatic migration

You can automatically migrate your codebase using grit, either online or with the following CLI command:

npm exec openai migrate

The grit binary executes entirely locally with AST-based transforms.

Be sure to audit its changes: we suggest ensuring you have a clean working tree beforehand, and running git add --patch afterwards. Note that grit.io also offers opt-in automatic fixes powered by AI.

Manual migration

There are changes in the initialization logic, method names, error handling. The API parameter names should be unchanged.

Initialization

// Old
import { Configuration, OpenAIApi } from "openai";

const configuration = new Configuration({
  apiKey: process.env.OPENAI_API_KEY,
});
const openai = new OpenAIApi(configuration);

// New
import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY // This is also the default, can be omitted
});

Creating a chat completion

// Old
const chatCompletion = await openai.createChatCompletion({
  model: "gpt-3.5-turbo",
  messages: [{role: "user", content: "Hello world"}],
});
console.log(chatCompletion.data.choices[0].message);

// New
const chatCompletion = await openai.chat.completions.create({
  model: "gpt-3.5-turbo",
  messages: [{"role": "user", "content": "Hello!"}],
});
console.log(chatCompletion.choices[0].message);

Creating a streaming chat completion (new)

// Old
// Not supported

// New
const stream = await openai.chat.completions.create({
  model: "gpt-3.5-turbo",
  messages: [{"role": "user", "content": "Hello!"}],
  stream: true,
});
for await (const part of stream) {
  console.log(part.choices[0].delta);
}

Creating a completion

// Old
const completion = await openai.createCompletion({
  model: "text-davinci-003",
  prompt: "This story begins",
  max_tokens: 30,
});
console.log(completion.data.choices[0].text);

// New
const completion = await openai.completions.create({
  model: "text-davinci-003",
  prompt: "This story begins",
  max_tokens: 30,
});
console.log(completion.choices[0].text);

Creating a transcription (whisper)

// Old
const response = await openai.createTranscription(
  fs.createReadStream("audio.mp3"),
  "whisper-1"
);

// New
const response = await openai.audio.transcriptions.create({
  model: 'whisper-1',
  file: fs.createReadStream('audio.mp3'),
});

Creating a streaming completion (new)

// Old
// Not supported

// New
const stream = await openai.completions.create({
  model: "text-davinci-003",
  prompt: "This story begins",
  max_tokens: 30,
  stream: true,
});
for await (const part of stream) {
  console.log(part.choices[0]);
}

Error handling

// Old
try {
  const completion = await openai.createCompletion({...});
} catch (error) {
  if (error.response) {
    console.log(error.response.status); // e.g. 401
    console.log(error.response.data.message); // e.g. The authentication token you passed was invalid...
    console.log(error.response.data.code); // e.g. 'invalid_api_key'
    console.log(error.response.data.type); // e.g. 'invalid_request_error'
  } else {
    console.log(error);
  }
}

// New
try {
  const response = await openai.completions.create({...});
} catch (error) {
  if (error instanceof OpenAI.APIError) {
    console.error(error.status);  // e.g. 401
    console.error(error.message); // e.g. The authentication token you passed was invalid...
    console.error(error.code);  // e.g. 'invalid_api_key'
    console.error(error.type);  // e.g. 'invalid_request_error'
  } else {
    // Non-API error
    console.log(error);
  }
}

Headers

// Old
const response = openai.createChatCompletion(params)
response.headers['x-ratelimit-remaining-tokens']
response.data.id

// New
const { data, response } = openai.chat.completions.create(params).withResponse()
response.headers.get('x-ratelimit-remaining-tokens')
data.id

All method name changes

To migrate these automatically, see Automatic migration, above

• createFineTune -> fineTunes.create

• cancelFineTune -> fineTunes.cancel

• retrieveFineTune -> fineTunes.retrieve

• listFineTunes -> fineTunes.list

• listFineTuneEvents -> fineTunes.listEvents

• createFile -> files.create

• deleteFile -> files.del

• retrieveFile -> files.retrieve

• downloadFile -> files.retrieveContent

• listFiles -> files.list

• deleteModel -> models.del

• listModels -> models.list

• retrieveModel -> models.retrieve

• createImage -> images.generate

• createImageEdit -> images.edit

• createImageVariation -> images.createVariation

• createChatCompletion -> chat.completions.create

• createCompletion -> completions.create

• createTranscription -> audio.transcriptions.create

• createTranslation -> audio.translations.create

• createEdit -> edits.create

• createEmbedding -> embeddings.create

• createModeration -> moderations.create

Removed:

• createAnswer()
• createClassification()
• createSearch()
• listEngines()
• retrieveEngine()

[danielsinewe]

It would be great if you could also update it in the playground.

[rattrayalex]

Thanks for reporting, we'll try to do that soon!

[kaigenji]

seconding this, i was banging my head on errors for hours until I found the update.

[schnerd]

This should be fixed now – thank you for reporting!

[woutersteven]

It would be great if an example could be added for Image generation. Though there is a guide at the bottom that lists the new functions. Some interfaces aren't listed, such as: "CreateImageRequestSizeEnum".

[PeterKeyse]

Just tried npm exec openai migrate. It returned: '"bash"' is not recognized as an internal or external command,
operable program or batch file.

[RobertCraigie]

@PeterKeyse Ah sorry about that, currently only systems with bash available are supported by the CLI.

While we improve support for other platforms you should be able to run this command instead:

npx -y @getgrit/launcher apply openai_v4

[rattrayalex]

@PeterKeyse does it work if you use WSL?

[PeterKeyse]

Unable to help with that, Alex @rattrayalex, as WSL means nothing to me.

[RobertCraigie]

@PeterKeyse He was referencing Windows Subsystem for Linux, https://learn.microsoft.com/en-us/windows/wsl/install.

[airstrike]

Thanks for this. A banner with a note on the release of v4.0.0 out of beta at the top of https://platform.openai.com/docs/api-reference would go a long way

[foxalabs]

https://chat.openai.com/share/b175130a-0d77-465e-8187-59b92590df8b

I put the main migration text body in a ChatGPT-4 chat for querying, handy to run issues past for a quick check.

[shuv1337]

Any information on using this SDK with the Azure OpenAI service? How do we set api_type, api_base, and api_version in the 4.0 SDK?

[rattrayalex]

Here's an example: https://github.com/openai/openai-node/blob/master/examples/azure.ts but we should add that to the README…

[1dolinski]

Hey -- really awesome to see this migration, we have to update a few things on our side but the streaming functionality is welcome.

Please provide a migration guide for functions.

[rattrayalex]

Can you provide a "before" snippet that you need help migrating, for context?

[1dolinski]

previously I leaned on this snippet from @JohannLai

import { Configuration, OpenAIApi } from "openai";

const configuration = new Configuration({
  apiKey: process.env.OPENAI_API_KEY,
});
const openai = new OpenAIApi(configuration);

const QUESTION = "现在几点？";

const messages = [
  {
    role: "user",
    content: QUESTION,
  },
];

const functions = {
  getCurrentTime: function () {
    var date = new Date();
    var hours = date.getHours();
    var minutes = date.getMinutes();

    var time = hours + ":" + minutes;

    return time;
  },
};

const getCompletion = async (messages) => {
  const response = await openai.createChatCompletion({
    model: "gpt-3.5-turbo-0613",
    messages,
    functions: [
      {
        name: "getCurrentTime",
        description: "Get the current time",
        parameters: {
          type: "object",
          properties: {},
        },
      },
    ],
    temperature: 0,
  });

  return response;
};

let response = await getCompletion(messages);

if (response.data.choices[0].finish_reason === "function_call") {
  const fnName = response.data.choices[0].message.function_call.name;
  const args = response.data.choices[0].message.function_call.arguments;

  console.log("Function call: " + fnName);
  console.log("Arguments: " + args);

  const fn = functions[fnName];
  const result = fn(...Object.values(args));

  console.log("Calling Function Result: " + result);

  messages.push({
    role: "assistant",
    content: null,
    function_call: {
      name: fnName,
      arguments: args,
    },
  });

  messages.push({
    role: "function",
    name: fnName,
    content: JSON.stringify({ result: result }),
  });

  response = await getCompletion(messages);

  console.log(response.data.choices[0].message.content);
}

[rattrayalex]

If you run our automated migration script or follow the manual migration guide above on that code, it should work just fine. Let me know if you run into any issues.

[jiapei100]

// New
const chatCompletion = await openai.chat.completions.create({
  model: "gpt-3.5-turbo",
  messages: [{"role": "user", "content": "Hello!"}],
});
console.log(chatCompletion.choices[0].message);

This new snippet brought me the following error messages:
I wonder if Creating a chat completion is NOT there any more?
Do I MUST use Creating a streaming chat completion (new) instead?

Property 'choices' does not exist on type 'Stream<ChatCompletionChunk> | ChatCompletion'.
  Property 'choices' does not exist on type 'Stream<ChatCompletionChunk>'.ts(2339)

[jiapei100]

Thank you so much @rattrayalex

And, what about ChatCompletionRequestMessage? Where is that for new version?

I used to have

const userMessage: ChatCompletionRequestMessage = {
        role: "user",
        content: values.prompt,
      };

But how do I modify the above part in openai-4.0.1??

[foxalabs]

From the migration guide:

const chatCompletion = await openai.chat.completions.create({
  model: "gpt-3.5-turbo",
  messages: [{"role": "user", "content": "Hello!"}],
});

To modify your code to fit with the new version (openai-4.0), you can do the following:

const userMessage = {
    role: "user",
    content: values.prompt,
};

// Later in your code
const chatCompletion = await openai.chat.completions.create({
    model: "gpt-3.5-turbo",
    messages: [userMessage],
});

You can use the link in this post #217 (comment) to chat with ChatGPT-4 about your code, it has the migration information already entered so you can just post your query or code and it will tell you what to do next, seems to work pretty well.

[mithilproof]

not working :(
i am having same trouble with ChatCompletionRequestMessage

[rattrayalex]

I believe you want

const userMessage: OpenAI.Chat.ChatCompletionMessage = {…}

[kevinkhill]

Thank you @rattrayalex, I was looking for how to solve this type error :)

[1dolinski]

@rattrayalex btw, thanks for the clear docs and rewrite, appreciate it

[jiapei100]

From the migration guide:

const chatCompletion = await openai.chat.completions.create({
  model: "gpt-3.5-turbo",
  messages: [{"role": "user", "content": "Hello!"}],
});

To modify your code to fit with the new version (openai-4.0), you can do the following:

const userMessage = {
    role: "user",
    content: values.prompt,
};

// Later in your code
const chatCompletion = await openai.chat.completions.create({
    model: "gpt-3.5-turbo",
    messages: [userMessage],
});

You can use the link in this post #217 (comment) to chat with ChatGPT-4 about your code, it has the migration information already entered so you can just post your query or code and it will tell you what to do next, seems to work pretty well.

Fantastic... Working here... But, I can still retrieve the data from model gpt-3.5-turbo, rather than gpt-4. Do I still have to wait until the invitation for using gpt-4?? So sad... I already purchased chatgpt-plus...

How am I able to try out gpt-4?

[schnerd]

You can learn more about how to access GPT-4 from this help article:
https://help.openai.com/en/articles/7102672-how-can-i-access-gpt-4

[rokbenko]

I have two questions:

1. Is there a typo in retrieveModel -> models.del? Should it be retrieveModel -> models.retrieve?

2. In the API documentation, it shows that Create edit is deprecated. Why is createEdit not under Removed?

[rattrayalex]

1. Yes, that was a typo – fixed! Thanks for raising it.
2. We chose to keep edits.create in the SDK for now, but marked as deprecated. It'll be removed in a future release.

[pixelasticity]

How can I convert CreateChatCompletionRequestMessage from v3 to v4?

        const newMessage: OpenAI.Chat.CreateChatCompletionRequestMessage = {
            role: 'user',
            content,
        }

[pixelasticity]

I get this error: Argument of type 'CreateChatCompletionRequestMessage[]' is not assignable to parameter of type 'OpenAI[]'.

[RobertCraigie]

Can you share a full code snippet? We don't define a OpenAI[] type anywhere so I suspect this is an issue with the typing in your source code.

[pixelasticity]

It's very likely that I just did something wrong. I was hoping it was a v3 to v4 issue so that it would be easier to fix. I apologize in advance if this ends up being the wrong place for this thread.

useMessages.tsx

import OpenAI from "openai";
import {
    ReactNode,
    createContext,
    useContext,
    useEffect,
    useState,
} from 'react';
import { sendMessage } from "./sendMessage";

interface ContextProps {
    messages: OpenAI.Chat.CreateChatCompletionRequestMessage[]
    addMessage: (content: string) => Promise<void>
    isLoadingAnswer: boolean
}

const ChatsContext = createContext<Partial<ContextProps>>({})

export function MessagesProvider({ children }: { children: ReactNode }) {
    const { addToast } = useToast()
    const [messages, setMessages] = useState<OpenAI.Chat.CreateChatCompletionRequestMessage[]>([])
    const [isLoadingAnswer, setIsLoadingAnswer] = useState(false)

    useEffect(() => {
        const initializeChat = () => {
            const systemMessage: OpenAI.Chat.CreateChatCompletionRequestMessage = {
                role: 'system',
                content: 'You are a helpful assistant.',
            }
            const welcomeMessage: OpenAI.Chat.CreateChatCompletionRequestMessage = {
                role: 'assistant',
                content: 'Hey there! How can I help you?',
            }
            setMessages([systemMessage, welcomeMessage])
        }

        if (!messages?.length) {
            initializeChat()
        }
    }, [messages?.length, setMessages])

    const addMessage = async (content: string) => {
        setIsLoadingAnswer(true)
        try {
            const newMessage: OpenAI.Chat.CreateChatCompletionRequestMessage = {
                role: 'user',
                content,
            }
            const newMessages = [...messages, newMessage]

            setMessages(newMessages)

            const { data } = await sendMessage(newMessages)
            const reply = data.choices[0].message

            setMessages([...newMessages, reply])
        } catch (error) {
            // Show error when something goes wrong
            if (error instanceof OpenAI.APIError) {
                console.error(error.status);  // e.g. 401
                console.error(error.message); // e.g. The authentication token you passed was invalid...
                console.error(error.code);  // e.g. 'invalid_api_key'
                console.error(error.type);  // e.g. 'invalid_request_error'
              } else {
                // Non-API error
                console.log(error);
              }
        } finally {
            setIsLoadingAnswer(false)
        }
    }

    return (
        <ChatsContext.Provider value={{ messages, addMessage, isLoadingAnswer }}>
            {children}
        </ChatsContext.Provider>
    )
}

export const useMessages = () => {
    return useContext(ChatsContext) as ContextProps
}

sendMessage.tsx

import ChatCompletionRequestMessage from 'openai'

export const sendMessage = async (messages: ChatCompletionRequestMessage[]) => {
    try {
        const response = await fetch('/api/createMessage', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify({ messages }),
        })

        return await response.json()
    } catch (error) {
        console.log(error)
    }
}

[rattrayalex]

import ChatCompletionRequestMessage from 'openai' is not correct:

- import ChatCompletionRequestMessage from 'openai'
+ import OpenAI from 'openai'

- export const sendMessage = async (messages: ChatCompletionRequestMessage[]) => {
+ export const sendMessage = async (messages: OpenAI.Chat.ChatCompletionRequestMessage[]) => {

[pixelasticity]

Thank you so much! I am now error free 🥇

[imsamimalik]

I have been trying to create an Express API endpoint that returns a response from the Open AI package in streaming format to be consumed by React on the front end. But all the resources are deprecated. Any help on how do I create such an endpoint?

[rattrayalex]

But all the resources are deprecated

Sorry, what do you mean?

We're working on a built-in helpers for this, but in the meantime, you may search for "ReadableStream" in this thread or try the ai package from Vercel.

[imsamimalik]

Sorry, what do you mean?

I was trying to create an Express JS REST streaming API but all the resources(articles, guides, videos) were outdated(they were all using v3).

But by this guide and a little bit of help from ChatGPT, I managed to get it to work.

[rattrayalex]

Ah, great to hear! I hope you've been able to report to the authors of those articles, guides, and videos that they should update their versions if possible.

[imsamimalik]

There are so many but I surely will do.

[Darshan2923]

Hey, I was doing the manual migration same as the above code snippet, I am in the version "^4.2.0" now and am getting this error---->
import { Configuration } from 'openai';
^^^^^^^^^^^^^
SyntaxError: The requested module 'openai' does not provide an export named 'Configuration'

[RobertCraigie]

The Configuration class has been removed, please see this snippet:

// Old
import { Configuration, OpenAIApi } from "openai";

const configuration = new Configuration({
  apiKey: process.env.OPENAI_API_KEY,
});
const openai = new OpenAIApi(configuration);

// New
import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY // This is also the default, can be omitted
});

[Darshan2923]

Thanks. My Bad!!!!

[Stroller15]

Can anyone please help me out to how to remove this errors

[RobertCraigie]

What version are you on? Can you also share the full error message please.

[Stroller15]

^4.3.0

[rattrayalex]

@Stroller15 to unblock yourself here for now, you can do this:

import OpenAI from 'openai';

useState<OpenAI.Chat.CreateChatCompletionRequestMessage[]>()

However, I'm quite curious why TS is saying it cannot find that module. Can you share your package.json and tsconfig.json?

[valpioner]

Hi @Stroller15 , I also faced this error, and somehow was able to resolve it, don't remember exactly what caused it, but try to play with tsconfig settings

[rattrayalex]

@valpioner do you have a diff of your tsconfig from before the migration to openai v4 and after?

[lslzl3000]

how to get usage from new stream completions?

[rattrayalex]

The API does not offer this functionality at this time; for other questions about the API, see community.openapi.com

[wyuchen1217]

import OpenAI from "openai"; // Updated import for OpenAI
import { auth } from "@clerk/nextjs"; // Ensure this package is correctly installed
import { NextResponse } from "next/server";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY }); // Initialize OpenAI API

export async function POST(req: Request) {
try {
const { userId } = auth(); // Make sure auth is correctly imported
const body = await req.json();
const { messages } = body;

if (!userId) {
  return new NextResponse("Unauthorised", { status: 401 });
}

if (!configuration.apiKey) {
  return new NextResponse("OpenAI API Key not configured", { status: 500 });
}

if (!messages) {
  return new NextResponse("Messages are required", { status: 400 });
}

const chatCompletion = await openai.chat.completions.create({
  model: "gpt-3.5-turbo",
  messages: [{"role": "user", "content": "Hello!"}],
});

// Use chatCompletion, not response
return NextResponse.json(chatCompletion.choices[0].message);

} catch (error) {
console.log("[CONVERSATION_ERROR]", error);
return new NextResponse("internal error", { status: 500 });
}
}

Cannot find name 'configuration'.ts(2304)

[wyuchen1217]

[wyuchen1217]

[rattrayalex]

Delete these lines:

if (!configuration.apiKey) {
  return new NextResponse("OpenAI API Key not configured", { status: 500 });
}

[wyuchen1217]

"use client";

import axios from "axios";
import * as z from "zod";
import { MessageSquare } from "lucide-react";
import { useForm } from "react-hook-form";
import {zodResolver} from "@hookform/resolvers/zod";

import {Heading} from "@/components/heading";
import {Form, FormControl, FormField, FormItem} from "@/components/ui/form";

import { formSchema } from "./constants";
import { useRouter } from "next/navigation";
import OpenAI from "openai";

import { Input } from "@/components/ui/input";
import { Button } from "@/components/ui/button";
import { Island_Moments } from "next/font/google";
import { captureRejectionSymbol } from "events";
import { useState } from "react";

const ConversationPage = () => {
const router = useRouter();
const [messages, setMessages] = useState<ChatCompletionRequestMessage[]>([]);

const form = useForm<z.infer<typeof formSchema>>({
    resolver: zodResolver(formSchema),
    defaultValues: {
        prompt: ""
    }
});

const isLoading = form.formState.isSubmitting;
const onSubmit = async (values: z.infer<typeof formSchema>) => {
    try{
        const userMessage = {
            role: "user",
            content: values.prompt,
        };
        
        

        const newMessage = [...messages, userMessage];

        const response = await axios.post("/api/conversation", {
            messages: newMessage,
        });

        setMessages((current)=> [...current, userMessage, response.data]);

        form.reset();
    }catch(error){
        // TODO: Open Pro Modal
        console.log(error);
    }finally{
        router.refresh();
    }
};
return (
    <div>
        <Heading
            title="Conversation"
            description="Our most advanced conversation model."
            icon={MessageSquare}
            iconColor="text-violet-500"
            bgColor="bg-violet-500/10"
        />
        <div className="px-4 lg:px-8">
            <div>
                <Form {...form}>
                    <form
                        onSubmit={form.handleSubmit(onSubmit)}
                        className="
                        rounded-lg
                        border
                        w-full
                        p-4
                        px-3
                        md:px-6
                        focus-within:shadow-sm
                        grid
                        grid-cols-12
                        gap-2
                        "
                    >
                        <FormField 
                            name="prompt"
                            render={({ field }) => (
                                <FormItem className="col-span-12 lg:col-span-10">
                                    <FormControl className="m-0 p-0">
                                        <Input
                                            className="border-0 outline-none focus-visible:ring-0 focus-visible:ring-transparent"
                                            disabled={isLoading}
                                            placeholder="How do I calculate the radius of a circle?"
                                            {...field}
                                        />
                                    </FormControl>
                                </FormItem>
                            )}
                        />
                        <Button className="col-span-12 lg:col-span-2 w-full" disabled={isLoading}>
                            Generate
                        </Button>
                    </form>
                </Form>
            </div>
            <div className="space-y-4 mt-4">
                <div className = "flex flex-col reverse gap-y-4">
                    {messages.map((message) => (
                        <div key={message.content}>
                            {message.content}
                        </div>
                    ))}
                </div>
            </div>
        </div>
    </div>
)
};

export default ConversationPage;

Cannot find name 'ChatCompletionRequestMessage'.ts(2304)

[wyuchen1217]

[wyuchen1217]

[rattrayalex]

Please search for ChatCompletionRequestMessage elsewhere in this thread for examples of how to import this type correctly.

[Darshan2923]

dalleRoutes.js (to fetch images from openapi)

import express from 'express';
import * as dotenv from 'dotenv';
import { OpenAI } from 'openai';

import Post from '../mongodb/models/post.js';

dotenv.config();

const router = express.Router();

const openai = new OpenAI({
apiKey: process.env.OPENAI_API_KEY,
})

router.route('/').get((req, res) => {
res.send("Dall-e says 'HII'");
});

router.route('/').post(async (req, res) => {
try {
const { prompt } = req.body;

    const aiResponse = await openai.createImage({
        prompt,
        n: 1,
        size: '1024x1024',
        response_format: 'b64_json',
    });

    const image = aiResponse.data.data[0].b64_json;

    res.status(200).json({ photo: image });

} catch (error) {
    res.status(500);
    console.log('Error in getting the prompt', error);
}

})

export default router;

postRoutes.js (to post on homepage)

import express from 'express';
import * as dotenv from 'dotenv';
import { v2 as cloudinary } from 'cloudinary';

import Post from '../mongodb/models/post.js';

dotenv.config();

const router = express.Router();

cloudinary.config({
cloud_name: process.env.CLOUDINARY_NAME,
api_key: process.env.CLOUDINARY_API_KEY,
api_secret: process.env.CLOUDINARY_API_SECRET,
});

//GET ALL POSTS
router.route('/').get(async (req, res) => {
try {
const posts = await Post.find({});

    res.status(200).json({ success: true, data: posts })
} catch (error) {
    res.status(500).json({ success: false, message: error })

}

});

//CREATE A POST
router.route('/').post(async (req, res) => {
try {
const { name, prompt, photo } = req.body;
const photoUrl = await cloudinary.uploader.upload(photo);

    const newPost = await Post.create({
        name,
        prompt,
        photo: photoUrl.url,
    })

    res.status(201).json({ success: true, data: newPost });
} catch (e) {
    res.status(500).json({ success: false, message: error });
}

});

export default router;

I'm getting this error:
Error in getting the prompt TypeError: openai.createImage is not a function
at file:///E:/React_projects/DreamVerse/backend/routes/dalleRoutes.js:23:41..
Pls help!!!

[rattrayalex]

Please follow the migration guide above, or try the migration script – as the error tells you, openai.createImage is from the old SDK.