openlayer 0.1.26 → 0.1.27

package/dist/index.d.ts

@@ -184,7 +184,6 @@ export declare class OpenlayerClient {
      * @param {StreamingData} data - The chat completion data to be streamed.
      * @param {string} inferencePipelineId - The ID of the Openlayer inference pipeline to which data is streamed.
      * @returns {Promise<void>} A promise that resolves when the data has been successfully streamed.
-     * @throws {Error} Throws an error if the Openlayer API key is not set or an error occurs in the streaming process.
      */
     streamData: (data: StreamingData, config: StreamingDataConfig, inferencePipelineId: string) => Promise<void>;
 }
@@ -216,7 +215,6 @@ export declare class OpenAIMonitor {
      * @param {CompletionCreateParams} body - The parameters for creating a completion.
      * @param {RequestOptions} [options] - Optional request options.
      * @returns {Promise<Completion | Stream<Completion>>} Promise that resolves to a Completion or a Stream.
-     * @throws {Error} Throws an error if monitoring is not active or if no prompt is provided.
      */
     createCompletion: (body: CompletionCreateParams, options?: RequestOptions, additionalLogs?: StreamingData) => Promise<Completion | Stream<Completion>>;
     /**

package/dist/index.js

@@ -248,12 +248,12 @@ class OpenlayerClient {
          * @param {StreamingData} data - The chat completion data to be streamed.
          * @param {string} inferencePipelineId - The ID of the Openlayer inference pipeline to which data is streamed.
          * @returns {Promise<void>} A promise that resolves when the data has been successfully streamed.
-         * @throws {Error} Throws an error if the Openlayer API key is not set or an error occurs in the streaming process.
          */
         this.streamData = (data, config, inferencePipelineId) => __awaiter(this, void 0, void 0, function* () {
             var _c;
             if (!this.openlayerApiKey) {
-                throw new Error('Openlayer API key are required for streaming data.');
+                console.error('Openlayer API key are required for streaming data.');
+                return;
             }
             try {
                 const dataStreamEndpoint = `/inference-pipelines/${inferencePipelineId}/data-stream`;
@@ -273,13 +273,12 @@ class OpenlayerClient {
                 });
                 if (!response.ok) {
                     console.error('Error making POST request:', response.status);
-                    throw new Error(`Error: ${response.status}`);
+                    console.error(`Error: ${response.status}`);
                 }
-                return yield response.json();
+                yield response.json();
             }
             catch (error) {
                 console.error('Error streaming data to Openlayer:', error);
-                throw error;
             }
         });
         this.openlayerApiKey = openlayerApiKey;
@@ -287,7 +286,7 @@ class OpenlayerClient {
             this.openlayerServerUrl = openlayerServerUrl;
         }
         if (!this.openlayerApiKey) {
-            throw new Error('Openlayer API key are required for publishing.');
+            console.error('Openlayer API key are required for publishing.');
         }
     }
 }
@@ -327,64 +326,73 @@ class OpenAIMonitor {
             var _a, e_1, _b, _c;
             var _d, _e, _f, _g, _h, _j, _k;
             if (!this.monitoringOn) {
-                throw new Error('Monitoring is not active.');
+                console.warn('Monitoring is not active.');
             }
-            if (typeof this.inferencePipeline === 'undefined') {
-                throw new Error('No inference pipeline found.');
+            else if (typeof this.inferencePipeline === 'undefined') {
+                console.error('No inference pipeline found.');
             }
             // Start a timer to measure latency
             const startTime = Date.now();
             // Accumulate output for streamed responses
             let streamedOutput = '';
             const response = yield this.openAIClient.chat.completions.create(body, options);
-            const prompt = this.formatChatCompletionInput(body.messages);
-            const inputVariableNames = prompt
-                .filter(({ role }) => role === 'user')
-                .map(({ content }) => String(content).replace(/{{\s*|\s*}}/g, ''));
-            const inputVariables = body.messages
-                .filter(({ role }) => role === 'user')
-                .map(({ content }) => content);
-            const inputVariablesMap = inputVariableNames.reduce((acc, name, i) => (Object.assign(Object.assign({}, acc), { [name]: inputVariables[i] })), {});
-            const config = Object.assign(Object.assign({}, this.openlayerClient.defaultConfig), { inputVariableNames,
-                prompt });
-            if (body.stream) {
-                const streamedResponse = response;
-                try {
-                    for (var _l = true, streamedResponse_1 = __asyncValues(streamedResponse), streamedResponse_1_1; streamedResponse_1_1 = yield streamedResponse_1.next(), _a = streamedResponse_1_1.done, !_a; _l = true) {
-                        _c = streamedResponse_1_1.value;
-                        _l = false;
-                        const chunk = _c;
-                        // Process each chunk - for example, accumulate input data
-                        const chunkOutput = (_d = chunk.choices[0].delta.content) !== null && _d !== void 0 ? _d : '';
-                        streamedOutput += chunkOutput;
+            try {
+                if (this.monitoringOn && typeof this.inferencePipeline !== 'undefined') {
+                    const prompt = this.formatChatCompletionInput(body.messages);
+                    const inputVariableNames = prompt
+                        .filter(({ role }) => role === 'user')
+                        .map(({ content }) => String(content).replace(/{{\s*|\s*}}/g, ''));
+                    const inputVariables = body.messages
+                        .filter(({ role }) => role === 'user')
+                        .map(({ content }) => content);
+                    const inputVariablesMap = inputVariableNames.reduce((acc, name, i) => (Object.assign(Object.assign({}, acc), { [name]: inputVariables[i] })), {});
+                    const config = Object.assign(Object.assign({}, this.openlayerClient.defaultConfig), { inputVariableNames,
+                        prompt });
+                    if (body.stream) {
+                        const streamedResponse = response;
+                        try {
+                            for (var _l = true, streamedResponse_1 = __asyncValues(streamedResponse), streamedResponse_1_1; streamedResponse_1_1 = yield streamedResponse_1.next(), _a = streamedResponse_1_1.done, !_a; _l = true) {
+                                _c = streamedResponse_1_1.value;
+                                _l = false;
+                                const chunk = _c;
+                                // Process each chunk - for example, accumulate input data
+                                const chunkOutput = (_d = chunk.choices[0].delta.content) !== null && _d !== void 0 ? _d : '';
+                                streamedOutput += chunkOutput;
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (!_l && !_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.streamData(Object.assign(Object.assign({ latency, output: streamedOutput, timestamp: startTime }, inputVariablesMap), additionalLogs), config, this.inferencePipeline.id);
                     }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (!_l && !_a && (_b = streamedResponse_1.return)) yield _b.call(streamedResponse_1);
+                    else {
+                        const nonStreamedResponse = response;
+                        // Handle regular (non-streamed) response
+                        const endTime = Date.now();
+                        const latency = endTime - startTime;
+                        const output = nonStreamedResponse.choices[0].message.content;
+                        const tokens = (_f = (_e = nonStreamedResponse.usage) === null || _e === void 0 ? void 0 : _e.total_tokens) !== null && _f !== void 0 ? _f : 0;
+                        const inputTokens = (_h = (_g = nonStreamedResponse.usage) === null || _g === void 0 ? void 0 : _g.prompt_tokens) !== null && _h !== void 0 ? _h : 0;
+                        const outputTokens = (_k = (_j = nonStreamedResponse.usage) === null || _j === void 0 ? void 0 : _j.completion_tokens) !== null && _k !== void 0 ? _k : 0;
+                        const cost = this.cost(nonStreamedResponse.model, inputTokens, outputTokens);
+                        if (typeof output === 'string') {
+                            this.openlayerClient.streamData(Object.assign(Object.assign({ cost,
+                                latency, model: nonStreamedResponse.model, output, timestamp: startTime, tokens }, inputVariablesMap), additionalLogs), config, this.inferencePipeline.id);
+                        }
+                        else {
+                            console.error('No output received from OpenAI.');
+                        }
                     }
-                    finally { if (e_1) throw e_1.error; }
                 }
-                const endTime = Date.now();
-                const latency = endTime - startTime;
-                this.openlayerClient.streamData(Object.assign(Object.assign({ latency, output: streamedOutput, timestamp: startTime }, inputVariablesMap), additionalLogs), config, this.inferencePipeline.id);
             }
-            else {
-                const nonStreamedResponse = response;
-                // Handle regular (non-streamed) response
-                const endTime = Date.now();
-                const latency = endTime - startTime;
-                const output = nonStreamedResponse.choices[0].message.content;
-                const tokens = (_f = (_e = nonStreamedResponse.usage) === null || _e === void 0 ? void 0 : _e.total_tokens) !== null && _f !== void 0 ? _f : 0;
-                const inputTokens = (_h = (_g = nonStreamedResponse.usage) === null || _g === void 0 ? void 0 : _g.prompt_tokens) !== null && _h !== void 0 ? _h : 0;
-                const outputTokens = (_k = (_j = nonStreamedResponse.usage) === null || _j === void 0 ? void 0 : _j.completion_tokens) !== null && _k !== void 0 ? _k : 0;
-                const cost = this.cost(nonStreamedResponse.model, inputTokens, outputTokens);
-                if (typeof output !== 'string') {
-                    throw new Error('No output received from OpenAI.');
-                }
-                this.openlayerClient.streamData(Object.assign(Object.assign({ cost,
-                    latency, model: nonStreamedResponse.model, output, timestamp: startTime, tokens }, inputVariablesMap), additionalLogs), config, this.inferencePipeline.id);
+            catch (error) {
+                console.error(error);
             }
             return response;
         });
@@ -393,19 +401,18 @@ class OpenAIMonitor {
          * @param {CompletionCreateParams} body - The parameters for creating a completion.
          * @param {RequestOptions} [options] - Optional request options.
          * @returns {Promise<Completion | Stream<Completion>>} Promise that resolves to a Completion or a Stream.
-         * @throws {Error} Throws an error if monitoring is not active or if no prompt is provided.
          */
         this.createCompletion = (body, options, additionalLogs) => __awaiter(this, void 0, void 0, function* () {
             var _m, e_2, _o, _p;
             var _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1;
-            if (!this.monitoringOn) {
-                throw new Error('Monitoring is not active.');
+            if (!body.prompt) {
+                console.error('No prompt provided.');
             }
-            if (typeof this.inferencePipeline === 'undefined') {
-                throw new Error('No inference pipeline found.');
+            if (!this.monitoringOn) {
+                console.warn('Monitoring is not active.');
             }
-            if (!body.prompt) {
-                throw new Error('No prompt provided.');
+            else if (typeof this.inferencePipeline === 'undefined') {
+                console.error('No inference pipeline found.');
             }
             // Start a timer to measure latency
             const startTime = Date.now();
@@ -416,44 +423,51 @@ class OpenAIMonitor {
             let streamedInputTokens = 0;
             let streamedOutputTokens = 0;
             const response = yield this.openAIClient.completions.create(body, options);
-            const config = Object.assign(Object.assign({}, this.openlayerClient.defaultConfig), { inputVariableNames: ['input'] });
-            if (body.stream) {
-                const streamedResponse = response;
-                try {
-                    for (var _2 = true, streamedResponse_2 = __asyncValues(streamedResponse), streamedResponse_2_1; streamedResponse_2_1 = yield streamedResponse_2.next(), _m = streamedResponse_2_1.done, !_m; _2 = true) {
-                        _p = streamedResponse_2_1.value;
-                        _2 = false;
-                        const chunk = _p;
-                        // Process each chunk - for example, accumulate input data
-                        streamedModel = chunk.model;
-                        streamedOutput += chunk.choices[0].text.trim();
-                        streamedTokens += (_r = (_q = chunk.usage) === null || _q === void 0 ? void 0 : _q.total_tokens) !== null && _r !== void 0 ? _r : 0;
-                        streamedInputTokens += (_t = (_s = chunk.usage) === null || _s === void 0 ? void 0 : _s.prompt_tokens) !== null && _t !== void 0 ? _t : 0;
-                        streamedOutputTokens += (_v = (_u = chunk.usage) === null || _u === void 0 ? void 0 : _u.completion_tokens) !== null && _v !== void 0 ? _v : 0;
+            try {
+                if (this.monitoringOn && typeof this.inferencePipeline !== 'undefined') {
+                    const config = Object.assign(Object.assign({}, this.openlayerClient.defaultConfig), { inputVariableNames: ['input'] });
+                    if (body.stream) {
+                        const streamedResponse = response;
+                        try {
+                            for (var _2 = true, streamedResponse_2 = __asyncValues(streamedResponse), streamedResponse_2_1; streamedResponse_2_1 = yield streamedResponse_2.next(), _m = streamedResponse_2_1.done, !_m; _2 = true) {
+                                _p = streamedResponse_2_1.value;
+                                _2 = false;
+                                const chunk = _p;
+                                // Process each chunk - for example, accumulate input data
+                                streamedModel = chunk.model;
+                                streamedOutput += chunk.choices[0].text.trim();
+                                streamedTokens += (_r = (_q = chunk.usage) === null || _q === void 0 ? void 0 : _q.total_tokens) !== null && _r !== void 0 ? _r : 0;
+                                streamedInputTokens += (_t = (_s = chunk.usage) === null || _s === void 0 ? void 0 : _s.prompt_tokens) !== null && _t !== void 0 ? _t : 0;
+                                streamedOutputTokens += (_v = (_u = chunk.usage) === null || _u === void 0 ? void 0 : _u.completion_tokens) !== null && _v !== void 0 ? _v : 0;
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (!_2 && !_m && (_o = streamedResponse_2.return)) yield _o.call(streamedResponse_2);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                        const endTime = Date.now();
+                        const latency = endTime - startTime;
+                        const cost = this.cost(streamedModel, streamedInputTokens, streamedOutputTokens);
+                        this.openlayerClient.streamData(Object.assign({ cost, input: body.prompt, latency, output: streamedOutput, timestamp: startTime, tokens: streamedTokens }, additionalLogs), config, this.inferencePipeline.id);
                     }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (!_2 && !_m && (_o = streamedResponse_2.return)) yield _o.call(streamedResponse_2);
+                    else {
+                        const nonStreamedResponse = response;
+                        // Handle regular (non-streamed) response
+                        const endTime = Date.now();
+                        const latency = endTime - startTime;
+                        const tokens = (_x = (_w = nonStreamedResponse.usage) === null || _w === void 0 ? void 0 : _w.total_tokens) !== null && _x !== void 0 ? _x : 0;
+                        const inputTokens = (_z = (_y = nonStreamedResponse.usage) === null || _y === void 0 ? void 0 : _y.prompt_tokens) !== null && _z !== void 0 ? _z : 0;
+                        const outputTokens = (_1 = (_0 = nonStreamedResponse.usage) === null || _0 === void 0 ? void 0 : _0.completion_tokens) !== null && _1 !== void 0 ? _1 : 0;
+                        const cost = this.cost(nonStreamedResponse.model, inputTokens, outputTokens);
+                        this.openlayerClient.streamData(Object.assign({ cost, input: body.prompt, latency, output: nonStreamedResponse.choices[0].text, timestamp: startTime, tokens }, additionalLogs), config, this.inferencePipeline.id);
                     }
-                    finally { if (e_2) throw e_2.error; }
                 }
-                const endTime = Date.now();
-                const latency = endTime - startTime;
-                const cost = this.cost(streamedModel, streamedInputTokens, streamedOutputTokens);
-                this.openlayerClient.streamData(Object.assign({ cost, input: body.prompt, latency, output: streamedOutput, timestamp: startTime, tokens: streamedTokens }, additionalLogs), config, this.inferencePipeline.id);
             }
-            else {
-                const nonStreamedResponse = response;
-                // Handle regular (non-streamed) response
-                const endTime = Date.now();
-                const latency = endTime - startTime;
-                const tokens = (_x = (_w = nonStreamedResponse.usage) === null || _w === void 0 ? void 0 : _w.total_tokens) !== null && _x !== void 0 ? _x : 0;
-                const inputTokens = (_z = (_y = nonStreamedResponse.usage) === null || _y === void 0 ? void 0 : _y.prompt_tokens) !== null && _z !== void 0 ? _z : 0;
-                const outputTokens = (_1 = (_0 = nonStreamedResponse.usage) === null || _0 === void 0 ? void 0 : _0.completion_tokens) !== null && _1 !== void 0 ? _1 : 0;
-                const cost = this.cost(nonStreamedResponse.model, inputTokens, outputTokens);
-                this.openlayerClient.streamData(Object.assign({ cost, input: body.prompt, latency, output: nonStreamedResponse.choices[0].text, timestamp: startTime, tokens }, additionalLogs), config, this.inferencePipeline.id);
+            catch (error) {
+                console.error(error);
             }
             return response;
         });
@@ -480,13 +494,19 @@ class OpenAIMonitor {
                 return;
             }
             console.info('Starting monitor: creating or loading an Openlayer project and inference pipeline...');
-            this.monitoringOn = true;
-            this.project = yield this.openlayerClient.createProject(this.openlayerProjectName, 'llm-base');
-            if (typeof this.project !== 'undefined') {
-                this.inferencePipeline =
-                    yield this.openlayerClient.createInferencePipeline(this.project.id, this.openlayerInferencePipelineName);
+            try {
+                this.monitoringOn = true;
+                this.project = yield this.openlayerClient.createProject(this.openlayerProjectName, 'llm-base');
+                if (typeof this.project !== 'undefined') {
+                    this.inferencePipeline =
+                        yield this.openlayerClient.createInferencePipeline(this.project.id, this.openlayerInferencePipelineName);
+                }
+                console.info('Monitor started');
+            }
+            catch (error) {
+                console.error('An error occurred while starting the monitor:', error);
+                this.stopMonitoring();
             }
-            console.info('Monitor started');
         });
     }
     /**

package/package.json

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