openai 1.1.1 → 2.0.2

package/dist/lib.js

@@ -1,179 +0,0 @@
-import { ContentLabel, } from './types.js';
-import { Transform } from 'stream';
-import FormData from 'form-data';
-import fetch from 'node-fetch';
-const baseUrl = 'https://api.openai.com';
-const defaultVersion = 'v1';
-export class OpenAI {
-    constructor(apiKey, organizationId, version = defaultVersion) {
-        this.headers = {
-            'authorization': `Bearer ${apiKey}`,
-            'content-type': 'application/json',
-        };
-        if (organizationId) {
-            this.headers['openai-organization'] = organizationId;
-        }
-        this.url = `${baseUrl}/${version}`;
-    }
-    getEngines() {
-        return this.request('/engines', 'GET').then((r) => r.data);
-    }
-    getEngine(engine) {
-        return this.request(`/engines/${engine}`, 'GET');
-    }
-    complete(engine, options) {
-        return this.request(`/engines/${engine}/completions`, 'POST', options);
-    }
-    completeFromModel(fineTunedModel, options) {
-        return this.request(`/completions`, 'POST', { ...options, model: fineTunedModel });
-    }
-    async completeAndStream(engine, options) {
-        const request = await this.requestRaw(`/engines/${engine}/completions`, 'POST', { ...options, stream: true });
-        return request.body.pipe(this.eventStreamTransformer());
-    }
-    async completeFromModelAndStream(fineTunedModel, options) {
-        const request = await this.requestRaw(`/completions`, 'POST', {
-            ...options,
-            model: fineTunedModel,
-            stream: true,
-        });
-        return request.body.pipe(this.eventStreamTransformer());
-    }
-    async contentFilter(content, user) {
-        const completion = await this.complete('content-filter-alpha-c4', {
-            prompt: `<|endoftext|>${content}\n--\nLabel:`,
-            temperature: 0,
-            max_tokens: 1,
-            top_p: 1,
-            frequency_penalty: 0,
-            presence_penalty: 0,
-            logprobs: 10,
-            user,
-        });
-        let label = Number(completion.choices[0].text);
-        if (label === ContentLabel.Unsafe) {
-            const logprobs = completion.choices[0].logprobs?.top_logprobs[0];
-            if (logprobs && logprobs['2'] < -0.355) {
-                if (logprobs['0'] && logprobs['1']) {
-                    label = logprobs['0'] >= logprobs['1'] ? ContentLabel.Safe : ContentLabel.Sensitive;
-                }
-                else if (logprobs['0']) {
-                    label = ContentLabel.Safe;
-                }
-                else if (logprobs['1']) {
-                    label = ContentLabel.Sensitive;
-                }
-            }
-        }
-        if (![0, 1, 2].includes(label)) {
-            label = ContentLabel.Unsafe;
-        }
-        return label;
-    }
-    search(engine, options) {
-        return this.request(`/engines/${engine}/search`, 'POST', options).then((r) => r.data);
-    }
-    classify(options) {
-        return this.request('/classifications', 'POST', options);
-    }
-    answer(options) {
-        return this.request('/answers', 'POST', options);
-    }
-    getFiles() {
-        return this.request('/files', 'GET').then((r) => r.data);
-    }
-    uploadFile(file, jsonlines, purpose) {
-        const data = new FormData();
-        let fileJsonlines;
-        if (Array.isArray(jsonlines)) {
-            if (typeof jsonlines[0] === 'object') {
-                jsonlines = jsonlines.map((j) => JSON.stringify(j));
-            }
-            fileJsonlines = jsonlines.join('\n');
-        }
-        else {
-            fileJsonlines = jsonlines;
-        }
-        data.append('file', fileJsonlines, file);
-        data.append('purpose', purpose);
-        return this.request('/files', 'POST', data);
-    }
-    getFile(fileId) {
-        return this.request(`/files/${fileId}`, 'GET');
-    }
-    deleteFile(fileId) {
-        return this.request(`/files/${fileId}`, 'DELETE');
-    }
-    finetune(options) {
-        return this.request(`/fine-tunes`, 'POST', options);
-    }
-    getFinetunes() {
-        return this.request('/fine-tunes', 'GET').then((r) => r.data);
-    }
-    getFinetune(finetuneId) {
-        return this.request(`/fine-tunes/${finetuneId}`, 'GET');
-    }
-    cancelFinetune(finetuneId) {
-        return this.request(`/fine-tunes/${finetuneId}/cancel`, 'POST');
-    }
-    getFinetuneEvents(finetuneId) {
-        return this.request(`/fine-tunes/${finetuneId}/events`, 'GET').then((r) => r.data);
-    }
-    createEmbedding(engine, options) {
-        return this.request(`/engines/${engine}/embeddings`, 'POST', options);
-    }
-    async requestRaw(path, method, body) {
-        let headers = { ...this.headers };
-        if (body instanceof FormData) {
-            delete headers['content-type'];
-            headers = body.getHeaders(headers);
-        }
-        else if (!['string', 'undefined'].includes(typeof body)) {
-            body = JSON.stringify(body);
-        }
-        const response = await fetch(this.url + path, {
-            headers,
-            method,
-            body: body,
-        });
-        if (!response.ok) {
-            let errorBody;
-            try {
-                const { error: { message }, } = (await response.json());
-                errorBody = message;
-            }
-            catch {
-                try {
-                    errorBody = await response.text();
-                }
-                catch {
-                    errorBody = 'Failed to get body as text';
-                }
-            }
-            throw new Error(`OpenAI did not return ok: ${response.status} ~ Error body: ${errorBody}`);
-        }
-        return response;
-    }
-    async request(path, method, body) {
-        const response = await this.requestRaw(path, method, body);
-        return response.json();
-    }
-    eventStreamTransformer() {
-        const dataHeader = Buffer.from('data: ');
-        return new Transform({
-            transform: function (chunk, _, callback) {
-                if (chunk.length >= dataHeader.length &&
-                    dataHeader.compare(chunk, undefined, dataHeader.length) === 0) {
-                    if (this.prevChunk) {
-                        const completion = JSON.parse(this.prevChunk.toString());
-                        this.push(completion.choices[0].text);
-                        this.prevChunk = undefined;
-                    }
-                    chunk = chunk.slice(dataHeader.length);
-                }
-                this.prevChunk = this.prevChunk ? Buffer.concat([this.prevChunk, chunk]) : chunk;
-                callback();
-            },
-        });
-    }
-}

package/dist/types.d.ts

@@ -1,186 +0,0 @@
-declare type LiteralUnion<T extends U, U = string> = T | (U & {});
-export declare type EngineId = LiteralUnion<'davinci' | 'curie' | 'babbage' | 'ada'>;
-export interface Engine {
-    id: EngineId;
-    object: 'engine';
-    created?: Date;
-    max_replicas?: number;
-    owner: string;
-    permissions: unknown;
-    ready: boolean;
-    ready_replicas: unknown;
-    replicas: unknown;
-}
-export interface List<T> {
-    object: 'list';
-    data: T[];
-    model?: string;
-}
-export interface CompletionRequest {
-    prompt?: string | string[];
-    max_tokens?: number;
-    temperature?: number;
-    top_p?: number;
-    n?: number;
-    logprobs?: number;
-    echo?: boolean;
-    stop?: string | string[];
-    presence_penalty?: number;
-    frequency_penalty?: number;
-    best_of?: number;
-    logit_bias?: Record<string, number>;
-    user?: string;
-}
-export interface LogProbs {
-    tokens: string[];
-    token_logprobs: number[];
-    top_logprobs: Array<Record<string, number>>;
-    text_offset: number[];
-}
-export interface Choice {
-    text: string;
-    index: number;
-    logprobs: LogProbs | null;
-    finish_reason: string | null;
-}
-export interface Completion {
-    id: string;
-    object: 'text_completion';
-    created: number;
-    model: string;
-    choices: Choice[];
-}
-export declare enum ContentLabel {
-    Safe = 0,
-    Sensitive = 1,
-    Unsafe = 2
-}
-export interface SearchRequest {
-    query: string;
-    documents?: string[];
-    file?: string;
-    max_rerank?: number;
-    return_metadata?: boolean;
-}
-export interface SearchDocument {
-    document: number;
-    object: 'search_result';
-    score: number;
-}
-export interface ClassificationRequest {
-    model: string;
-    query: string;
-    examples?: string[];
-    file?: string;
-    labels?: string[] | null;
-    search_model?: string;
-    temperature?: number;
-    logprobs?: number;
-    max_examples?: number;
-    logit_bias?: Record<string, number>;
-    return_prompt?: boolean;
-    return_metadata?: boolean;
-    expand?: string[];
-}
-export interface ClassificationExample {
-    document: number;
-    label: string;
-    text: string;
-}
-export interface Classification {
-    completion: string;
-    label: string;
-    model: string;
-    object: 'classification';
-    search_model: string;
-    selected_examples: ClassificationExample[];
-}
-export interface AnswerRequest {
-    model: string;
-    question: string;
-    examples: Array<[string, string]>;
-    examples_context: string;
-    documents?: string[];
-    file?: string;
-    search_model?: string;
-    max_rerank?: number;
-    temperature?: number;
-    logprobs?: number;
-    max_tokens?: number;
-    stop?: string | string[];
-    n?: number;
-    logit_bias?: Record<string, number>;
-    return_metadata?: boolean;
-    return_prompt?: boolean;
-    expand?: string[];
-}
-export interface AnswerDocument {
-    document: number;
-    text: string;
-}
-export interface Answer {
-    answers: string[];
-    completion: string | Completion;
-    model: string;
-    object: 'answer';
-    search_model: string;
-    prompt: string;
-    selected_documents: AnswerDocument[];
-}
-export declare type FilePurpose = 'search' | 'answers' | 'classifications' | 'fine-tune';
-export declare type JsonLines = string | string[] | unknown[];
-export interface File {
-    id: string;
-    object: string;
-    bytes: number;
-    created_at: number;
-    filename: string;
-    purpose: FilePurpose;
-}
-export interface Hyperparams {
-    n_epochs?: number;
-    batch_size?: number;
-    learning_rate_multiplier?: number;
-    use_packing?: boolean;
-    prompt_loss_weight?: number;
-}
-export interface FineTuneRequest extends Hyperparams {
-    training_file: string;
-    validation_file?: string;
-    model?: string;
-    compute_classification_metrics?: boolean;
-    classification_n_classes?: number;
-    classification_positive_class?: string;
-    classification_betas?: number[];
-}
-export interface FineTuneEvent {
-    object: 'fine-tune-event';
-    created_at: number;
-    level: string;
-    message: string;
-}
-export interface FineTune {
-    id: string;
-    object: 'fine-tune';
-    model: string;
-    created_at: number;
-    events: FineTuneEvent[];
-    fine_tuned_model: string;
-    hyperparams: Hyperparams;
-    organization_id: string;
-    result_files: File[];
-    status: string;
-    validation_files: File[];
-    training_files: File[];
-    updated_at: number;
-    user_id: string;
-}
-export interface EmbeddingRequest {
-    input: string | string[];
-}
-export interface Embedding {
-    object: 'embedding';
-    embedding: number[];
-    index: number;
-}
-export {};

package/dist/types.js

@@ -1,6 +0,0 @@
-export var ContentLabel;
-(function (ContentLabel) {
-    ContentLabel[ContentLabel["Safe"] = 0] = "Safe";
-    ContentLabel[ContentLabel["Sensitive"] = 1] = "Sensitive";
-    ContentLabel[ContentLabel["Unsafe"] = 2] = "Unsafe";
-})(ContentLabel || (ContentLabel = {}));