-- | @\/v1@
--
-- Example usage:
--
-- @
-- {-# LANGUAGE DuplicateRecordFields #-}
-- {-# LANGUAGE NamedFieldPuns        #-}
-- {-# LANGUAGE OverloadedStrings     #-}
-- {-# LANGUAGE OverloadedLists       #-}
--
-- module Main where
--
-- import "Data.Foldable" (`Data.Foldable.traverse_`)
-- import "OpenAI.V1"
-- import "OpenAI.V1.Chat.Completions"
--
-- import qualified "Data.Text" as Text
-- import qualified "Data.Text.IO" as Text.IO
-- import qualified "System.Environment" as Environment
--
-- main :: `IO` ()
-- main = do
--     key <- Environment.`System.Environment.getEnv` \"OPENAI_KEY\"
--
--     clientEnv <- `OpenAI.V1.getClientEnv` \"https://api.openai.com\"
--
--     let `OpenAI.V1.Methods`{ createChatCompletion } = `OpenAI.V1.makeMethods` clientEnv (Text.`Data.Text.pack` key)
--
--     text <- Text.IO.`Data.Text.IO.getLine`
--
--     `OpenAI.V1.Chat.Completions.ChatCompletionObject`{ `OpenAI.V1.Chat.Completions.choices` } <- createChatCompletion `OpenAI.V1.Chat.Completions._CreateChatCompletion`
--         { `OpenAI.V1.Chat.Completions.messages` = [ `OpenAI.V1.Chat.Completions.User`{ `OpenAI.V1.Chat.Completions.content` = [ `OpenAI.V1.Chat.Completions.Text`{ `OpenAI.V1.Chat.Completions.text` } ], `OpenAI.V1.Chat.Completions.name` = `Nothing` } ]
--         , `OpenAI.V1.Chat.Completions.model` = \"gpt-4o-mini\"
--         }
--
--     let display `OpenAI.V1.Chat.Completions.Choice`{ `OpenAI.V1.Chat.Completions.message` } = Text.IO.`Data.Text.IO.putStrLn` (`OpenAI.V1.Chat.Completions.messageToContent` message)
--
--     `Data.Foldable.traverse_` display choices
-- @

module OpenAI.V1
    ( -- * Methods
      Methods(..)
    , getClientEnv
    , makeMethods
      -- * Servant
    , API
    ) where

import Control.Monad (foldM)
import Data.ByteString.Char8 ()
import Data.Proxy (Proxy(..))
import OpenAI.Prelude
import OpenAI.V1.Audio.Speech (CreateSpeech)
import OpenAI.V1.Audio.Transcriptions (CreateTranscription, TranscriptionObject)
import OpenAI.V1.Audio.Translations (CreateTranslation, TranslationObject)
import OpenAI.V1.Batches (BatchID, BatchObject, CreateBatch)
import OpenAI.V1.Chat.Completions (ChatCompletionObject, CreateChatCompletion)
import OpenAI.V1.DeletionStatus (DeletionStatus)
import OpenAI.V1.Embeddings (CreateEmbeddings, EmbeddingObject)
import OpenAI.V1.Files (FileID, FileObject, UploadFile)
import OpenAI.V1.Images.Edits (CreateImageEdit)
import OpenAI.V1.Images.Generations (CreateImage)
import OpenAI.V1.Images.Image (ImageObject)
import OpenAI.V1.Images.Variations (CreateImageVariation)
import OpenAI.V1.ListOf (ListOf(..))
import OpenAI.V1.Message (Message)
import OpenAI.V1.Models (Model, ModelObject)
import OpenAI.V1.Moderations (CreateModeration, Moderation)
import OpenAI.V1.Order (Order)
import OpenAI.V1.Responses (CreateResponse, InputItem, ResponseObject)
import OpenAI.V1.Threads (ModifyThread, Thread, ThreadID, ThreadObject)
import OpenAI.V1.Threads.Messages (MessageID, MessageObject, ModifyMessage)
import OpenAI.V1.Threads.Runs.Steps (RunStepObject(..), StepID)
import Servant.Client (ClientEnv)
import Servant.Multipart.Client ()

import OpenAI.V1.Assistants
    (AssistantID, AssistantObject, CreateAssistant, ModifyAssistant)
import OpenAI.V1.FineTuning.Jobs
    ( CheckpointObject
    , CreateFineTuningJob
    , EventObject
    , FineTuningJobID
    , JobObject
    )
import OpenAI.V1.Threads.Runs
    ( CreateRun
    , CreateThreadAndRun
    , ModifyRun
    , RunID
    , RunObject
    , SubmitToolOutputsToRun
    )
import OpenAI.V1.Uploads
    ( AddUploadPart
    , CompleteUpload
    , CreateUpload
    , PartObject
    , UploadID
    , UploadObject
    )
import OpenAI.V1.VectorStores
    ( CreateVectorStore(..)
    , ModifyVectorStore(..)
    , VectorStoreID
    , VectorStoreObject(..)
    )
import OpenAI.V1.VectorStores.FileBatches
    ( CreateVectorStoreFileBatch(..)
    , VectorStoreFileBatchID
    , VectorStoreFilesBatchObject(..)
    )
import OpenAI.V1.VectorStores.Files
    (CreateVectorStoreFile(..), VectorStoreFileID, VectorStoreFileObject(..))

import qualified Control.Exception as Exception
import qualified Data.Aeson as Aeson
import qualified Data.ByteString as SBS
import qualified Data.ByteString.Char8 as S8
import qualified Data.IORef as IORef
import qualified Data.Text as Text
import qualified Network.HTTP.Client as HTTP.Client
import qualified Network.HTTP.Client.TLS as TLS
import qualified Network.HTTP.Types.Status as Status
import qualified OpenAI.V1.Assistants as Assistants
import qualified OpenAI.V1.Audio as Audio
import qualified OpenAI.V1.Batches as Batches
import qualified OpenAI.V1.Chat.Completions as Chat.Completions
import qualified OpenAI.V1.Embeddings as Embeddings
import qualified OpenAI.V1.Files as Files
import qualified OpenAI.V1.FineTuning.Jobs as FineTuning.Jobs
import qualified OpenAI.V1.Images as Images
import qualified OpenAI.V1.Models as Models
import qualified OpenAI.V1.Moderations as Moderations
import qualified OpenAI.V1.Responses as Responses
import qualified OpenAI.V1.Threads as Threads
import qualified OpenAI.V1.Threads.Messages as Messages
import qualified OpenAI.V1.Threads.Runs as Threads.Runs
import qualified OpenAI.V1.Threads.Runs.Steps as Threads.Runs.Steps
import qualified OpenAI.V1.Uploads as Uploads
import qualified OpenAI.V1.VectorStores as VectorStores
import qualified OpenAI.V1.VectorStores.FileBatches as VectorStores.FileBatches
import qualified OpenAI.V1.VectorStores.Files as VectorStores.Files
import qualified OpenAI.V1.VectorStores.Status as VectorStores.Status
import qualified Servant.Client as Client

-- | Convenient utility to get a `ClientEnv` for the most common use case
getClientEnv
    :: Text
    -- ^ Base URL for API
    -> IO ClientEnv
getClientEnv :: Text -> IO ClientEnv
getClientEnv Text
baseUrlText = do
    BaseUrl
baseUrl <- String -> IO BaseUrl
forall (m :: * -> *). MonadThrow m => String -> m BaseUrl
Client.parseBaseUrl (Text -> String
Text.unpack Text
baseUrlText)

    let managerSettings :: ManagerSettings
managerSettings = ManagerSettings
TLS.tlsManagerSettings
            { HTTP.Client.managerResponseTimeout =
                HTTP.Client.responseTimeoutNone
            }

    Manager
manager <- ManagerSettings -> IO Manager
forall (m :: * -> *). MonadIO m => ManagerSettings -> m Manager
TLS.newTlsManagerWith ManagerSettings
managerSettings

    ClientEnv -> IO ClientEnv
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Manager -> BaseUrl -> ClientEnv
Client.mkClientEnv Manager
manager BaseUrl
baseUrl)

-- | Get a record of API methods after providing an API token
makeMethods
    :: ClientEnv
    -- ^
    -> Text
    -- ^ API token
    -> Maybe Text
    -- ^ Organization ID
    -> Maybe Text
    -- ^ Project ID
    -> Methods
makeMethods :: ClientEnv -> Text -> Maybe Text -> Maybe Text -> Methods
makeMethods ClientEnv
clientEnv Text
token Maybe Text
organizationID Maybe Text
projectID = Methods{IO (Vector ModelObject)
Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector AssistantObject)
Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector VectorStoreObject)
Maybe Text -> Maybe Natural -> IO (Vector JobObject)
Maybe Text -> Maybe Natural -> IO (Vector BatchObject)
Maybe Purpose
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> IO (Vector FileObject)
Text -> IO (Vector InputItem)
Text -> IO ResponseObject
Model -> IO DeletionStatus
Model -> IO ModelObject
CreateImageVariation -> IO (Vector ImageObject)
CreateImage -> IO (Vector ImageObject)
CreateImageEdit -> IO (Vector ImageObject)
CreateEmbeddings -> IO (Vector EmbeddingObject)
CreateTranslation -> IO TranslationObject
CreateTranscription -> IO TranscriptionObject
CreateSpeech -> IO ByteString
CreateModeration -> IO Moderation
UploadFile -> IO FileObject
FileID -> IO ByteString
FileID -> IO DeletionStatus
FileID -> IO FileObject
CreateFineTuningJob -> IO JobObject
FineTuningJobID -> IO JobObject
FineTuningJobID
-> Maybe Text -> Maybe Natural -> IO (Vector CheckpointObject)
FineTuningJobID
-> Maybe Text -> Maybe Natural -> IO (Vector EventObject)
CreateBatch -> IO BatchObject
BatchID -> IO BatchObject
CreateResponse -> IO ResponseObject
CreateResponse -> (Either Text Value -> IO ()) -> IO ()
CreateResponse
-> (Either Text ResponseStreamEvent -> IO ()) -> IO ()
Thread -> IO ThreadObject
ThreadID -> IO (Vector MessageObject)
ThreadID -> IO DeletionStatus
ThreadID -> IO ThreadObject
ThreadID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector RunObject)
ThreadID -> Maybe Text -> CreateRun -> IO RunObject
ThreadID -> Message -> IO MessageObject
ThreadID -> ModifyThread -> IO ThreadObject
ThreadID -> RunID -> IO RunObject
ThreadID
-> RunID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> IO (Vector RunStepObject)
ThreadID -> RunID -> SubmitToolOutputsToRun -> IO RunObject
ThreadID -> RunID -> ModifyRun -> IO RunObject
ThreadID -> RunID -> StepID -> Maybe Text -> IO RunStepObject
ThreadID -> MessageID -> IO DeletionStatus
ThreadID -> MessageID -> IO MessageObject
ThreadID -> MessageID -> ModifyMessage -> IO MessageObject
CreateAssistant -> IO AssistantObject
AssistantID -> IO DeletionStatus
AssistantID -> IO AssistantObject
AssistantID -> ModifyAssistant -> IO AssistantObject
CreateUpload -> IO (UploadObject (Maybe Void))
UploadID -> IO (UploadObject (Maybe Void))
UploadID -> CompleteUpload -> IO (UploadObject FileObject)
UploadID -> AddUploadPart -> IO PartObject
CreateThreadAndRun -> IO RunObject
CreateChatCompletion -> IO ChatCompletionObject
CreateChatCompletion -> (Either Text Value -> IO ()) -> IO ()
CreateChatCompletion
-> (Either Text ChatCompletionStreamEvent -> IO ()) -> IO ()
CreateVectorStore -> IO VectorStoreObject
VectorStoreID -> IO DeletionStatus
VectorStoreID -> IO VectorStoreObject
VectorStoreID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Status
-> IO (Vector VectorStoreFileObject)
VectorStoreID -> ModifyVectorStore -> IO VectorStoreObject
VectorStoreID -> CreateVectorStoreFile -> IO VectorStoreFileObject
VectorStoreID -> VectorStoreFileID -> IO DeletionStatus
VectorStoreID -> VectorStoreFileID -> IO VectorStoreFileObject
VectorStoreID
-> CreateVectorStoreFileBatch -> IO VectorStoreFilesBatchObject
VectorStoreID
-> VectorStoreFileBatchID -> IO VectorStoreFilesBatchObject
VectorStoreID
-> VectorStoreFileBatchID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Status
-> IO (Vector VectorStoreFilesBatchObject)
createSpeech :: CreateSpeech -> IO ByteString
createChatCompletion :: CreateChatCompletion -> IO ChatCompletionObject
createResponse :: CreateResponse -> IO ResponseObject
retrieveResponse :: Text -> IO ResponseObject
cancelResponse :: Text -> IO ResponseObject
createFineTuningJob :: CreateFineTuningJob -> IO JobObject
retrieveFineTuningJob :: FineTuningJobID -> IO JobObject
cancelFineTuning :: FineTuningJobID -> IO JobObject
createBatch :: CreateBatch -> IO BatchObject
retrieveBatch :: BatchID -> IO BatchObject
cancelBatch :: BatchID -> IO BatchObject
retrieveFile :: FileID -> IO FileObject
deleteFile :: FileID -> IO DeletionStatus
retrieveFileContent :: FileID -> IO ByteString
createUpload :: CreateUpload -> IO (UploadObject (Maybe Void))
completeUpload :: UploadID -> CompleteUpload -> IO (UploadObject FileObject)
cancelUpload :: UploadID -> IO (UploadObject (Maybe Void))
retrieveModel :: Model -> IO ModelObject
deleteModel :: Model -> IO DeletionStatus
createModeration :: CreateModeration -> IO Moderation
createAssistant :: CreateAssistant -> IO AssistantObject
retrieveAssistant :: AssistantID -> IO AssistantObject
modifyAssistant :: AssistantID -> ModifyAssistant -> IO AssistantObject
deleteAssistant :: AssistantID -> IO DeletionStatus
createThread :: Thread -> IO ThreadObject
retrieveThread :: ThreadID -> IO ThreadObject
modifyThread :: ThreadID -> ModifyThread -> IO ThreadObject
deleteThread :: ThreadID -> IO DeletionStatus
createMessage :: ThreadID -> Message -> IO MessageObject
retrieveMessage :: ThreadID -> MessageID -> IO MessageObject
modifyMessage :: ThreadID -> MessageID -> ModifyMessage -> IO MessageObject
deleteMessage :: ThreadID -> MessageID -> IO DeletionStatus
createRun :: ThreadID -> Maybe Text -> CreateRun -> IO RunObject
createThreadAndRun :: CreateThreadAndRun -> IO RunObject
retrieveRun :: ThreadID -> RunID -> IO RunObject
modifyRun :: ThreadID -> RunID -> ModifyRun -> IO RunObject
submitToolOutputsToRun :: ThreadID -> RunID -> SubmitToolOutputsToRun -> IO RunObject
cancelRun :: ThreadID -> RunID -> IO RunObject
retrieveRunStep :: ThreadID -> RunID -> StepID -> Maybe Text -> IO RunStepObject
createVectorStore :: CreateVectorStore -> IO VectorStoreObject
retrieveVectorStore :: VectorStoreID -> IO VectorStoreObject
modifyVectorStore :: VectorStoreID -> ModifyVectorStore -> IO VectorStoreObject
deleteVectorStore :: VectorStoreID -> IO DeletionStatus
createVectorStoreFile :: VectorStoreID -> CreateVectorStoreFile -> IO VectorStoreFileObject
retrieveVectorStoreFile :: VectorStoreID -> VectorStoreFileID -> IO VectorStoreFileObject
deleteVectorStoreFile :: VectorStoreID -> VectorStoreFileID -> IO DeletionStatus
createVectorStoreFileBatch :: VectorStoreID
-> CreateVectorStoreFileBatch -> IO VectorStoreFilesBatchObject
retrieveVectorStoreFileBatch :: VectorStoreID
-> VectorStoreFileBatchID -> IO VectorStoreFilesBatchObject
cancelVectorStoreFileBatch :: VectorStoreID
-> VectorStoreFileBatchID -> IO VectorStoreFilesBatchObject
createTranscription :: CreateTranscription -> IO TranscriptionObject
createTranslation :: CreateTranslation -> IO TranslationObject
createEmbeddings :: CreateEmbeddings -> IO (Vector EmbeddingObject)
listFineTuningJobs :: Maybe Text -> Maybe Natural -> IO (Vector JobObject)
listFineTuningEvents :: FineTuningJobID
-> Maybe Text -> Maybe Natural -> IO (Vector EventObject)
listFineTuningCheckpoints :: FineTuningJobID
-> Maybe Text -> Maybe Natural -> IO (Vector CheckpointObject)
listBatch :: Maybe Text -> Maybe Natural -> IO (Vector BatchObject)
uploadFile :: UploadFile -> IO FileObject
listFiles :: Maybe Purpose
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> IO (Vector FileObject)
addUploadPart :: UploadID -> AddUploadPart -> IO PartObject
createImage :: CreateImage -> IO (Vector ImageObject)
createImageEdit :: CreateImageEdit -> IO (Vector ImageObject)
createImageVariation :: CreateImageVariation -> IO (Vector ImageObject)
listModels :: IO (Vector ModelObject)
listAssistants :: Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector AssistantObject)
listMessages :: ThreadID -> IO (Vector MessageObject)
listRuns :: ThreadID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector RunObject)
listRunSteps :: ThreadID
-> RunID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> IO (Vector RunStepObject)
listVectorStores :: Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector VectorStoreObject)
listVectorStoreFiles :: VectorStoreID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Status
-> IO (Vector VectorStoreFileObject)
listVectorStoreFilesInABatch :: VectorStoreID
-> VectorStoreFileBatchID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Status
-> IO (Vector VectorStoreFilesBatchObject)
listResponseInputItems :: Text -> IO (Vector InputItem)
createResponseStream :: CreateResponse -> (Either Text Value -> IO ()) -> IO ()
createResponseStreamTyped :: CreateResponse
-> (Either Text ResponseStreamEvent -> IO ()) -> IO ()
createChatCompletionStream :: CreateChatCompletion -> (Either Text Value -> IO ()) -> IO ()
createChatCompletionStreamTyped :: CreateChatCompletion
-> (Either Text ChatCompletionStreamEvent -> IO ()) -> IO ()
listVectorStoreFilesInABatch :: VectorStoreID
-> VectorStoreFileBatchID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Status
-> IO (Vector VectorStoreFilesBatchObject)
cancelVectorStoreFileBatch :: VectorStoreID
-> VectorStoreFileBatchID -> IO VectorStoreFilesBatchObject
retrieveVectorStoreFileBatch :: VectorStoreID
-> VectorStoreFileBatchID -> IO VectorStoreFilesBatchObject
createVectorStoreFileBatch :: VectorStoreID
-> CreateVectorStoreFileBatch -> IO VectorStoreFilesBatchObject
deleteVectorStoreFile :: VectorStoreID -> VectorStoreFileID -> IO DeletionStatus
retrieveVectorStoreFile :: VectorStoreID -> VectorStoreFileID -> IO VectorStoreFileObject
listVectorStoreFiles :: VectorStoreID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Status
-> IO (Vector VectorStoreFileObject)
createVectorStoreFile :: VectorStoreID -> CreateVectorStoreFile -> IO VectorStoreFileObject
deleteVectorStore :: VectorStoreID -> IO DeletionStatus
modifyVectorStore :: VectorStoreID -> ModifyVectorStore -> IO VectorStoreObject
retrieveVectorStore :: VectorStoreID -> IO VectorStoreObject
listVectorStores :: Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector VectorStoreObject)
createVectorStore :: CreateVectorStore -> IO VectorStoreObject
listResponseInputItems :: Text -> IO (Vector InputItem)
cancelResponse :: Text -> IO ResponseObject
retrieveResponse :: Text -> IO ResponseObject
retrieveRunStep :: ThreadID -> RunID -> StepID -> Maybe Text -> IO RunStepObject
listRunSteps :: ThreadID
-> RunID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> IO (Vector RunStepObject)
cancelRun :: ThreadID -> RunID -> IO RunObject
submitToolOutputsToRun :: ThreadID -> RunID -> SubmitToolOutputsToRun -> IO RunObject
modifyRun :: ThreadID -> RunID -> ModifyRun -> IO RunObject
retrieveRun :: ThreadID -> RunID -> IO RunObject
listRuns :: ThreadID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector RunObject)
createThreadAndRun :: CreateThreadAndRun -> IO RunObject
createRun :: ThreadID -> Maybe Text -> CreateRun -> IO RunObject
deleteMessage :: ThreadID -> MessageID -> IO DeletionStatus
modifyMessage :: ThreadID -> MessageID -> ModifyMessage -> IO MessageObject
retrieveMessage :: ThreadID -> MessageID -> IO MessageObject
listMessages :: ThreadID -> IO (Vector MessageObject)
createMessage :: ThreadID -> Message -> IO MessageObject
deleteThread :: ThreadID -> IO DeletionStatus
modifyThread :: ThreadID -> ModifyThread -> IO ThreadObject
retrieveThread :: ThreadID -> IO ThreadObject
createThread :: Thread -> IO ThreadObject
deleteAssistant :: AssistantID -> IO DeletionStatus
modifyAssistant :: AssistantID -> ModifyAssistant -> IO AssistantObject
retrieveAssistant :: AssistantID -> IO AssistantObject
listAssistants :: Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector AssistantObject)
createAssistant :: CreateAssistant -> IO AssistantObject
createModeration :: CreateModeration -> IO Moderation
deleteModel :: Model -> IO DeletionStatus
retrieveModel :: Model -> IO ModelObject
listModels :: IO (Vector ModelObject)
createImageVariation :: CreateImageVariation -> IO (Vector ImageObject)
createImageEdit :: CreateImageEdit -> IO (Vector ImageObject)
createImage :: CreateImage -> IO (Vector ImageObject)
cancelUpload :: UploadID -> IO (UploadObject (Maybe Void))
completeUpload :: UploadID -> CompleteUpload -> IO (UploadObject FileObject)
addUploadPart :: UploadID -> AddUploadPart -> IO PartObject
createUpload :: CreateUpload -> IO (UploadObject (Maybe Void))
retrieveFileContent :: FileID -> IO ByteString
deleteFile :: FileID -> IO DeletionStatus
retrieveFile :: FileID -> IO FileObject
listFiles :: Maybe Purpose
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> IO (Vector FileObject)
uploadFile :: UploadFile -> IO FileObject
listBatch :: Maybe Text -> Maybe Natural -> IO (Vector BatchObject)
cancelBatch :: BatchID -> IO BatchObject
retrieveBatch :: BatchID -> IO BatchObject
createBatch :: CreateBatch -> IO BatchObject
cancelFineTuning :: FineTuningJobID -> IO JobObject
retrieveFineTuningJob :: FineTuningJobID -> IO JobObject
listFineTuningCheckpoints :: FineTuningJobID
-> Maybe Text -> Maybe Natural -> IO (Vector CheckpointObject)
listFineTuningEvents :: FineTuningJobID
-> Maybe Text -> Maybe Natural -> IO (Vector EventObject)
listFineTuningJobs :: Maybe Text -> Maybe Natural -> IO (Vector JobObject)
createFineTuningJob :: CreateFineTuningJob -> IO JobObject
createResponseStreamTyped :: CreateResponse
-> (Either Text ResponseStreamEvent -> IO ()) -> IO ()
createEmbeddings :: CreateEmbeddings -> IO (Vector EmbeddingObject)
createResponseStream :: CreateResponse -> (Either Text Value -> IO ()) -> IO ()
createResponse :: CreateResponse -> IO ResponseObject
createChatCompletionStreamTyped :: CreateChatCompletion
-> (Either Text ChatCompletionStreamEvent -> IO ()) -> IO ()
createChatCompletionStream :: CreateChatCompletion -> (Either Text Value -> IO ()) -> IO ()
createChatCompletion :: CreateChatCompletion -> IO ChatCompletionObject
createTranslation :: CreateTranslation -> IO TranslationObject
createTranscription :: CreateTranscription -> IO TranscriptionObject
createSpeech :: CreateSpeech -> IO ByteString
..}
  where
    authorization :: Text
authorization = Text
"Bearer " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
token

    (       (     CreateSpeech -> IO ByteString
createSpeech
            :<|>  (ByteString, CreateTranscription) -> IO TranscriptionObject
createTranscription_
            :<|>  (ByteString, CreateTranslation) -> IO TranslationObject
createTranslation_
                    )
      :<|>  CreateChatCompletion -> IO ChatCompletionObject
createChatCompletion
      :<|>  (     CreateResponse -> IO ResponseObject
createResponse
            :<|>  Text -> IO ResponseObject
retrieveResponse
            :<|>  Text -> IO ResponseObject
cancelResponse
            :<|>  Text -> IO (ListOf InputItem)
listResponseInputItems_
            )
      :<|>  CreateEmbeddings -> IO (ListOf EmbeddingObject)
createEmbeddings_
      :<|>  (     CreateFineTuningJob -> IO JobObject
createFineTuningJob
            :<|>  Maybe Text -> Maybe Natural -> IO (ListOf JobObject)
listFineTuningJobs_
            :<|>  FineTuningJobID
-> Maybe Text -> Maybe Natural -> IO (ListOf EventObject)
listFineTuningEvents_
            :<|>  FineTuningJobID
-> Maybe Text -> Maybe Natural -> IO (ListOf CheckpointObject)
listFineTuningCheckpoints_
            :<|>  FineTuningJobID -> IO JobObject
retrieveFineTuningJob
            :<|>  FineTuningJobID -> IO JobObject
cancelFineTuning
            )
      :<|>  (     CreateBatch -> IO BatchObject
createBatch
            :<|>  BatchID -> IO BatchObject
retrieveBatch
            :<|>  BatchID -> IO BatchObject
cancelBatch
            :<|>  Maybe Text -> Maybe Natural -> IO (ListOf BatchObject)
listBatch_
            )
      :<|>  (     (ByteString, UploadFile) -> IO FileObject
uploadFile_
            :<|>  Maybe Purpose
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> IO (ListOf FileObject)
listFiles_
            :<|>  FileID -> IO FileObject
retrieveFile
            :<|>  FileID -> IO DeletionStatus
deleteFile
            :<|>  FileID -> IO ByteString
retrieveFileContent
            )
      :<|>  (     CreateImage -> IO (ListOf ImageObject)
createImage_
            :<|>  (ByteString, CreateImageEdit) -> IO (ListOf ImageObject)
createImageEdit_
            :<|>  (ByteString, CreateImageVariation) -> IO (ListOf ImageObject)
createImageVariation_
            )
      :<|>  (     CreateUpload -> IO (UploadObject (Maybe Void))
createUpload
            :<|>  UploadID -> (ByteString, AddUploadPart) -> IO PartObject
addUploadPart_
            :<|>  UploadID -> CompleteUpload -> IO (UploadObject FileObject)
completeUpload
            :<|>  UploadID -> IO (UploadObject (Maybe Void))
cancelUpload
            )
      :<|>  (     IO (ListOf ModelObject)
listModels_
            :<|>  Model -> IO ModelObject
retrieveModel
            :<|>  Model -> IO DeletionStatus
deleteModel
            )
      :<|>  (     CreateModeration -> IO Moderation
createModeration
            )
      :<|>  (   (\Text
-> (CreateAssistant -> IO AssistantObject)
   :<|> ((Maybe Natural
          -> Maybe Order
          -> Maybe Text
          -> Maybe Text
          -> IO (ListOf AssistantObject))
         :<|> ((AssistantID -> IO AssistantObject)
               :<|> ((AssistantID -> ModifyAssistant -> IO AssistantObject)
                     :<|> (AssistantID -> IO DeletionStatus))))
x -> Text
-> (CreateAssistant -> IO AssistantObject)
   :<|> ((Maybe Natural
          -> Maybe Order
          -> Maybe Text
          -> Maybe Text
          -> IO (ListOf AssistantObject))
         :<|> ((AssistantID -> IO AssistantObject)
               :<|> ((AssistantID -> ModifyAssistant -> IO AssistantObject)
                     :<|> (AssistantID -> IO DeletionStatus))))
x Text
"assistants=v2")
            ->  (     CreateAssistant -> IO AssistantObject
createAssistant
                :<|>  Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (ListOf AssistantObject)
listAssistants_
                :<|>  AssistantID -> IO AssistantObject
retrieveAssistant
                :<|>  AssistantID -> ModifyAssistant -> IO AssistantObject
modifyAssistant
                :<|>  AssistantID -> IO DeletionStatus
deleteAssistant
                )
            )
      :<|>  (   (\Text
-> (Thread -> IO ThreadObject)
   :<|> ((ThreadID -> IO ThreadObject)
         :<|> ((ThreadID -> ModifyThread -> IO ThreadObject)
               :<|> (ThreadID -> IO DeletionStatus)))
x -> Text
-> (Thread -> IO ThreadObject)
   :<|> ((ThreadID -> IO ThreadObject)
         :<|> ((ThreadID -> ModifyThread -> IO ThreadObject)
               :<|> (ThreadID -> IO DeletionStatus)))
x Text
"assistants=v2")
            ->  (     Thread -> IO ThreadObject
createThread
                :<|>  ThreadID -> IO ThreadObject
retrieveThread
                :<|>  ThreadID -> ModifyThread -> IO ThreadObject
modifyThread
                :<|>  ThreadID -> IO DeletionStatus
deleteThread
                )
            )
      :<|>  (   (\Text
-> (ThreadID -> Message -> IO MessageObject)
   :<|> ((ThreadID -> IO (ListOf MessageObject))
         :<|> ((ThreadID -> MessageID -> IO MessageObject)
               :<|> ((ThreadID -> MessageID -> ModifyMessage -> IO MessageObject)
                     :<|> (ThreadID -> MessageID -> IO DeletionStatus))))
x -> Text
-> (ThreadID -> Message -> IO MessageObject)
   :<|> ((ThreadID -> IO (ListOf MessageObject))
         :<|> ((ThreadID -> MessageID -> IO MessageObject)
               :<|> ((ThreadID -> MessageID -> ModifyMessage -> IO MessageObject)
                     :<|> (ThreadID -> MessageID -> IO DeletionStatus))))
x Text
"assistants=v2")
            ->  (     ThreadID -> Message -> IO MessageObject
createMessage
                :<|>  ThreadID -> IO (ListOf MessageObject)
listMessages_
                :<|>  ThreadID -> MessageID -> IO MessageObject
retrieveMessage
                :<|>  ThreadID -> MessageID -> ModifyMessage -> IO MessageObject
modifyMessage
                :<|>  ThreadID -> MessageID -> IO DeletionStatus
deleteMessage
                )
            )
      :<|>  (   (\Text
-> (ThreadID -> Maybe Text -> CreateRun -> IO RunObject)
   :<|> ((CreateThreadAndRun -> IO RunObject)
         :<|> ((ThreadID
                -> Maybe Natural
                -> Maybe Order
                -> Maybe Text
                -> Maybe Text
                -> IO (ListOf RunObject))
               :<|> ((ThreadID -> RunID -> IO RunObject)
                     :<|> ((ThreadID -> RunID -> ModifyRun -> IO RunObject)
                           :<|> ((ThreadID -> RunID -> SubmitToolOutputsToRun -> IO RunObject)
                                 :<|> (ThreadID -> RunID -> IO RunObject))))))
x -> Text
-> (ThreadID -> Maybe Text -> CreateRun -> IO RunObject)
   :<|> ((CreateThreadAndRun -> IO RunObject)
         :<|> ((ThreadID
                -> Maybe Natural
                -> Maybe Order
                -> Maybe Text
                -> Maybe Text
                -> IO (ListOf RunObject))
               :<|> ((ThreadID -> RunID -> IO RunObject)
                     :<|> ((ThreadID -> RunID -> ModifyRun -> IO RunObject)
                           :<|> ((ThreadID -> RunID -> SubmitToolOutputsToRun -> IO RunObject)
                                 :<|> (ThreadID -> RunID -> IO RunObject))))))
x Text
"assistants=v2")
            ->  (     ThreadID -> Maybe Text -> CreateRun -> IO RunObject
createRun
                :<|>  CreateThreadAndRun -> IO RunObject
createThreadAndRun
                :<|>  ThreadID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (ListOf RunObject)
listRuns_
                :<|>  ThreadID -> RunID -> IO RunObject
retrieveRun
                :<|>  ThreadID -> RunID -> ModifyRun -> IO RunObject
modifyRun
                :<|>  ThreadID -> RunID -> SubmitToolOutputsToRun -> IO RunObject
submitToolOutputsToRun
                :<|>  ThreadID -> RunID -> IO RunObject
cancelRun
                )
            )
      :<|>  (   (\Text
-> (ThreadID
    -> RunID
    -> Maybe Natural
    -> Maybe Order
    -> Maybe Text
    -> Maybe Text
    -> Maybe Text
    -> IO (ListOf RunStepObject))
   :<|> (ThreadID
         -> RunID -> StepID -> Maybe Text -> IO RunStepObject)
x -> Text
-> (ThreadID
    -> RunID
    -> Maybe Natural
    -> Maybe Order
    -> Maybe Text
    -> Maybe Text
    -> Maybe Text
    -> IO (ListOf RunStepObject))
   :<|> (ThreadID
         -> RunID -> StepID -> Maybe Text -> IO RunStepObject)
x Text
"assistants=v2")
            ->  (     ThreadID
-> RunID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> IO (ListOf RunStepObject)
listRunSteps_
                :<|>  ThreadID -> RunID -> StepID -> Maybe Text -> IO RunStepObject
retrieveRunStep
                )
            )

      :<|>  (   (\Text
-> (CreateVectorStore -> IO VectorStoreObject)
   :<|> ((Maybe Natural
          -> Maybe Order
          -> Maybe Text
          -> Maybe Text
          -> IO (ListOf VectorStoreObject))
         :<|> ((VectorStoreID -> IO VectorStoreObject)
               :<|> ((VectorStoreID -> ModifyVectorStore -> IO VectorStoreObject)
                     :<|> (VectorStoreID -> IO DeletionStatus))))
x -> Text
-> (CreateVectorStore -> IO VectorStoreObject)
   :<|> ((Maybe Natural
          -> Maybe Order
          -> Maybe Text
          -> Maybe Text
          -> IO (ListOf VectorStoreObject))
         :<|> ((VectorStoreID -> IO VectorStoreObject)
               :<|> ((VectorStoreID -> ModifyVectorStore -> IO VectorStoreObject)
                     :<|> (VectorStoreID -> IO DeletionStatus))))
x Text
"assistants=v2")
            ->  (     CreateVectorStore -> IO VectorStoreObject
createVectorStore
                :<|>  Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (ListOf VectorStoreObject)
listVectorStores_
                :<|>  VectorStoreID -> IO VectorStoreObject
retrieveVectorStore
                :<|>  VectorStoreID -> ModifyVectorStore -> IO VectorStoreObject
modifyVectorStore
                :<|>  VectorStoreID -> IO DeletionStatus
deleteVectorStore
                )
            )
      :<|>  (   (\Text
-> (VectorStoreID
    -> CreateVectorStoreFile -> IO VectorStoreFileObject)
   :<|> ((VectorStoreID
          -> Maybe Natural
          -> Maybe Order
          -> Maybe Text
          -> Maybe Text
          -> Maybe Status
          -> IO (ListOf VectorStoreFileObject))
         :<|> ((VectorStoreID
                -> VectorStoreFileID -> IO VectorStoreFileObject)
               :<|> (VectorStoreID -> VectorStoreFileID -> IO DeletionStatus)))
x -> Text
-> (VectorStoreID
    -> CreateVectorStoreFile -> IO VectorStoreFileObject)
   :<|> ((VectorStoreID
          -> Maybe Natural
          -> Maybe Order
          -> Maybe Text
          -> Maybe Text
          -> Maybe Status
          -> IO (ListOf VectorStoreFileObject))
         :<|> ((VectorStoreID
                -> VectorStoreFileID -> IO VectorStoreFileObject)
               :<|> (VectorStoreID -> VectorStoreFileID -> IO DeletionStatus)))
x Text
"assistants=v2")
            ->  (     VectorStoreID -> CreateVectorStoreFile -> IO VectorStoreFileObject
createVectorStoreFile
                :<|>  VectorStoreID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Status
-> IO (ListOf VectorStoreFileObject)
listVectorStoreFiles_
                :<|>  VectorStoreID -> VectorStoreFileID -> IO VectorStoreFileObject
retrieveVectorStoreFile
                :<|>  VectorStoreID -> VectorStoreFileID -> IO DeletionStatus
deleteVectorStoreFile
                )
            )
      :<|>  (   (\Text
-> (VectorStoreID
    -> CreateVectorStoreFileBatch -> IO VectorStoreFilesBatchObject)
   :<|> ((VectorStoreID
          -> VectorStoreFileBatchID -> IO VectorStoreFilesBatchObject)
         :<|> ((VectorStoreID
                -> VectorStoreFileBatchID -> IO VectorStoreFilesBatchObject)
               :<|> (VectorStoreID
                     -> VectorStoreFileBatchID
                     -> Maybe Natural
                     -> Maybe Order
                     -> Maybe Text
                     -> Maybe Text
                     -> Maybe Status
                     -> IO (ListOf VectorStoreFilesBatchObject))))
x -> Text
-> (VectorStoreID
    -> CreateVectorStoreFileBatch -> IO VectorStoreFilesBatchObject)
   :<|> ((VectorStoreID
          -> VectorStoreFileBatchID -> IO VectorStoreFilesBatchObject)
         :<|> ((VectorStoreID
                -> VectorStoreFileBatchID -> IO VectorStoreFilesBatchObject)
               :<|> (VectorStoreID
                     -> VectorStoreFileBatchID
                     -> Maybe Natural
                     -> Maybe Order
                     -> Maybe Text
                     -> Maybe Text
                     -> Maybe Status
                     -> IO (ListOf VectorStoreFilesBatchObject))))
x Text
"assistants=v2")
            ->  (     VectorStoreID
-> CreateVectorStoreFileBatch -> IO VectorStoreFilesBatchObject
createVectorStoreFileBatch
                :<|>  VectorStoreID
-> VectorStoreFileBatchID -> IO VectorStoreFilesBatchObject
retrieveVectorStoreFileBatch
                :<|>  VectorStoreID
-> VectorStoreFileBatchID -> IO VectorStoreFilesBatchObject
cancelVectorStoreFileBatch
                :<|>  VectorStoreID
-> VectorStoreFileBatchID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Status
-> IO (ListOf VectorStoreFilesBatchObject)
listVectorStoreFilesInABatch_
                )
            )
      ) = forall api (m :: * -> *) (n :: * -> *).
HasClient ClientM api =>
Proxy api -> (forall a. m a -> n a) -> Client m api -> Client n api
Client.hoistClient @API Proxy API
forall {k} (t :: k). Proxy t
Proxy ClientM a -> IO a
forall a. ClientM a -> IO a
run (forall api.
HasClient ClientM api =>
Proxy api -> Client ClientM api
Client.client @API Proxy API
forall {k} (t :: k). Proxy t
Proxy) Text
authorization Maybe Text
organizationID Maybe Text
projectID

    run :: Client.ClientM a -> IO a
    run :: forall a. ClientM a -> IO a
run ClientM a
clientM = do
        Either ClientError a
result <- ClientM a -> ClientEnv -> IO (Either ClientError a)
forall a. ClientM a -> ClientEnv -> IO (Either ClientError a)
Client.runClientM ClientM a
clientM ClientEnv
clientEnv
        case Either ClientError a
result of
            Left ClientError
exception -> ClientError -> IO a
forall e a. Exception e => e -> IO a
Exception.throwIO ClientError
exception
            Right a
a -> a -> IO a
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return a
a

    toVector :: IO (ListOf a) -> IO (Vector a)
    toVector :: forall a. IO (ListOf a) -> IO (Vector a)
toVector = (ListOf a -> Vector a) -> IO (ListOf a) -> IO (Vector a)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ListOf a -> Vector a
forall {a}. ListOf a -> Vector a
adapt
      where
        adapt :: ListOf a -> Vector a
adapt List{ Vector a
data_ :: Vector a
data_ :: forall {a}. ListOf a -> Vector a
data_ } = Vector a
data_

    createTranscription :: CreateTranscription -> IO TranscriptionObject
createTranscription CreateTranscription
a = (ByteString, CreateTranscription) -> IO TranscriptionObject
createTranscription_ (ByteString
boundary, CreateTranscription
a)
    createTranslation :: CreateTranslation -> IO TranslationObject
createTranslation CreateTranslation
a = (ByteString, CreateTranslation) -> IO TranslationObject
createTranslation_ (ByteString
boundary, CreateTranslation
a)
    createEmbeddings :: CreateEmbeddings -> IO (Vector EmbeddingObject)
createEmbeddings CreateEmbeddings
a = IO (ListOf EmbeddingObject) -> IO (Vector EmbeddingObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (CreateEmbeddings -> IO (ListOf EmbeddingObject)
createEmbeddings_ CreateEmbeddings
a)
    listFineTuningJobs :: Maybe Text -> Maybe Natural -> IO (Vector JobObject)
listFineTuningJobs Maybe Text
a Maybe Natural
b = IO (ListOf JobObject) -> IO (Vector JobObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (Maybe Text -> Maybe Natural -> IO (ListOf JobObject)
listFineTuningJobs_ Maybe Text
a Maybe Natural
b)
    listFineTuningEvents :: FineTuningJobID
-> Maybe Text -> Maybe Natural -> IO (Vector EventObject)
listFineTuningEvents FineTuningJobID
a Maybe Text
b Maybe Natural
c = IO (ListOf EventObject) -> IO (Vector EventObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (FineTuningJobID
-> Maybe Text -> Maybe Natural -> IO (ListOf EventObject)
listFineTuningEvents_ FineTuningJobID
a Maybe Text
b Maybe Natural
c)
    listFineTuningCheckpoints :: FineTuningJobID
-> Maybe Text -> Maybe Natural -> IO (Vector CheckpointObject)
listFineTuningCheckpoints FineTuningJobID
a Maybe Text
b Maybe Natural
c =
        IO (ListOf CheckpointObject) -> IO (Vector CheckpointObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (FineTuningJobID
-> Maybe Text -> Maybe Natural -> IO (ListOf CheckpointObject)
listFineTuningCheckpoints_ FineTuningJobID
a Maybe Text
b Maybe Natural
c)
    listBatch :: Maybe Text -> Maybe Natural -> IO (Vector BatchObject)
listBatch Maybe Text
a Maybe Natural
b = IO (ListOf BatchObject) -> IO (Vector BatchObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (Maybe Text -> Maybe Natural -> IO (ListOf BatchObject)
listBatch_ Maybe Text
a Maybe Natural
b)
    uploadFile :: UploadFile -> IO FileObject
uploadFile UploadFile
a = (ByteString, UploadFile) -> IO FileObject
uploadFile_ (ByteString
boundary, UploadFile
a)
    listFiles :: Maybe Purpose
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> IO (Vector FileObject)
listFiles Maybe Purpose
a Maybe Natural
b Maybe Order
c Maybe Text
d = IO (ListOf FileObject) -> IO (Vector FileObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (Maybe Purpose
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> IO (ListOf FileObject)
listFiles_ Maybe Purpose
a Maybe Natural
b Maybe Order
c Maybe Text
d)
    addUploadPart :: UploadID -> AddUploadPart -> IO PartObject
addUploadPart UploadID
a AddUploadPart
b = UploadID -> (ByteString, AddUploadPart) -> IO PartObject
addUploadPart_ UploadID
a (ByteString
boundary, AddUploadPart
b)
    createImage :: CreateImage -> IO (Vector ImageObject)
createImage CreateImage
a = IO (ListOf ImageObject) -> IO (Vector ImageObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (CreateImage -> IO (ListOf ImageObject)
createImage_ CreateImage
a)
    createImageEdit :: CreateImageEdit -> IO (Vector ImageObject)
createImageEdit CreateImageEdit
a = IO (ListOf ImageObject) -> IO (Vector ImageObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector ((ByteString, CreateImageEdit) -> IO (ListOf ImageObject)
createImageEdit_ (ByteString
boundary, CreateImageEdit
a))
    createImageVariation :: CreateImageVariation -> IO (Vector ImageObject)
createImageVariation CreateImageVariation
a = IO (ListOf ImageObject) -> IO (Vector ImageObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector ((ByteString, CreateImageVariation) -> IO (ListOf ImageObject)
createImageVariation_ (ByteString
boundary, CreateImageVariation
a))
    listModels :: IO (Vector ModelObject)
listModels = IO (ListOf ModelObject) -> IO (Vector ModelObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector IO (ListOf ModelObject)
listModels_
    listAssistants :: Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector AssistantObject)
listAssistants Maybe Natural
a Maybe Order
b Maybe Text
c Maybe Text
d = IO (ListOf AssistantObject) -> IO (Vector AssistantObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (ListOf AssistantObject)
listAssistants_ Maybe Natural
a Maybe Order
b Maybe Text
c Maybe Text
d)
    listMessages :: ThreadID -> IO (Vector MessageObject)
listMessages ThreadID
a = IO (ListOf MessageObject) -> IO (Vector MessageObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (ThreadID -> IO (ListOf MessageObject)
listMessages_ ThreadID
a)
    listRuns :: ThreadID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector RunObject)
listRuns ThreadID
a Maybe Natural
b Maybe Order
c Maybe Text
d Maybe Text
e = IO (ListOf RunObject) -> IO (Vector RunObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (ThreadID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (ListOf RunObject)
listRuns_ ThreadID
a Maybe Natural
b Maybe Order
c Maybe Text
d Maybe Text
e)
    listRunSteps :: ThreadID
-> RunID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> IO (Vector RunStepObject)
listRunSteps ThreadID
a RunID
b Maybe Natural
c Maybe Order
d Maybe Text
e Maybe Text
f Maybe Text
g = IO (ListOf RunStepObject) -> IO (Vector RunStepObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (ThreadID
-> RunID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> IO (ListOf RunStepObject)
listRunSteps_ ThreadID
a RunID
b Maybe Natural
c Maybe Order
d Maybe Text
e Maybe Text
f Maybe Text
g)
    listVectorStores :: Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector VectorStoreObject)
listVectorStores Maybe Natural
a Maybe Order
b Maybe Text
c Maybe Text
d = IO (ListOf VectorStoreObject) -> IO (Vector VectorStoreObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (ListOf VectorStoreObject)
listVectorStores_ Maybe Natural
a Maybe Order
b Maybe Text
c Maybe Text
d)
    listVectorStoreFiles :: VectorStoreID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Status
-> IO (Vector VectorStoreFileObject)
listVectorStoreFiles VectorStoreID
a Maybe Natural
b Maybe Order
c Maybe Text
d Maybe Text
e Maybe Status
f =
        IO (ListOf VectorStoreFileObject)
-> IO (Vector VectorStoreFileObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (VectorStoreID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Status
-> IO (ListOf VectorStoreFileObject)
listVectorStoreFiles_ VectorStoreID
a Maybe Natural
b Maybe Order
c Maybe Text
d Maybe Text
e Maybe Status
f)
    listVectorStoreFilesInABatch :: VectorStoreID
-> VectorStoreFileBatchID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Status
-> IO (Vector VectorStoreFilesBatchObject)
listVectorStoreFilesInABatch VectorStoreID
a VectorStoreFileBatchID
b Maybe Natural
c Maybe Order
d Maybe Text
e Maybe Text
f Maybe Status
g =
        IO (ListOf VectorStoreFilesBatchObject)
-> IO (Vector VectorStoreFilesBatchObject)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (VectorStoreID
-> VectorStoreFileBatchID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Status
-> IO (ListOf VectorStoreFilesBatchObject)
listVectorStoreFilesInABatch_ VectorStoreID
a VectorStoreFileBatchID
b Maybe Natural
c Maybe Order
d Maybe Text
e Maybe Text
f Maybe Status
g)
    listResponseInputItems :: Text -> IO (Vector InputItem)
listResponseInputItems Text
a = IO (ListOf InputItem) -> IO (Vector InputItem)
forall a. IO (ListOf a) -> IO (Vector a)
toVector (Text -> IO (ListOf InputItem)
listResponseInputItems_ Text
a)

    -- Streaming implementation using http-client and SSE parsing
    createResponseStream :: CreateResponse -> (Either Text Value -> IO ()) -> IO ()
createResponseStream CreateResponse
req Either Text Value -> IO ()
onEvent = do
        let req' :: CreateResponse
req' = CreateResponse
req{ Responses.stream = Just True }
        String -> CreateResponse -> (Either Text Value -> IO ()) -> IO ()
forall a.
ToJSON a =>
String -> a -> (Either Text Value -> IO ()) -> IO ()
ssePostJSON String
"/v1/responses" CreateResponse
req' Either Text Value -> IO ()
onEvent

    createResponseStreamTyped
        :: CreateResponse
        -> (Either Text Responses.ResponseStreamEvent -> IO ())
        -> IO ()
    createResponseStreamTyped :: CreateResponse
-> (Either Text ResponseStreamEvent -> IO ()) -> IO ()
createResponseStreamTyped CreateResponse
req Either Text ResponseStreamEvent -> IO ()
onEvent =
        CreateResponse -> (Either Text Value -> IO ()) -> IO ()
createResponseStream CreateResponse
req ((Either Text Value -> IO ()) -> IO ())
-> (Either Text Value -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Either Text Value
ev -> case Either Text Value
ev of
            Left Text
err -> Either Text ResponseStreamEvent -> IO ()
onEvent (Text -> Either Text ResponseStreamEvent
forall a b. a -> Either a b
Left Text
err)
            Right Value
val -> case Value -> Result ResponseStreamEvent
forall a. FromJSON a => Value -> Result a
Aeson.fromJSON Value
val of
                Aeson.Error String
msg -> Either Text ResponseStreamEvent -> IO ()
onEvent (Text -> Either Text ResponseStreamEvent
forall a b. a -> Either a b
Left (String -> Text
Text.pack String
msg))
                Aeson.Success ResponseStreamEvent
e -> Either Text ResponseStreamEvent -> IO ()
onEvent (ResponseStreamEvent -> Either Text ResponseStreamEvent
forall a b. b -> Either a b
Right ResponseStreamEvent
e)

    -- Streaming implementation for chat completions
    createChatCompletionStream :: CreateChatCompletion -> (Either Text Value -> IO ()) -> IO ()
createChatCompletionStream CreateChatCompletion
req Either Text Value -> IO ()
onEvent = do
        let req' :: CreateChatCompletion
req' = CreateChatCompletion
req{ Chat.Completions.stream = Just True }
        String
-> CreateChatCompletion -> (Either Text Value -> IO ()) -> IO ()
forall a.
ToJSON a =>
String -> a -> (Either Text Value -> IO ()) -> IO ()
ssePostJSON String
"/v1/chat/completions" CreateChatCompletion
req' Either Text Value -> IO ()
onEvent

    createChatCompletionStreamTyped
        :: CreateChatCompletion
        -> (Either Text Chat.Completions.ChatCompletionStreamEvent -> IO ())
        -> IO ()
    createChatCompletionStreamTyped :: CreateChatCompletion
-> (Either Text ChatCompletionStreamEvent -> IO ()) -> IO ()
createChatCompletionStreamTyped CreateChatCompletion
req Either Text ChatCompletionStreamEvent -> IO ()
onEvent =
        CreateChatCompletion -> (Either Text Value -> IO ()) -> IO ()
createChatCompletionStream CreateChatCompletion
req ((Either Text Value -> IO ()) -> IO ())
-> (Either Text Value -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Either Text Value
ev -> case Either Text Value
ev of
            Left Text
err -> Either Text ChatCompletionStreamEvent -> IO ()
onEvent (Text -> Either Text ChatCompletionStreamEvent
forall a b. a -> Either a b
Left Text
err)
            Right Value
val -> case Value -> Result ChatCompletionStreamEvent
forall a. FromJSON a => Value -> Result a
Aeson.fromJSON Value
val of
                Aeson.Error String
msg -> Either Text ChatCompletionStreamEvent -> IO ()
onEvent (Text -> Either Text ChatCompletionStreamEvent
forall a b. a -> Either a b
Left (String -> Text
Text.pack String
msg))
                Aeson.Success ChatCompletionStreamEvent
e -> Either Text ChatCompletionStreamEvent -> IO ()
onEvent (ChatCompletionStreamEvent -> Either Text ChatCompletionStreamEvent
forall a b. b -> Either a b
Right ChatCompletionStreamEvent
e)

    ssePostJSON :: ToJSON a
                => String
                -> a
                -> (Either Text Aeson.Value -> IO ())
                -> IO ()
    ssePostJSON :: forall a.
ToJSON a =>
String -> a -> (Either Text Value -> IO ()) -> IO ()
ssePostJSON String
path a
body Either Text Value -> IO ()
onEvent = do
        let base :: BaseUrl
base = ClientEnv -> BaseUrl
Client.baseUrl ClientEnv
clientEnv
        let secure :: Bool
secure = case BaseUrl -> Scheme
Client.baseUrlScheme BaseUrl
base of
                Scheme
Client.Http -> Bool
False
                Scheme
Client.Https -> Bool
True
        let host :: ByteString
host = String -> ByteString
S8.pack (BaseUrl -> String
Client.baseUrlHost BaseUrl
base)
        let port :: Int
port = BaseUrl -> Int
Client.baseUrlPort BaseUrl
base
        let basePath :: String
basePath = BaseUrl -> String
Client.baseUrlPath BaseUrl
base
        let fullPath :: ByteString
fullPath = String -> ByteString
S8.pack (String -> String
normalizePath String
basePath String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
path)

        let headers0 :: [(HeaderName, ByteString)]
headers0 =
                [ (HeaderName
"Authorization", String -> ByteString
S8.pack (Text -> String
Text.unpack Text
authorization))
                , (HeaderName
"Accept", ByteString
"text/event-stream")
                , (HeaderName
"Content-Type", ByteString
"application/json")
                ]
        let headers1 :: [(HeaderName, ByteString)]
headers1 = case Maybe Text
organizationID of
                Maybe Text
Nothing -> [(HeaderName, ByteString)]
headers0
                Just Text
org -> (HeaderName
"OpenAI-Organization", String -> ByteString
S8.pack (Text -> String
Text.unpack Text
org)) (HeaderName, ByteString)
-> [(HeaderName, ByteString)] -> [(HeaderName, ByteString)]
forall a. a -> [a] -> [a]
: [(HeaderName, ByteString)]
headers0
        let headers :: [(HeaderName, ByteString)]
headers = case Maybe Text
projectID of
                Maybe Text
Nothing -> [(HeaderName, ByteString)]
headers1
                Just Text
proj -> (HeaderName
"OpenAI-Project", String -> ByteString
S8.pack (Text -> String
Text.unpack Text
proj)) (HeaderName, ByteString)
-> [(HeaderName, ByteString)] -> [(HeaderName, ByteString)]
forall a. a -> [a] -> [a]
: [(HeaderName, ByteString)]
headers1

        let request :: Request
request = Request
HTTP.Client.defaultRequest
                { HTTP.Client.secure = secure
                , HTTP.Client.host = host
                , HTTP.Client.port = port
                , HTTP.Client.method = "POST"
                , HTTP.Client.path = fullPath
                , HTTP.Client.requestHeaders = headers
                , HTTP.Client.requestBody = HTTP.Client.RequestBodyLBS (Aeson.encode body)
                , HTTP.Client.responseTimeout = HTTP.Client.responseTimeoutNone
                }

        Request -> Manager -> (Response BodyReader -> IO ()) -> IO ()
forall a.
Request -> Manager -> (Response BodyReader -> IO a) -> IO a
HTTP.Client.withResponse Request
request (ClientEnv -> Manager
Client.manager ClientEnv
clientEnv) ((Response BodyReader -> IO ()) -> IO ())
-> (Response BodyReader -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Response BodyReader
response -> do
            -- Short-circuit on non-2xx HTTP statuses and surface a single error event
            let st :: Status
st = Response BodyReader -> Status
forall body. Response body -> Status
HTTP.Client.responseStatus Response BodyReader
response
            if Bool -> Bool
not (Status -> Bool
Status.statusIsSuccessful Status
st)
                then do
                    [ByteString]
bodyChunks <- BodyReader -> IO [ByteString]
HTTP.Client.brConsume (Response BodyReader -> BodyReader
forall body. Response body -> body
HTTP.Client.responseBody Response BodyReader
response)
                    let errBody :: ByteString
errBody = [ByteString] -> ByteString
SBS.concat [ByteString]
bodyChunks
                    let msg :: Text
msg =
                            Text
"HTTP error "
                            Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Int -> Text
forall number. Integral number => number -> Text
renderIntegral (Status -> Int
Status.statusCode Status
st)
                            Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" "
                            Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> (String -> Text
Text.pack (ByteString -> String
S8.unpack (Status -> ByteString
Status.statusMessage Status
st)))
                            Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> (if ByteString -> Bool
SBS.null ByteString
errBody then Text
"" else Text
": " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> String -> Text
Text.pack (ByteString -> String
S8.unpack ByteString
errBody))
                    Either Text Value -> IO ()
onEvent (Text -> Either Text Value
forall a b. a -> Either a b
Left Text
msg)
                else do
                    let br :: BodyReader
br = Response BodyReader -> BodyReader
forall body. Response body -> body
HTTP.Client.responseBody Response BodyReader
response
                    IORef ByteString
lineBufRef <- ByteString -> IO (IORef ByteString)
forall a. a -> IO (IORef a)
IORef.newIORef ByteString
SBS.empty
                    IORef [ByteString]
eventBufRef <- [ByteString] -> IO (IORef [ByteString])
forall a. a -> IO (IORef a)
IORef.newIORef ([] :: [SBS.ByteString])
                    let flushEvent :: IO Bool
flushEvent = do
                            [ByteString]
es <- IORef [ByteString]
-> ([ByteString] -> ([ByteString], [ByteString]))
-> IO [ByteString]
forall a b. IORef a -> (a -> (a, b)) -> IO b
IORef.atomicModifyIORef IORef [ByteString]
eventBufRef (\[ByteString]
buf -> ([], [ByteString] -> [ByteString]
forall a. [a] -> [a]
reverse [ByteString]
buf))
                            if [ByteString] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [ByteString]
es
                                then Bool -> IO Bool
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
                                else do
                                    let payload :: ByteString
payload = [ByteString] -> ByteString
S8.concat [ByteString]
es
                                    if ByteString
payload ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
"[DONE]"
                                        then Bool -> IO Bool
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True
                                        else case (ByteString -> Either String Value
forall a. FromJSON a => ByteString -> Either String a
Aeson.eitherDecodeStrict ByteString
payload :: Either String Aeson.Value) of
                                            Left String
err -> Either Text Value -> IO ()
onEvent (Text -> Either Text Value
forall a b. a -> Either a b
Left (String -> Text
Text.pack String
err)) IO () -> IO Bool -> IO Bool
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Bool -> IO Bool
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
                                            Right Value
val -> Either Text Value -> IO ()
onEvent (Value -> Either Text Value
forall a b. b -> Either a b
Right Value
val) IO () -> IO Bool -> IO Bool
forall a b. IO a -> IO b -> IO b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Bool -> IO Bool
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False

                    -- Note: SSE frames can include fields like "event:" and others.
                    -- We currently ignore all non-"data:" fields and only buffer
                    -- "data:" lines; an empty line flushes a complete event.
                    let handleLine :: ByteString -> IO Bool
handleLine ByteString
line = do
                            let l :: ByteString
l = ByteString -> ByteString
stripCR ByteString
line
                            if ByteString -> Bool
S8.null ByteString
l
                                then IO Bool
flushEvent
                                else if ByteString
"data:" ByteString -> ByteString -> Bool
`S8.isPrefixOf` ByteString
l
                                    then do
                                        let d :: ByteString
d = (Char -> Bool) -> ByteString -> ByteString
S8.dropWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
' ') (Int -> ByteString -> ByteString
S8.drop Int
5 ByteString
l)
                                        IORef [ByteString] -> ([ByteString] -> [ByteString]) -> IO ()
forall a. IORef a -> (a -> a) -> IO ()
IORef.modifyIORef' IORef [ByteString]
eventBufRef (ByteString
dByteString -> [ByteString] -> [ByteString]
forall a. a -> [a] -> [a]
:)
                                        Bool -> IO Bool
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
                                    else Bool -> IO Bool
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False

                    let loop :: IO ()
loop = do
                            ByteString
chunk <- BodyReader -> BodyReader
HTTP.Client.brRead BodyReader
br
                            if ByteString -> Bool
SBS.null ByteString
chunk
                                then do
                                    -- flush any pending event at EOF
                                    Bool
_ <- IO Bool
flushEvent
                                    () -> IO ()
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
                                else do
                                    ByteString
prev <- IORef ByteString -> BodyReader
forall a. IORef a -> IO a
IORef.readIORef IORef ByteString
lineBufRef
                                    let combined :: ByteString
combined = ByteString
prev ByteString -> ByteString -> ByteString
forall a. Semigroup a => a -> a -> a
<> ByteString
chunk
                                    let ls :: [ByteString]
ls = Char -> ByteString -> [ByteString]
S8.split Char
'\n' ByteString
combined
                                    case [ByteString] -> Maybe ([ByteString], ByteString)
forall {b}. [b] -> Maybe ([b], b)
unsnoc [ByteString]
ls of
                                        Maybe ([ByteString], ByteString)
Nothing -> IO ()
loop
                                        Just ([ByteString]
completeLines, ByteString
lastLine) -> do
                                            IORef ByteString -> ByteString -> IO ()
forall a. IORef a -> a -> IO ()
IORef.writeIORef IORef ByteString
lineBufRef ByteString
lastLine
                                            Bool
stop <- (Bool -> ByteString -> IO Bool) -> Bool -> [ByteString] -> IO Bool
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM (\Bool
acc ByteString
ln -> if Bool
acc then Bool -> IO Bool
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True else ByteString -> IO Bool
handleLine ByteString
ln) Bool
False [ByteString]
completeLines
                                            if Bool
stop then () -> IO ()
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure () else IO ()
loop

                    IO ()
loop

    normalizePath :: String -> String
normalizePath String
p = case String
p of
        String
"" -> String
""
        (Char
'/':String
_) -> String
p
        String
_ -> Char
'/'Char -> String -> String
forall a. a -> [a] -> [a]
:String
p

    stripCR :: ByteString -> ByteString
stripCR ByteString
bs = case ByteString -> Maybe (ByteString, Char)
S8.unsnoc ByteString
bs of
        Just (ByteString
initBs, Char
'\r') -> ByteString
initBs
        Maybe (ByteString, Char)
_ -> ByteString
bs

    unsnoc :: [b] -> Maybe ([b], b)
unsnoc [] = Maybe ([b], b)
forall a. Maybe a
Nothing
    unsnoc [b]
xs = ([b], b) -> Maybe ([b], b)
forall a. a -> Maybe a
Just ([b] -> [b]
forall a. HasCallStack => [a] -> [a]
init [b]
xs, [b] -> b
forall a. HasCallStack => [a] -> a
last [b]
xs)

-- | Hard-coded boundary to simplify the user-experience
--
-- I don't understand why `multipart-servant-client` insists on generating a
-- fresh boundary for each request (or why it doesn't handle that for you)
boundary :: ByteString
boundary :: ByteString
boundary = ByteString
"j3qdD3XtDVjvva8IIqoBzHQAYwCenObtPMkxAFnylwFyU5xffWKoYrY"

-- | API methods
data Methods = Methods
    { Methods -> CreateSpeech -> IO ByteString
createSpeech :: CreateSpeech -> IO ByteString
    , Methods -> CreateTranscription -> IO TranscriptionObject
createTranscription :: CreateTranscription -> IO TranscriptionObject
    , Methods -> CreateTranslation -> IO TranslationObject
createTranslation :: CreateTranslation -> IO TranslationObject
    , Methods -> CreateChatCompletion -> IO ChatCompletionObject
createChatCompletion :: CreateChatCompletion -> IO ChatCompletionObject
    , Methods
-> CreateChatCompletion -> (Either Text Value -> IO ()) -> IO ()
createChatCompletionStream
        :: CreateChatCompletion
        -> (Either Text Aeson.Value -> IO ())
        -> IO ()
    , Methods
-> CreateChatCompletion
-> (Either Text ChatCompletionStreamEvent -> IO ())
-> IO ()
createChatCompletionStreamTyped
        :: CreateChatCompletion
        -> (Either Text Chat.Completions.ChatCompletionStreamEvent -> IO ())
        -> IO ()
    , Methods -> CreateResponse -> IO ResponseObject
createResponse :: CreateResponse -> IO ResponseObject
    , Methods -> CreateResponse -> (Either Text Value -> IO ()) -> IO ()
createResponseStream
        :: CreateResponse
        -> (Either Text Aeson.Value -> IO ())
        -> IO ()
    , Methods -> CreateEmbeddings -> IO (Vector EmbeddingObject)
createEmbeddings :: CreateEmbeddings -> IO (Vector EmbeddingObject)
    , Methods
-> CreateResponse
-> (Either Text ResponseStreamEvent -> IO ())
-> IO ()
createResponseStreamTyped
        :: CreateResponse
        -> (Either Text Responses.ResponseStreamEvent -> IO ())
        -> IO ()
    , Methods -> CreateFineTuningJob -> IO JobObject
createFineTuningJob :: CreateFineTuningJob -> IO JobObject
    , Methods -> Maybe Text -> Maybe Natural -> IO (Vector JobObject)
listFineTuningJobs
        :: Maybe Text
        -- ^ after
        -> Maybe Natural
        -- ^ limit
        -> IO (Vector JobObject)
    , Methods
-> FineTuningJobID
-> Maybe Text
-> Maybe Natural
-> IO (Vector EventObject)
listFineTuningEvents
        :: FineTuningJobID
        -- ^
        -> Maybe Text
        -- ^ after
        -> Maybe Natural
        -- ^ limit
        -> IO (Vector EventObject)
    , Methods
-> FineTuningJobID
-> Maybe Text
-> Maybe Natural
-> IO (Vector CheckpointObject)
listFineTuningCheckpoints
        :: FineTuningJobID
        -- ^
        -> Maybe Text
        -- ^ after
        -> Maybe Natural
        -- ^ limit
        -> IO (Vector CheckpointObject)
    , Methods -> FineTuningJobID -> IO JobObject
retrieveFineTuningJob :: FineTuningJobID -> IO JobObject
    , Methods -> FineTuningJobID -> IO JobObject
cancelFineTuning :: FineTuningJobID -> IO JobObject
    , Methods -> CreateBatch -> IO BatchObject
createBatch :: CreateBatch -> IO BatchObject
    , Methods -> BatchID -> IO BatchObject
retrieveBatch :: BatchID -> IO BatchObject
    , Methods -> BatchID -> IO BatchObject
cancelBatch :: BatchID -> IO BatchObject
    , Methods -> Maybe Text -> Maybe Natural -> IO (Vector BatchObject)
listBatch
        :: Maybe Text
        -- ^ after
        -> Maybe Natural
        -- ^ limit
        -> IO (Vector BatchObject)
    , Methods -> UploadFile -> IO FileObject
uploadFile :: UploadFile -> IO FileObject
    , Methods
-> Maybe Purpose
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> IO (Vector FileObject)
listFiles
        :: Maybe Files.Purpose
        -- ^ purpose
        -> Maybe Natural
        -- ^ limit
        -> Maybe Order
        -- ^ order
        -> Maybe Text
        -- ^ after
        -> IO (Vector FileObject)
    , Methods -> FileID -> IO FileObject
retrieveFile :: FileID -> IO FileObject
    , Methods -> FileID -> IO DeletionStatus
deleteFile :: FileID -> IO DeletionStatus
    , Methods -> FileID -> IO ByteString
retrieveFileContent :: FileID -> IO ByteString
    , Methods -> CreateUpload -> IO (UploadObject (Maybe Void))
createUpload
        :: CreateUpload -> IO (UploadObject (Maybe Void))
    , Methods -> UploadID -> AddUploadPart -> IO PartObject
addUploadPart :: UploadID -> AddUploadPart -> IO PartObject
    , Methods
-> UploadID -> CompleteUpload -> IO (UploadObject FileObject)
completeUpload
        :: UploadID -> CompleteUpload -> IO (UploadObject FileObject)
    , Methods -> UploadID -> IO (UploadObject (Maybe Void))
cancelUpload :: UploadID -> IO (UploadObject (Maybe Void))
    , Methods -> CreateImage -> IO (Vector ImageObject)
createImage :: CreateImage -> IO (Vector ImageObject)
    , Methods -> CreateImageEdit -> IO (Vector ImageObject)
createImageEdit :: CreateImageEdit -> IO (Vector ImageObject)
    , Methods -> CreateImageVariation -> IO (Vector ImageObject)
createImageVariation :: CreateImageVariation -> IO (Vector ImageObject)
    , Methods -> IO (Vector ModelObject)
listModels :: IO (Vector ModelObject)
    , Methods -> Model -> IO ModelObject
retrieveModel :: Model -> IO ModelObject
    , Methods -> Model -> IO DeletionStatus
deleteModel :: Model -> IO DeletionStatus
    , Methods -> CreateModeration -> IO Moderation
createModeration :: CreateModeration -> IO Moderation
    , Methods -> CreateAssistant -> IO AssistantObject
createAssistant :: CreateAssistant -> IO AssistantObject
    , Methods
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector AssistantObject)
listAssistants
        :: Maybe Natural
        -- ^ limit
        -> Maybe Order
        -- ^ order
        -> Maybe Text
        -- ^ after
        -> Maybe Text
        -- ^ before
        -> IO (Vector AssistantObject)
    , Methods -> AssistantID -> IO AssistantObject
retrieveAssistant :: AssistantID -> IO AssistantObject
    , Methods -> AssistantID -> ModifyAssistant -> IO AssistantObject
modifyAssistant :: AssistantID -> ModifyAssistant -> IO AssistantObject
    , Methods -> AssistantID -> IO DeletionStatus
deleteAssistant :: AssistantID -> IO DeletionStatus
    , Methods -> Thread -> IO ThreadObject
createThread :: Thread -> IO ThreadObject
    , Methods -> ThreadID -> IO ThreadObject
retrieveThread :: ThreadID -> IO ThreadObject
    , Methods -> ThreadID -> ModifyThread -> IO ThreadObject
modifyThread :: ThreadID -> ModifyThread -> IO ThreadObject
    , Methods -> ThreadID -> IO DeletionStatus
deleteThread :: ThreadID -> IO DeletionStatus
    , Methods -> ThreadID -> Message -> IO MessageObject
createMessage :: ThreadID -> Message -> IO MessageObject
    , Methods -> ThreadID -> IO (Vector MessageObject)
listMessages :: ThreadID -> IO (Vector MessageObject)
    , Methods -> ThreadID -> MessageID -> IO MessageObject
retrieveMessage :: ThreadID -> MessageID -> IO MessageObject
    , Methods
-> ThreadID -> MessageID -> ModifyMessage -> IO MessageObject
modifyMessage
        :: ThreadID -> MessageID -> ModifyMessage -> IO MessageObject
    , Methods -> ThreadID -> MessageID -> IO DeletionStatus
deleteMessage :: ThreadID -> MessageID -> IO DeletionStatus
    , Methods -> ThreadID -> Maybe Text -> CreateRun -> IO RunObject
createRun
        :: ThreadID
        -- ^
        -> Maybe Text
        -- ^ include[]
        -> CreateRun
        -- ^
        -> IO RunObject
    , Methods -> CreateThreadAndRun -> IO RunObject
createThreadAndRun :: CreateThreadAndRun -> IO RunObject
    , Methods
-> ThreadID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector RunObject)
listRuns
        :: ThreadID
        -- ^
        -> Maybe Natural
        -- ^ limit
        -> Maybe Order
        -- ^ order
        -> Maybe Text
        -- ^ after
        -> Maybe Text
        -- ^ before
        -> IO (Vector RunObject)
    , Methods -> ThreadID -> RunID -> IO RunObject
retrieveRun :: ThreadID -> RunID -> IO RunObject
    , Methods -> ThreadID -> RunID -> ModifyRun -> IO RunObject
modifyRun :: ThreadID -> RunID -> ModifyRun -> IO RunObject
    , Methods
-> ThreadID -> RunID -> SubmitToolOutputsToRun -> IO RunObject
submitToolOutputsToRun
        :: ThreadID -> RunID -> SubmitToolOutputsToRun -> IO RunObject
    , Methods -> ThreadID -> RunID -> IO RunObject
cancelRun :: ThreadID -> RunID -> IO RunObject
    , Methods
-> ThreadID
-> RunID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> IO (Vector RunStepObject)
listRunSteps
        :: ThreadID
        -- ^
        -> RunID
        -- ^
        -> Maybe Natural
        -- ^ limit
        -> Maybe Order
        -- ^ order
        -> Maybe Text
        -- ^ after
        -> Maybe Text
        -- ^ before
        -> Maybe Text
        -- ^ include[]
        -> IO (Vector RunStepObject)
    , Methods
-> ThreadID -> RunID -> StepID -> Maybe Text -> IO RunStepObject
retrieveRunStep
        :: ThreadID
        -- ^
        -> RunID
        -- ^
        -> StepID
        -- ^
        -> Maybe Text
        -- ^ include[]
        -> IO RunStepObject
    , Methods -> Text -> IO ResponseObject
retrieveResponse :: Text -> IO ResponseObject
    , Methods -> Text -> IO ResponseObject
cancelResponse :: Text -> IO ResponseObject
    , Methods -> Text -> IO (Vector InputItem)
listResponseInputItems :: Text -> IO (Vector InputItem)
    , Methods -> CreateVectorStore -> IO VectorStoreObject
createVectorStore :: CreateVectorStore -> IO VectorStoreObject
    , Methods
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> IO (Vector VectorStoreObject)
listVectorStores
        :: Maybe Natural
        -- ^ limit
        -> Maybe Order
        -- ^ order
        -> Maybe Text
        -- ^ after
        -> Maybe Text
        -- ^ before
        -> IO (Vector VectorStoreObject)
    , Methods -> VectorStoreID -> IO VectorStoreObject
retrieveVectorStore :: VectorStoreID -> IO VectorStoreObject
    , Methods
-> VectorStoreID -> ModifyVectorStore -> IO VectorStoreObject
modifyVectorStore
        :: VectorStoreID -> ModifyVectorStore -> IO VectorStoreObject
    , Methods -> VectorStoreID -> IO DeletionStatus
deleteVectorStore :: VectorStoreID -> IO DeletionStatus
    , Methods
-> VectorStoreID
-> CreateVectorStoreFile
-> IO VectorStoreFileObject
createVectorStoreFile
        :: VectorStoreID -> CreateVectorStoreFile -> IO VectorStoreFileObject
    , Methods
-> VectorStoreID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Status
-> IO (Vector VectorStoreFileObject)
listVectorStoreFiles
        :: VectorStoreID
        -- ^
        -> Maybe Natural
        -- ^ limit
        -> Maybe Order
        -- ^ order
        -> Maybe Text
        -- ^ after
        -> Maybe Text
        -- ^ before
        -> Maybe VectorStores.Status.Status
        -- ^ filter
        -> IO (Vector VectorStoreFileObject)
    , Methods
-> VectorStoreID -> VectorStoreFileID -> IO VectorStoreFileObject
retrieveVectorStoreFile
        :: VectorStoreID -> VectorStoreFileID -> IO VectorStoreFileObject
    , Methods -> VectorStoreID -> VectorStoreFileID -> IO DeletionStatus
deleteVectorStoreFile
        :: VectorStoreID -> VectorStoreFileID -> IO DeletionStatus
    , Methods
-> VectorStoreID
-> CreateVectorStoreFileBatch
-> IO VectorStoreFilesBatchObject
createVectorStoreFileBatch
        :: VectorStoreID
        -> CreateVectorStoreFileBatch
        -> IO VectorStoreFilesBatchObject
    , Methods
-> VectorStoreID
-> VectorStoreFileBatchID
-> IO VectorStoreFilesBatchObject
retrieveVectorStoreFileBatch
        :: VectorStoreID
        -> VectorStoreFileBatchID
        -> IO VectorStoreFilesBatchObject
    , Methods
-> VectorStoreID
-> VectorStoreFileBatchID
-> IO VectorStoreFilesBatchObject
cancelVectorStoreFileBatch
        :: VectorStoreID
        -> VectorStoreFileBatchID
        -> IO VectorStoreFilesBatchObject
    , Methods
-> VectorStoreID
-> VectorStoreFileBatchID
-> Maybe Natural
-> Maybe Order
-> Maybe Text
-> Maybe Text
-> Maybe Status
-> IO (Vector VectorStoreFilesBatchObject)
listVectorStoreFilesInABatch
        :: VectorStoreID
        -- ^
        -> VectorStoreFileBatchID
        -- ^
        -> Maybe Natural
        -- ^ limit
        -> Maybe Order
        -- ^ order
        -> Maybe Text
        -- ^ after
        -> Maybe Text
        -- ^ before
        -> Maybe VectorStores.Status.Status
        -- ^ filter
        -> IO (Vector VectorStoreFilesBatchObject)
    }

-- | Servant API
type API
    =   Header' [ Required, Strict ] "Authorization" Text
    :>  Header' [ Optional, Strict ] "OpenAI-Organization" Text
    :>  Header' [ Optional, Strict ] "OpenAI-Project" Text
    :>  "v1"
    :>  (     Audio.API
        :<|>  Chat.Completions.API
        :<|>  Responses.API
        :<|>  Embeddings.API
        :<|>  FineTuning.Jobs.API
        :<|>  Batches.API
        :<|>  Files.API
        :<|>  Images.API
        :<|>  Uploads.API
        :<|>  Models.API
        :<|>  Moderations.API
        :<|>  Assistants.API
        :<|>  Threads.API
        :<|>  Messages.API
        :<|>  Threads.Runs.API
        :<|>  Threads.Runs.Steps.API
        :<|>  VectorStores.API
        :<|>  VectorStores.Files.API
        :<|>  VectorStores.FileBatches.API
        )