openlayer 0.1.5 → 0.1.6

package/dist/index.d.ts

@@ -61,13 +61,15 @@ export interface ChatCompletionConfig {
      */
     timestampColumnName: string | null;
 }
-type ConstructorProps = {
-    openAiApiKey: string;
+type OpenlayerClientConstructorProps = {
     openlayerApiKey?: string;
     openlayerInferencePipelineName?: string;
     openlayerProjectName?: string;
     openlayerServerUrl?: string;
 };
+type OpenAIMonitorConstructorProps = OpenlayerClientConstructorProps & {
+    openAiApiKey: string;
+};
 type OpenlayerInferencePipeline = {
     dataVolumeGraphs?: OpenlayerSampleVolumeGraph;
     dateCreated: string;
@@ -123,17 +125,13 @@ type OpenlayerSampleVolumeGraph = {
     weekly: OpenlayerSampleVolumeGraphBucket;
 };
 type OpenlayerTaskType = 'llm-base' | 'tabular-classification' | 'tabular-regression' | 'text-classification';
-declare class OpenAIMonitor {
-    private OpenAIClient;
-    private monitoringOn;
+declare class OpenlayerClient {
     private openlayerApiKey?;
-    private openlayerDefaultDataConfig;
     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;
     private uploadToInferencePipeline;
     /**
@@ -145,24 +143,6 @@ declare class OpenAIMonitor {
      * @returns A promise that resolves when the data has been successfully uploaded.
      */
     uploadDataToOpenlayer: (data: ChatCompletionData, config: ChatCompletionConfig) => Promise<void>;
-    /**
-     * 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>>;
     /**
      * Creates a new inference pipeline in Openlayer, or loads an existing one if it already exists.
      * @param name The name of the inference pipeline.
@@ -189,6 +169,32 @@ declare class OpenAIMonitor {
      */
     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.
      */
@@ -198,4 +204,4 @@ declare class OpenAIMonitor {
      */
     stopMonitoring(): void;
 }
-export default OpenAIMonitor;
+export default OpenlayerClient;

package/dist/index.js

@@ -16,28 +16,14 @@ 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;
-        this.openlayerDefaultDataConfig = {
-            groundTruthColumnName: null,
-            inferenceIdColumnName: 'id',
-            inputVariableNames: ['input'],
-            latencyColumnName: 'latency',
-            numOfTokenColumnName: 'tokens',
-            outputColumnName: 'output',
-            timestampColumnName: 'timestamp',
-        };
+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.uploadToInferencePipeline = (inferencePipelineId, data, config) => __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -84,138 +70,6 @@ class OpenAIMonitor {
                 throw error;
             }
         });
-        /**
-         * 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 _b, e_1, _c, _d;
-            var _e, _f;
-            if (!this.monitoringOn) {
-                throw new Error('Monitoring is not active.');
-            }
-            // Start a timer to measure latency
-            const startTime = Date.now();
-            // Accumulate output for streamed responses
-            let outputData = '';
-            const response = yield this.OpenAIClient.chat.completions.create(body, options);
-            if (body.stream) {
-                const streamedResponse = response;
-                try {
-                    for (var _g = true, streamedResponse_1 = __asyncValues(streamedResponse), streamedResponse_1_1; streamedResponse_1_1 = yield streamedResponse_1.next(), _b = streamedResponse_1_1.done, !_b; _g = true) {
-                        _d = streamedResponse_1_1.value;
-                        _g = false;
-                        const chunk = _d;
-                        // Process each chunk - for example, accumulate input data
-                        outputData += chunk.choices[0].delta.content;
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (!_g && !_b && (_c = streamedResponse_1.return)) yield _c.call(streamedResponse_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-                const endTime = Date.now();
-                const latency = endTime - startTime;
-                this.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;
-                const output = nonStreamedResponse.choices[0].message.content;
-                if (typeof output !== 'string') {
-                    throw new Error('No output received from OpenAI.');
-                }
-                this.uploadDataToOpenlayer({
-                    input: this.formatChatCompletionInput(body.messages),
-                    latency,
-                    output,
-                    timestamp: startTime,
-                    tokens: (_f = (_e = nonStreamedResponse.usage) === null || _e === void 0 ? void 0 : _e.total_tokens) !== null && _f !== void 0 ? _f : 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 _h, e_2, _j, _k;
-            var _l, _m, _o, _p;
-            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);
-            if (body.stream) {
-                const streamedResponse = response;
-                try {
-                    for (var _q = true, streamedResponse_2 = __asyncValues(streamedResponse), streamedResponse_2_1; streamedResponse_2_1 = yield streamedResponse_2.next(), _h = streamedResponse_2_1.done, !_h; _q = true) {
-                        _k = streamedResponse_2_1.value;
-                        _q = false;
-                        const chunk = _k;
-                        // Process each chunk - for example, accumulate input data
-                        outputData += chunk.choices[0].text.trim();
-                        tokensData += (_m = (_l = chunk.usage) === null || _l === void 0 ? void 0 : _l.total_tokens) !== null && _m !== void 0 ? _m : 0;
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (!_q && !_h && (_j = streamedResponse_2.return)) yield _j.call(streamedResponse_2);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
-                const endTime = Date.now();
-                const latency = endTime - startTime;
-                this.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({
-                    input: body.prompt,
-                    latency,
-                    output: nonStreamedResponse.choices[0].text,
-                    timestamp: startTime,
-                    tokens: (_p = (_o = nonStreamedResponse.usage) === null || _o === void 0 ? void 0 : _o.total_tokens) !== null && _p !== void 0 ? _p : 0,
-                }, this.openlayerDefaultDataConfig);
-            }
-            return response;
-        });
         /**
          * Creates a new inference pipeline in Openlayer, or loads an existing one if it already exists.
          * @param name The name of the inference pipeline.
@@ -227,7 +81,7 @@ class OpenAIMonitor {
             try {
                 return yield this.loadInferencePipeline(name, projectId);
             }
-            catch (_r) {
+            catch (_b) {
                 const createInferencePipelineEndpoint = `/projects/${projectId}/inference-pipelines`;
                 const createInferencePipelineQuery = this.resolvedQuery(createInferencePipelineEndpoint, { version: this.version });
                 const createInferencePipelineResponse = yield fetch(createInferencePipelineQuery, {
@@ -262,7 +116,7 @@ class OpenAIMonitor {
             try {
                 return yield this.loadProject(name);
             }
-            catch (_s) {
+            catch (_c) {
                 const projectsEndpoint = '/projects';
                 const projectsQuery = this.resolvedQuery(projectsEndpoint);
                 const projectsResponse = yield fetch(projectsQuery, {
@@ -342,10 +196,6 @@ class OpenAIMonitor {
             }
             return project;
         });
-        this.OpenAIClient = new openai_1.default({
-            apiKey: openAiApiKey,
-            dangerouslyAllowBrowser: true,
-        });
         this.openlayerApiKey = openlayerApiKey;
         this.openlayerInferencePipelineName = openlayerInferencePipelineName;
         this.openlayerProjectName = openlayerProjectName;
@@ -356,6 +206,167 @@ class OpenAIMonitor {
             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;
+            if (!this.monitoringOn) {
+                throw new Error('Monitoring is not active.');
+            }
+            // Start a timer to measure latency
+            const startTime = Date.now();
+            // Accumulate output for streamed responses
+            let outputData = '';
+            const response = yield this.openAIClient.chat.completions.create(body, options);
+            if (body.stream) {
+                const streamedResponse = response;
+                try {
+                    for (var _f = true, streamedResponse_1 = __asyncValues(streamedResponse), streamedResponse_1_1; streamedResponse_1_1 = yield streamedResponse_1.next(), _a = streamedResponse_1_1.done, !_a; _f = true) {
+                        _c = streamedResponse_1_1.value;
+                        _f = false;
+                        const chunk = _c;
+                        // Process each chunk - for example, accumulate input data
+                        outputData += chunk.choices[0].delta.content;
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_f && !_a && (_b = streamedResponse_1.return)) yield _b.call(streamedResponse_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                const endTime = Date.now();
+                const latency = endTime - startTime;
+                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;
+                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,
+                    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);
+            if (body.stream) {
+                const streamedResponse = response;
+                try {
+                    for (var _p = true, streamedResponse_2 = __asyncValues(streamedResponse), streamedResponse_2_1; streamedResponse_2_1 = yield streamedResponse_2.next(), _g = streamedResponse_2_1.done, !_g; _p = true) {
+                        _j = streamedResponse_2_1.value;
+                        _p = false;
+                        const chunk = _j;
+                        // Process each chunk - for example, accumulate input data
+                        outputData += chunk.choices[0].text.trim();
+                        tokensData += (_l = (_k = chunk.usage) === null || _k === void 0 ? void 0 : _k.total_tokens) !== null && _l !== void 0 ? _l : 0;
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_p && !_g && (_h = streamedResponse_2.return)) yield _h.call(streamedResponse_2);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                const endTime = Date.now();
+                const latency = endTime - startTime;
+                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.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.openlayerClient = new OpenlayerClient({
+            openlayerApiKey,
+            openlayerInferencePipelineName,
+            openlayerProjectName,
+            openlayerServerUrl,
+        });
+        this.openAIClient = new openai_1.default({
+            apiKey: openAiApiKey,
+            dangerouslyAllowBrowser: true,
+        });
+    }
     /**
      * Starts monitoring for the OpenAI Monitor instance. If monitoring is already active, a warning is logged.
      */
@@ -379,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.5",
+  "version": "0.1.6",
   "description": "The Openlayer TypeScript client",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",