I noticed that when there is an error with Open AI API, the response from createChatCompletion looks like this:

{
  error: {
    message: "That model is currently overloaded with other requests. You can retry your request, or contact us through our help center at help.openai.com if the error persists. (Please include the request ID <redacted> in your message.)", // string
    type: "server_error", // string
    param: null, // any?
    code: null, // string | null
  },
}```

Could you please add the types for the error response to the API?

Error: invalid_request_error: This is a chat model and not supported in the v1/completions endpoint. Did you mean to use v1/chat/completions?
This is the feedback from ChatGPT 3.5 nowadays. out-of-date

I want to add custom headers on request

I noticed that the type defintion for createChatCompletionStream options doesn't accept function_call and functions unlike createChatCompletion that accepts them as options

In the function calling example, the model should be updated to gpt-3.5-turbo-0613.

Hello there. Thanks for sharing this library.

I believe the return types for the methods in this library are incorrect. For example, createCompletion is declared as returning Promise<Response>, when it's really returning a promised response.json(), which is of any type, since it's the actual response body data parsed as JSON into an object (see here).

I think, instead, it should either be declared as returning Promise<any> or return Promise<the actual object shape> (shapes are documented here). If you would prefer, I could contribute this change. If so, just let me know if you would prefer Promise<any> or if I should fully type the API.

Currently only ChatCompletionMessage is exported.

I need its variations to write guard type guards:

• SystemCompletionMessage
• UserCompletionMessage
• FunctionAwareAssistantCompletionMessage
• FunctionCompletionMessage
• AssistantCompletionMessage

1. Would you be open to a PR that addresses that?
2. Would you like me to also submit the guard functions (they help when going through the array of messages trying to identify what type each message has. e.g. a function_call and regular content both can have role: 'assistant, so one needs to look inside the object)?

When passing function and function_call to the createChatCompletion() we should expect to have function_call object inside content of a message, however it's impossible to determine whether the openAI response is AssistantCompletionMessage or FunctionAwareAssistantCompletionMessage as both share the same role:

interface AssistantCompletionMessage {
  content: string;
  name?: string;
  role: "assistant";
}

interface FunctionAwareAssistantCompletionMessage {
  content: string | null;
  role: "assistant";
  function_call?: {
    "name": string;
    "arguments": string;
  };
}

And it seems impossible to narrow the type from that point, so properties name from AssistantCompletionMessage and property function_call from FunctionAwareAssistantCompletionMessage can't be accessed.

Moreover, those types are not exported, so you can't really create a Type Guard yourself.

When calling the method createImageVariation the following error is returned:

{
    "error": "invalid_request_error: Invalid Content-Type header (application/json), expected multipart/form-data. (HINT: If you're using curl, you can pass -H 'Content-Type: multipart/form-data')"
}

Just a question on token limits:

If I use, for example, the 8k token model, can I send a list of messages, each with content equal to 8k tokens, or would the entirety of my messages array have to be under 8k?

Why? To make deno fmt work as well as IDE-specific auto formatting features.

Suggestion based on the current coding style:

  "fmt": {
    "indentWidth": 2,
    "semiColons": true,
    "singleQuote": false,
    "useTabs": false
  }

Running this against the current code base shows minimal changes (only dangling commas are added in ts files) as well as a double quote usage in the README.

Happy to do a PR if needed.

This uses EventSource, so we'll probably have to use Skye's polyfill until denoland/deno#14730 lands.

https://github.com/load1n9/openai/blob/a779b21c4d9c4659933ae84bee9b9749433eaf65/src/openai.ts#L301:L311

This should use FormData.

Deno has native testing support. Could we add some tests with mock data just to ensure that the parsing and encoding/decoding functionality works as expected?

Right now the error handling only exposes the response body via the standard Error class.

1. This makes it hard to know if the exception was a result of this library or something else
2. You do not have access other response properties (most importantly statusCode

I'd probably copy axios and do something like this:

class HttpResponseError extends Error {
  httpResponse: Response;

  constructor(message: string, httpResponse: Response) {
    super(message);

    // Set the prototype explicitly to allow instanceof checks
    Object.setPrototypeOf(this, HttpResponseError.prototype);

    this.name = 'HttpResponseError';
    this.httpResponse = httpResponse;
  }
}

Or maybe even just have properties forstatus, body, etc if it's already been parsed/consumed.

Then you can do something like this in your catch blocks:

}catch(e){
  if(e instanceof HttpResponseError){
     if(e.statusCode === 429){
        // retry request with backoff
        return retry();
     }
  }
  throw e;
}

When going through the incoming JSON array from OpenAI API, each element can be of a different type.

Deno uses TypeScript which uses type guards to simplify type assertions.

Examples

Let's say we have an array of messages:

const messageArray: ChatCompletionMessage[]

1. When a FunctionCompletionMessage is being inserted to messageArray, it is important to verify that the last element is of type FunctionAwareAssistantCompletionMessage.

2. When inserting user input into the messageArray, it is important to check that it is well-formed (UserCompletionMessage).

Suggestion

Add the following guard functions:

• isSystemCompletionMessage(x: unknown): x is SystemCompletionMessage
• isUserCompletionMessage(x: unknown): x is UserCompletionMessage
• isFunctionAwareAssistantCompletionMessage(x: unknown): x is FunctionAwareAssistantCompletionMessage
• isFunctionCompletionMessage(x: unknown): x is FunctionCompletionMessage
• isAssistantCompletionMessage(x: unknown): x is AssistantCompletionMessage

Currently, it seems like this lib is hard-coded to only allow request against OpenAI APIs. Allow passing in a host so this can be used to target the Azure OpenAI Service

Self-explanatory