dependencies: [
    .package(url: "https://github.com/MacPaw/OpenAI.git", .branch("main"))
]

let openAI = OpenAI(apiToken: "YOUR_TOKEN_HERE")

    struct CompletionsQuery: Codable {
        /// ID of the model to use.
        let model: Model
        /// The prompt(s) to generate completions for, encoded as a string, array of strings, array of tokens, or array of token arrays.
        let prompt: String
        /// What sampling temperature to use. Higher values means the model will take more risks. Try 0.9 for more creative applications, and 0 (argmax sampling) for ones with a well-defined answer.
        let temperature: Int
        /// The maximum number of tokens to generate in the completion.
        let max_tokens: Int
        /// An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered.
        let top_p: Int
        /// Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.
        let frequency_penalty: Int
        /// Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.
        let presence_penalty: Int
        /// Up to 4 sequences where the API will stop generating further tokens. The returned text will not contain the stop sequence.
        let stop: [String]
    }

struct CompletionsResult: Codable {
    struct Choice: Codable {
        let text: String
        let index: Int
    }

    let id: String
    let object: String
    let created: TimeInterval
    let model: Model
    let choices: [Choice]
}

openAI.completions(query: .init(model: .textDavinci_003, prompt: "What is 42?", temperature: 0, max_tokens: 100, top_p: 1, frequency_penalty: 0, presence_penalty: 0, stop: ["\\n"])) { result in
  //Handle response here
}

struct ImagesQuery: Codable {
    /// A text description of the desired image(s). The maximum length is 1000 characters.
    let prompt: String
    /// The number of images to generate. Must be between 1 and 10.
    let n: Int?
    /// The size of the generated images. Must be one of 256x256, 512x512, or 1024x1024.
    let size: String?
}

struct ImagesResult: Codable {
    struct URLResult: Codable {
        let url: String
    }
    let created: TimeInterval
    let data: [URLResult]
}

openAI.images(query: .init(prompt: "White cat with heterochromia sitting on the kitchen table", n: 1, size: "1024x1024")) { result in
  //Handle response here
}

struct EmbeddingsQuery: Codable {
    /// ID of the model to use.
    let model: Model
    /// Input text to get embeddings for
    let input: String
}

struct EmbeddingsResult: Codable {
    
    struct Embedding: Codable {
        
        let object: String
        let embedding: [Double]
        let index: Int
    }
    let data: [Embedding]
}

openAI.embeddings(query: .init(model: .textSearchBabbadgeDoc, input: "The food was delicious and the waiter...")) { result in
  //Handle response here
}

public struct Vector {
    
    /// Returns the similarity between two vectors
    ///
    /// - Parameters:
    ///     - a: The first vector
    ///     - b: The second vector
    public static func cosineSimilarity(a: [Double], b: [Double]) -> Double {
        return dot(a, b) / (mag(a) * mag(b))
    }

    /// Returns the difference between two vectors. Cosine distance is defined as `1 - cosineSimilarity(a, b)`
    ///
    /// - Parameters:
    ///     - a: The first vector
    ///     - b: The second vector
    public func cosineDifference(a: [Double], b: [Double]) -> Double {
        return 1 - Self.cosineSimilarity(a: a, b: b)
    }
}

let vector1 = [0.213123, 0.3214124, 0.421412, 0.3214521251, 0.412412, 0.3214124, 0.1414124, 0.3214521251, 0.213123, 0.3214124, 0.1414124, 0.4214214, 0.213123, 0.3214124, 0.1414124, 0.3214521251, 0.213123, 0.3214124, 0.1414124, 0.3214521251]
let vector2 = [0.213123, 0.3214124, 0.1414124, 0.3214521251, 0.213123, 0.3214124, 0.1414124, 0.3214521251, 0.213123, 0.511515, 0.1414124, 0.3214521251, 0.213123, 0.3214124, 0.1414124, 0.3214521251, 0.213123, 0.3214124, 0.1414124, 0.3213213]
let similarity = Vector.cosineSimilarity(a: vector1, b: vector2)
print(similarity) //0.9510201910206734