openlayer 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -1,35 +1,207 @@
 import { RequestOptions } from 'openai/core';
 import { ChatCompletion, ChatCompletionChunk, ChatCompletionCreateParams, Completion, CompletionCreateParams } from 'openai/resources';
 import { Stream } from 'openai/streaming';
+/**
+ * Represents the data structure for a chat completion.
+ */
 export interface ChatCompletionData {
-    input: string | string[] | number[] | number[][] | null;
-    latency: number;
-    output: string | null;
-    timestamp: number;
+    [key: string]: any;
+    /**
+     * The input data for the chat completion. It can be a string, an array of strings,
+     * or a nested array of numbers.
+     */
+    input: string | string[] | number[] | number[][];
+    /**
+     * The latency of the chat completion in milliseconds. Optional.
+     */
+    latency?: number;
+    /**
+     * The output string generated by the chat completion.
+     */
+    output: string;
+    /**
+     * A timestamp representing when the chat completion occurred. Optional.
+     */
+    timestamp?: number;
+    /**
+     * The number of tokens used in the chat completion. Optional.
+     */
     tokens?: number;
 }
-type ConstructorProps = {
-    openAiApiKey: string;
+/**
+ * Configuration settings for uploading chat completion data to Openlayer.
+ */
+export interface ChatCompletionConfig {
+    /**
+     * The name of the column that stores the ground truth data. Can be null.
+     */
+    groundTruthColumnName: string | null;
+    /**
+     * The name of the column that stores inference IDs. Can be null.
+     */
+    inferenceIdColumnName: string | null;
+    /**
+     * An array of names for input variable columns. Can be null.
+     */
+    inputVariableNames: string[] | null;
+    /**
+     * The name of the column that stores latency data. Can be null.
+     */
+    latencyColumnName: string | null;
+    /**
+     * The name of the column that stores the number of tokens. Can be null.
+     */
+    numOfTokenColumnName: string | null;
+    /**
+     * The name of the column that stores output data. Can be null.
+     */
+    outputColumnName: string | null;
+    /**
+     * The name of the column that stores timestamp data. Can be null.
+     */
+    timestampColumnName: string | null;
+}
+type OpenlayerClientConstructorProps = {
     openlayerApiKey?: string;
     openlayerInferencePipelineName?: string;
     openlayerProjectName?: string;
     openlayerServerUrl?: string;
 };
-declare class OpenAIMonitor {
-    private OpenAIClient;
-    private monitoringOn;
+type OpenAIMonitorConstructorProps = OpenlayerClientConstructorProps & {
+    openAiApiKey: string;
+};
+type OpenlayerInferencePipeline = {
+    dataVolumeGraphs?: OpenlayerSampleVolumeGraph;
+    dateCreated: string;
+    dateLastEvaluated?: string;
+    dateLastSampleReceived?: string;
+    dateOfNextEvaluation?: string;
+    dateUpdated: string;
+    description?: string;
+    failingGoalCount: number;
+    id: string;
+    name: string;
+    passingGoalCount: number;
+    projectId: string;
+    status: OpenlayerInferencePipelineStatus;
+    statusMessage?: string;
+    totalGoalCount: number;
+};
+type OpenlayerInferencePipelineStatus = 'completed' | 'failed' | 'paused' | 'queued' | 'running' | 'unknown';
+type OpenlayerProject = {
+    dateCreated: string;
+    dateUpdated: string;
+    description?: string;
+    developmentGoalCount: number;
+    goalCount: number;
+    id: string;
+    inferencePipelineCount: number;
+    memberIds: string[];
+    monitoringGoalCount: number;
+    name: string;
+    sample?: boolean;
+    slackChannelId?: string;
+    slackChannelName?: string;
+    slackChannelNotificationsEnabled: boolean;
+    taskType: OpenlayerTaskType;
+    unreadNotificationCount: number;
+    versionCount: number;
+};
+type OpenlayerSampleVolumeGraphBucket = {
+    title: string;
+    xAxis: {
+        data: string[];
+        title: string;
+    };
+    yAxis: {
+        data: number[];
+        title: string;
+    };
+};
+type OpenlayerSampleVolumeGraph = {
+    daily: OpenlayerSampleVolumeGraphBucket;
+    hourly: OpenlayerSampleVolumeGraphBucket;
+    monthly: OpenlayerSampleVolumeGraphBucket;
+    weekly: OpenlayerSampleVolumeGraphBucket;
+};
+type OpenlayerTaskType = 'llm-base' | 'tabular-classification' | 'tabular-regression' | 'text-classification';
+declare class OpenlayerClient {
     private openlayerApiKey?;
     private openlayerProjectName?;
     private openlayerInferencePipelineName?;
     private openlayerServerUrl;
     private version;
-    constructor({ openAiApiKey, openlayerApiKey, openlayerInferencePipelineName, openlayerProjectName, openlayerServerUrl, }: ConstructorProps);
-    private formatChatCompletionInput;
+    constructor({ openlayerApiKey, openlayerInferencePipelineName, openlayerProjectName, openlayerServerUrl, }: OpenlayerClientConstructorProps);
     private resolvedQuery;
-    uploadDataToOpenlayer: (data: ChatCompletionData) => Promise<void>;
-    startMonitoring(): void;
-    stopMonitoring(): void;
+    private uploadToInferencePipeline;
+    /**
+     * Uploads data to Openlayer. This function takes ChatCompletionData and an optional
+     * ChatCompletionConfig, then uploads the data to the specified Openlayer Inference Pipeline.
+     * @param data The ChatCompletionData to be uploaded.
+     * @param config Configuration for the data upload.
+     * @throws Throws an error if Openlayer API key or project name are not set.
+     * @returns A promise that resolves when the data has been successfully uploaded.
+     */
+    uploadDataToOpenlayer: (data: ChatCompletionData, config: ChatCompletionConfig) => Promise<void>;
+    /**
+     * Creates a new inference pipeline in Openlayer, or loads an existing one if it already exists.
+     * @param name The name of the inference pipeline.
+     * @param projectId The project ID containing the inference pipeline.
+     * @throws Throws an error if the inference pipeline cannot be created or found.
+     * @returns A promise that resolves to an OpenlayerInferencePipeline object.
+     */
+    createInferencePipeline: (name: string, projectId: string) => Promise<OpenlayerInferencePipeline>;
+    /**
+     * Creates a new project in Openlayer, or loads an existing one if it already exists.
+     * @param name The name of the project.
+     * @param taskType The type of task associated with the project.
+     * @param description Optional description of the project.
+     * @throws Throws an error if the project cannot be created or found.
+     * @returns A promise that resolves to an OpenlayerProject object.
+     */
+    createProject: (name: string, taskType: OpenlayerTaskType, description?: string) => Promise<OpenlayerProject>;
+    /**
+     * Loads an existing inference pipeline from Openlayer based on its name and project ID.
+     * @param name The name of the inference pipeline.
+     * @param projectId The project ID containing the inference pipeline.
+     * @throws Throws an error if the inference pipeline is not found.
+     * @returns A promise that resolves to an OpenlayerInferencePipeline object.
+     */
+    loadInferencePipeline: (name: string, projectId: string) => Promise<OpenlayerInferencePipeline>;
+    loadProject: (name: string) => Promise<OpenlayerProject>;
+}
+export declare class OpenAIMonitor {
+    private openlayerClient;
+    private openAIClient;
+    private openlayerDefaultDataConfig;
+    private monitoringOn;
+    constructor({ openAiApiKey, openlayerApiKey, openlayerInferencePipelineName, openlayerProjectName, openlayerServerUrl, }: OpenAIMonitorConstructorProps);
+    private formatChatCompletionInput;
+    /**
+     * Creates a new ChatCompletion instance. If monitoring is not active, an error is thrown.
+     * This function also measures latency and uploads data to Openlayer.
+     * @param body The parameters for creating a chat completion.
+     * @param options Optional request options.
+     * @throws Throws an error if monitoring is not active or if there is no output received from OpenAI.
+     * @returns A promise that resolves to a ChatCompletion or a Stream of ChatCompletionChunks.
+     */
     createChatCompletion: (body: ChatCompletionCreateParams, options?: RequestOptions) => Promise<ChatCompletion | Stream<ChatCompletionChunk>>;
+    /**
+     * Creates a new Completion instance. If monitoring is not active, an error is thrown.
+     * This function also measures latency and uploads data to Openlayer.
+     * @param body The parameters for creating a completion.
+     * @param options Optional request options.
+     * @throws Throws an error if monitoring is not active or if no prompt is provided.
+     * @returns A promise that resolves to a Completion or a Stream of Completions.
+     */
     createCompletion: (body: CompletionCreateParams, options?: RequestOptions) => Promise<Completion | Stream<Completion>>;
+    /**
+     * Starts monitoring for the OpenAI Monitor instance. If monitoring is already active, a warning is logged.
+     */
+    startMonitoring(): void;
+    /**
+     * Stops monitoring for the OpenAI Monitor instance. If monitoring is not active, a warning is logged.
+     */
+    stopMonitoring(): void;
 }
-export default OpenAIMonitor;
+export default OpenlayerClient;

package/dist/index.js

@@ -16,38 +16,80 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIMonitor = void 0;
 const openai_1 = require("openai");
 const uuid_1 = require("uuid");
 const request_1 = require("./utils/request");
-class OpenAIMonitor {
-    constructor({ openAiApiKey, openlayerApiKey, openlayerInferencePipelineName, openlayerProjectName, openlayerServerUrl, }) {
-        this.monitoringOn = false;
+class OpenlayerClient {
+    constructor({ openlayerApiKey, openlayerInferencePipelineName, openlayerProjectName, openlayerServerUrl, }) {
         this.openlayerServerUrl = 'https://api.openlayer.com/v1';
         this.version = '0.1.0a16';
-        this.formatChatCompletionInput = (messages) => messages
-            .filter(({ role }) => role === 'user')
-            .map(({ content }) => content)
-            .join('\n')
-            .trim();
         this.resolvedQuery = (endpoint, args = {}) => (0, request_1.resolvedQuery)(this.openlayerServerUrl, endpoint, args);
-        this.uploadDataToOpenlayer = (data) => __awaiter(this, void 0, void 0, function* () {
-            const uploadToInferencePipeline = (id) => __awaiter(this, void 0, void 0, function* () {
-                const dataStreamEndpoint = `/inference-pipelines/${id}/data-stream`;
-                const dataStreamQuery = this.resolvedQuery(dataStreamEndpoint);
-                const response = yield fetch(dataStreamQuery, {
+        this.uploadToInferencePipeline = (inferencePipelineId, data, config) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const dataStreamEndpoint = `/inference-pipelines/${inferencePipelineId}/data-stream`;
+            const dataStreamQuery = this.resolvedQuery(dataStreamEndpoint);
+            const response = yield fetch(dataStreamQuery, {
+                body: JSON.stringify({
+                    config,
+                    rows: [
+                        Object.assign(Object.assign({}, data), { id: (0, uuid_1.v4)(), timestamp: Math.round(((_a = data.timestamp) !== null && _a !== void 0 ? _a : Date.now()) / 1000) }),
+                    ],
+                }),
+                headers: {
+                    Authorization: `Bearer ${this.openlayerApiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                method: 'POST',
+            });
+            if (!response.ok) {
+                console.error('Error making POST request:', response.status);
+                throw new Error(`Error: ${response.status}`);
+            }
+            return yield response.json();
+        });
+        /**
+         * Uploads data to Openlayer. This function takes ChatCompletionData and an optional
+         * ChatCompletionConfig, then uploads the data to the specified Openlayer Inference Pipeline.
+         * @param data The ChatCompletionData to be uploaded.
+         * @param config Configuration for the data upload.
+         * @throws Throws an error if Openlayer API key or project name are not set.
+         * @returns A promise that resolves when the data has been successfully uploaded.
+         */
+        this.uploadDataToOpenlayer = (data, config) => __awaiter(this, void 0, void 0, function* () {
+            if (!this.openlayerApiKey || !this.openlayerProjectName) {
+                throw new Error('Openlayer API key and project name are required for publishing.');
+            }
+            try {
+                const project = yield this.createProject(this.openlayerProjectName, 'llm-base');
+                const inferencePipeline = yield this.createInferencePipeline(this.openlayerProjectName, project.id);
+                yield this.uploadToInferencePipeline(inferencePipeline.id, data, config);
+            }
+            catch (error) {
+                console.error('Error publishing data to Openlayer:', error);
+                throw error;
+            }
+        });
+        /**
+         * Creates a new inference pipeline in Openlayer, or loads an existing one if it already exists.
+         * @param name The name of the inference pipeline.
+         * @param projectId The project ID containing the inference pipeline.
+         * @throws Throws an error if the inference pipeline cannot be created or found.
+         * @returns A promise that resolves to an OpenlayerInferencePipeline object.
+         */
+        this.createInferencePipeline = (name, projectId) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.loadInferencePipeline(name, projectId);
+            }
+            catch (_b) {
+                const createInferencePipelineEndpoint = `/projects/${projectId}/inference-pipelines`;
+                const createInferencePipelineQuery = this.resolvedQuery(createInferencePipelineEndpoint, { version: this.version });
+                const createInferencePipelineResponse = yield fetch(createInferencePipelineQuery, {
                     body: JSON.stringify({
-                        config: {
-                            groundTruthColumnName: null,
-                            inferenceIdColumnName: 'id',
-                            inputVariableNames: ['input'],
-                            latencyColumnName: 'latency',
-                            numOfTokenColumnName: 'tokens',
-                            outputColumnName: 'output',
-                            timestampColumnName: 'timestamp',
-                        },
-                        rows: [
-                            Object.assign(Object.assign({}, data), { id: (0, uuid_1.v4)(), timestamp: Math.round(data.timestamp / 1000) }),
-                        ],
+                        description: '',
+                        name: typeof this.openlayerInferencePipelineName === 'undefined'
+                            ? 'production'
+                            : this.openlayerInferencePipelineName,
                     }),
                     headers: {
                         Authorization: `Bearer ${this.openlayerApiKey}`,
@@ -55,87 +97,141 @@ class OpenAIMonitor {
                     },
                     method: 'POST',
                 });
-                if (!response.ok) {
-                    console.error('Error making POST request:', response.status);
-                    throw new Error(`Error: ${response.status}`);
+                const inferencePipeline = yield createInferencePipelineResponse.json();
+                if (!(inferencePipeline === null || inferencePipeline === void 0 ? void 0 : inferencePipeline.id)) {
+                    throw new Error('Error creating inference pipeline');
                 }
-                return yield response.json();
-            });
-            if (!this.openlayerApiKey || !this.openlayerProjectName) {
-                throw new Error('Openlayer API key and project name are required for publishing.');
+                return inferencePipeline;
             }
+        });
+        /**
+         * Creates a new project in Openlayer, or loads an existing one if it already exists.
+         * @param name The name of the project.
+         * @param taskType The type of task associated with the project.
+         * @param description Optional description of the project.
+         * @throws Throws an error if the project cannot be created or found.
+         * @returns A promise that resolves to an OpenlayerProject object.
+         */
+        this.createProject = (name, taskType, description) => __awaiter(this, void 0, void 0, function* () {
             try {
+                return yield this.loadProject(name);
+            }
+            catch (_c) {
                 const projectsEndpoint = '/projects';
-                const projectsQueryParameters = {
-                    name: this.openlayerProjectName,
-                    version: this.version,
-                };
-                const projectsQuery = this.resolvedQuery(projectsEndpoint, projectsQueryParameters);
+                const projectsQuery = this.resolvedQuery(projectsEndpoint);
                 const projectsResponse = yield fetch(projectsQuery, {
+                    body: JSON.stringify({
+                        description,
+                        name,
+                        taskType,
+                    }),
                     headers: {
                         Authorization: `Bearer ${this.openlayerApiKey}`,
                         'Content-Type': 'application/json',
                     },
-                    method: 'GET',
+                    method: 'POST',
                 });
                 const { items: projects } = yield projectsResponse.json();
                 if (!Array.isArray(projects)) {
                     throw new Error('Invalid response from Openlayer');
                 }
-                const project = projects.find(({ name }) => name === this.openlayerProjectName);
+                const project = projects.find((p) => p.name === name);
                 if (!(project === null || project === void 0 ? void 0 : project.id)) {
                     throw new Error('Project not found');
                 }
-                const inferencePipelineEndpoint = `/projects/${project.id}/inference-pipelines`;
-                const inferencePipelineQueryParameters = {
-                    name: this.openlayerInferencePipelineName,
-                    version: this.version,
-                };
-                const inferencePipelineQuery = this.resolvedQuery(inferencePipelineEndpoint, inferencePipelineQueryParameters);
-                const inferencePipelineResponse = yield fetch(inferencePipelineQuery, {
-                    headers: {
-                        Authorization: `Bearer ${this.openlayerApiKey}`,
-                        'Content-Type': 'application/json',
-                    },
-                    method: 'GET',
-                });
-                const { items: inferencePipelines } = yield inferencePipelineResponse.json();
-                const inferencePipeline = Array.isArray(inferencePipelines)
-                    ? inferencePipelines.find(({ name }) => typeof this.openlayerInferencePipelineName === 'undefined' ||
-                        name === this.openlayerInferencePipelineName)
-                    : undefined;
-                if (inferencePipeline === null || inferencePipeline === void 0 ? void 0 : inferencePipeline.id) {
-                    const { id: inferencePipelineId } = inferencePipeline;
-                    yield uploadToInferencePipeline(inferencePipelineId);
-                }
-                else {
-                    const createInferencePipelineEndpoint = `/projects/${project.id}/inference-pipelines`;
-                    const createInferencePipelineQuery = this.resolvedQuery(createInferencePipelineEndpoint, { version: this.version });
-                    const createInferencePipelineResponse = yield fetch(createInferencePipelineQuery, {
-                        body: JSON.stringify({
-                            description: '',
-                            name: typeof this.openlayerInferencePipelineName === 'undefined'
-                                ? 'production'
-                                : this.openlayerInferencePipelineName,
-                        }),
-                        headers: {
-                            Authorization: `Bearer ${this.openlayerApiKey}`,
-                            'Content-Type': 'application/json',
-                        },
-                        method: 'POST',
-                    });
-                    const { id: inferencePipelineId } = yield createInferencePipelineResponse.json();
-                    if (!inferencePipelineId) {
-                        throw new Error('Error creating inference pipeline');
-                    }
-                    yield uploadToInferencePipeline(inferencePipelineId);
-                }
+                return project;
             }
-            catch (error) {
-                console.error('Error publishing data to Openlayer:', error);
-                throw error;
+        });
+        /**
+         * Loads an existing inference pipeline from Openlayer based on its name and project ID.
+         * @param name The name of the inference pipeline.
+         * @param projectId The project ID containing the inference pipeline.
+         * @throws Throws an error if the inference pipeline is not found.
+         * @returns A promise that resolves to an OpenlayerInferencePipeline object.
+         */
+        this.loadInferencePipeline = (name, projectId) => __awaiter(this, void 0, void 0, function* () {
+            const inferencePipelineEndpoint = `/projects/${projectId}/inference-pipelines`;
+            const inferencePipelineQueryParameters = {
+                name: this.openlayerInferencePipelineName,
+                version: this.version,
+            };
+            const inferencePipelineQuery = this.resolvedQuery(inferencePipelineEndpoint, inferencePipelineQueryParameters);
+            const inferencePipelineResponse = yield fetch(inferencePipelineQuery, {
+                headers: {
+                    Authorization: `Bearer ${this.openlayerApiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                method: 'GET',
+            });
+            const { items: inferencePipelines } = yield inferencePipelineResponse.json();
+            const inferencePipeline = Array.isArray(inferencePipelines)
+                ? inferencePipelines.find((p) => p.name === name)
+                : undefined;
+            if (!(inferencePipeline === null || inferencePipeline === void 0 ? void 0 : inferencePipeline.id)) {
+                throw new Error('Inference pipeline not found');
+            }
+            return inferencePipeline;
+        });
+        this.loadProject = (name) => __awaiter(this, void 0, void 0, function* () {
+            const projectsEndpoint = '/projects';
+            const projectsQueryParameters = {
+                name,
+                version: this.version,
+            };
+            const projectsQuery = this.resolvedQuery(projectsEndpoint, projectsQueryParameters);
+            const projectsResponse = yield fetch(projectsQuery, {
+                headers: {
+                    Authorization: `Bearer ${this.openlayerApiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                method: 'GET',
+            });
+            const { items: projects } = yield projectsResponse.json();
+            if (!Array.isArray(projects)) {
+                throw new Error('Invalid response from Openlayer');
+            }
+            const project = projects.find((p) => p.name === name);
+            if (!(project === null || project === void 0 ? void 0 : project.id)) {
+                throw new Error('Project not found');
             }
+            return project;
         });
+        this.openlayerApiKey = openlayerApiKey;
+        this.openlayerInferencePipelineName = openlayerInferencePipelineName;
+        this.openlayerProjectName = openlayerProjectName;
+        if (openlayerServerUrl) {
+            this.openlayerServerUrl = openlayerServerUrl;
+        }
+        if (!this.openlayerApiKey || !this.openlayerProjectName) {
+            throw new Error('Openlayer API key and project name are required for publishing.');
+        }
+    }
+}
+class OpenAIMonitor {
+    constructor({ openAiApiKey, openlayerApiKey, openlayerInferencePipelineName, openlayerProjectName, openlayerServerUrl, }) {
+        this.openlayerDefaultDataConfig = {
+            groundTruthColumnName: null,
+            inferenceIdColumnName: 'id',
+            inputVariableNames: ['input'],
+            latencyColumnName: 'latency',
+            numOfTokenColumnName: 'tokens',
+            outputColumnName: 'output',
+            timestampColumnName: 'timestamp',
+        };
+        this.monitoringOn = false;
+        this.formatChatCompletionInput = (messages) => messages
+            .filter(({ role }) => role === 'user')
+            .map(({ content }) => content)
+            .join('\n')
+            .trim();
+        /**
+         * Creates a new ChatCompletion instance. If monitoring is not active, an error is thrown.
+         * This function also measures latency and uploads data to Openlayer.
+         * @param body The parameters for creating a chat completion.
+         * @param options Optional request options.
+         * @throws Throws an error if monitoring is not active or if there is no output received from OpenAI.
+         * @returns A promise that resolves to a ChatCompletion or a Stream of ChatCompletionChunks.
+         */
         this.createChatCompletion = (body, options) => __awaiter(this, void 0, void 0, function* () {
             var _a, e_1, _b, _c;
             var _d, _e;
@@ -146,7 +242,7 @@ class OpenAIMonitor {
             const startTime = Date.now();
             // Accumulate output for streamed responses
             let outputData = '';
-            const response = yield this.OpenAIClient.chat.completions.create(body, options);
+            const response = yield this.openAIClient.chat.completions.create(body, options);
             if (body.stream) {
                 const streamedResponse = response;
                 try {
@@ -167,40 +263,55 @@ class OpenAIMonitor {
                 }
                 const endTime = Date.now();
                 const latency = endTime - startTime;
-                this.uploadDataToOpenlayer({
+                this.openlayerClient.uploadDataToOpenlayer({
                     input: this.formatChatCompletionInput(body.messages),
                     latency,
                     output: outputData,
                     timestamp: startTime,
-                });
+                }, this.openlayerDefaultDataConfig);
             }
             else {
                 const nonStreamedResponse = response;
                 // Handle regular (non-streamed) response
                 const endTime = Date.now();
                 const latency = endTime - startTime;
-                this.uploadDataToOpenlayer({
+                const output = nonStreamedResponse.choices[0].message.content;
+                if (typeof output !== 'string') {
+                    throw new Error('No output received from OpenAI.');
+                }
+                this.openlayerClient.uploadDataToOpenlayer({
                     input: this.formatChatCompletionInput(body.messages),
                     latency,
-                    output: nonStreamedResponse.choices[0].message.content,
+                    output,
                     timestamp: startTime,
                     tokens: (_e = (_d = nonStreamedResponse.usage) === null || _d === void 0 ? void 0 : _d.total_tokens) !== null && _e !== void 0 ? _e : 0,
-                });
+                }, this.openlayerDefaultDataConfig);
             }
             return response;
         });
+        /**
+         * Creates a new Completion instance. If monitoring is not active, an error is thrown.
+         * This function also measures latency and uploads data to Openlayer.
+         * @param body The parameters for creating a completion.
+         * @param options Optional request options.
+         * @throws Throws an error if monitoring is not active or if no prompt is provided.
+         * @returns A promise that resolves to a Completion or a Stream of Completions.
+         */
         this.createCompletion = (body, options) => __awaiter(this, void 0, void 0, function* () {
             var _g, e_2, _h, _j;
             var _k, _l, _m, _o;
             if (!this.monitoringOn) {
                 throw new Error('Monitoring is not active.');
             }
+            if (!body.prompt) {
+                throw new Error('No prompt provided.');
+            }
             // Start a timer to measure latency
             const startTime = Date.now();
             // Accumulate output and tokens data for streamed responses
             let outputData = '';
             let tokensData = 0;
-            const response = yield this.OpenAIClient.completions.create(body, options);
+            const response = yield this.openAIClient.completions.create(body, options);
             if (body.stream) {
                 const streamedResponse = response;
                 try {
@@ -222,43 +333,43 @@ class OpenAIMonitor {
                 }
                 const endTime = Date.now();
                 const latency = endTime - startTime;
-                this.uploadDataToOpenlayer({
+                this.openlayerClient.uploadDataToOpenlayer({
                     input: body.prompt,
                     latency,
                     output: outputData,
                     timestamp: startTime,
                     tokens: tokensData,
-                });
+                }, this.openlayerDefaultDataConfig);
             }
             else {
                 const nonStreamedResponse = response;
                 // Handle regular (non-streamed) response
                 const endTime = Date.now();
                 const latency = endTime - startTime;
-                this.uploadDataToOpenlayer({
+                this.openlayerClient.uploadDataToOpenlayer({
                     input: body.prompt,
                     latency,
                     output: nonStreamedResponse.choices[0].text,
                     timestamp: startTime,
                     tokens: (_o = (_m = nonStreamedResponse.usage) === null || _m === void 0 ? void 0 : _m.total_tokens) !== null && _o !== void 0 ? _o : 0,
-                });
+                }, this.openlayerDefaultDataConfig);
             }
             return response;
         });
-        this.OpenAIClient = new openai_1.default({
+        this.openlayerClient = new OpenlayerClient({
+            openlayerApiKey,
+            openlayerInferencePipelineName,
+            openlayerProjectName,
+            openlayerServerUrl,
+        });
+        this.openAIClient = new openai_1.default({
             apiKey: openAiApiKey,
             dangerouslyAllowBrowser: true,
         });
-        this.openlayerApiKey = openlayerApiKey;
-        this.openlayerInferencePipelineName = openlayerInferencePipelineName;
-        this.openlayerProjectName = openlayerProjectName;
-        if (openlayerServerUrl) {
-            this.openlayerServerUrl = openlayerServerUrl;
-        }
-        if (!this.openlayerApiKey || !this.openlayerProjectName) {
-            throw new Error('Openlayer API key and project name are required for publishing.');
-        }
     }
+    /**
+     * Starts monitoring for the OpenAI Monitor instance. If monitoring is already active, a warning is logged.
+     */
     startMonitoring() {
         if (this.monitoringOn) {
             console.warn('Monitoring is already on!');
@@ -267,6 +378,9 @@ class OpenAIMonitor {
         this.monitoringOn = true;
         console.info('Monitoring started.');
     }
+    /**
+     * Stops monitoring for the OpenAI Monitor instance. If monitoring is not active, a warning is logged.
+     */
     stopMonitoring() {
         if (!this.monitoringOn) {
             console.warn('Monitoring is not active.');
@@ -276,4 +390,5 @@ class OpenAIMonitor {
         console.info('Monitoring stopped.');
     }
 }
-exports.default = OpenAIMonitor;
+exports.OpenAIMonitor = OpenAIMonitor;
+exports.default = OpenlayerClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openlayer",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "The Openlayer TypeScript client",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",