openlayer 0.1.16 → 0.1.18

package/dist/index.d.ts

@@ -7,6 +7,10 @@ import { Stream } from 'openai/streaming';
  */
 export interface StreamingData {
     [columnName: string]: any;
+    /**
+     * The total estimated cost of the chat completion in USD. Optional.
+     */
+    cost?: number;
     /**
      * The latency of the chat completion in milliseconds. Optional.
      */
@@ -139,14 +143,6 @@ export declare class OpenlayerClient {
      */
     constructor({ openlayerApiKey, openlayerServerUrl, }: OpenlayerClientConstructorProps);
     private resolvedQuery;
-    /**
-     * Streams data to the Openlayer inference pipeline.
-     * @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>;
     /**
      * Creates a new inference pipeline in Openlayer or loads an existing one.
      * @param {string} projectId - The ID of the project containing the inference pipeline.
@@ -179,6 +175,14 @@ export declare class OpenlayerClient {
      * @throws {Error} Throws an error if the project is not found.
      */
     loadProject: (name: string) => Promise<OpenlayerProject>;
+    /**
+     * Streams data to the Openlayer inference pipeline.
+     * @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>;
 }
 export declare class OpenAIMonitor {
     private openlayerClient;
@@ -191,6 +195,7 @@ export declare class OpenAIMonitor {
      * @param {OpenAIMonitorConstructorProps} props - The configuration properties for the OpenAI and Openlayer clients.
      */
     constructor({ openAiApiKey, openlayerApiKey, openlayerProjectName, openlayerInferencePipelineName, openlayerServerUrl, }: OpenAIMonitorConstructorProps);
+    private cost;
     private formatChatCompletionInput;
     /**
      * Creates a chat completion using the OpenAI client and streams the result to Openlayer.
@@ -199,7 +204,7 @@ export declare class OpenAIMonitor {
      * @returns {Promise<ChatCompletion | Stream<ChatCompletionChunk>>} Promise of a ChatCompletion or a Stream
      * @throws {Error} Throws an error if monitoring is not active or if no output is received from OpenAI.
      */
-    createChatCompletion: (body: ChatCompletionCreateParams, options?: RequestOptions) => Promise<ChatCompletion | Stream<ChatCompletionChunk>>;
+    createChatCompletion: (body: ChatCompletionCreateParams, options?: RequestOptions, additionalLogs?: StreamingData) => Promise<ChatCompletion | Stream<ChatCompletionChunk>>;
     /**
      * Creates a completion using the OpenAI client and streams the result to Openlayer.
      * @param {CompletionCreateParams} body - The parameters for creating a completion.
@@ -207,7 +212,7 @@ export declare class OpenAIMonitor {
      * @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) => Promise<Completion | Stream<Completion>>;
+    createCompletion: (body: CompletionCreateParams, options?: RequestOptions, additionalLogs?: StreamingData) => Promise<Completion | Stream<Completion>>;
     /**
      * Starts monitoring for the OpenAI Monitor instance. If monitoring is already active, a warning is logged.
      */

package/dist/index.js

@@ -20,6 +20,64 @@ exports.OpenAIMonitor = exports.OpenlayerClient = void 0;
 const openai_1 = require("openai");
 const uuid_1 = require("uuid");
 const request_1 = require("./utils/request");
+const OpenAIPricing = {
+    'babbage-002': {
+        input: 0.0004,
+        output: 0.0004,
+    },
+    'davinci-002': {
+        input: 0.002,
+        output: 0.002,
+    },
+    'gpt-3.5-turbo': {
+        input: 0.003,
+        output: 0.006,
+    },
+    'gpt-3.5-turbo-0301': {
+        input: 0.0015,
+        output: 0.002,
+    },
+    'gpt-3.5-turbo-0613': {
+        input: 0.0015,
+        output: 0.002,
+    },
+    'gpt-3.5-turbo-1106': {
+        input: 0.001,
+        output: 0.002,
+    },
+    'gpt-3.5-turbo-16k-0613': {
+        input: 0.003,
+        output: 0.004,
+    },
+    'gpt-3.5-turbo-instruct': {
+        input: 0.0015,
+        output: 0.002,
+    },
+    'gpt-4': {
+        input: 0.03,
+        output: 0.06,
+    },
+    'gpt-4-0314': {
+        input: 0.03,
+        output: 0.06,
+    },
+    'gpt-4-1106-preview': {
+        input: 0.01,
+        output: 0.03,
+    },
+    'gpt-4-1106-vision-preview': {
+        input: 0.01,
+        output: 0.03,
+    },
+    'gpt-4-32k': {
+        input: 0.06,
+        output: 0.12,
+    },
+    'gpt-4-32k-0314': {
+        input: 0.06,
+        output: 0.12,
+    },
+};
 class OpenlayerClient {
     /**
      * Constructs an OpenlayerClient instance.
@@ -38,45 +96,6 @@ class OpenlayerClient {
         this.openlayerServerUrl = 'https://api.openlayer.com/v1';
         this.version = '0.1.0a16';
         this.resolvedQuery = (endpoint, args = {}) => (0, request_1.resolvedQuery)(this.openlayerServerUrl, endpoint, args);
-        /**
-         * Streams data to the Openlayer inference pipeline.
-         * @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 _a;
-            if (!this.openlayerApiKey) {
-                throw new Error('Openlayer API key are required for streaming data.');
-            }
-            try {
-                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();
-            }
-            catch (error) {
-                console.error('Error streaming data to Openlayer:', error);
-                throw error;
-            }
-        });
         /**
          * Creates a new inference pipeline in Openlayer or loads an existing one.
          * @param {string} projectId - The ID of the project containing the inference pipeline.
@@ -88,7 +107,7 @@ class OpenlayerClient {
             try {
                 return yield this.loadInferencePipeline(projectId, name);
             }
-            catch (_b) {
+            catch (_a) {
                 const createInferencePipelineEndpoint = `/projects/${projectId}/inference-pipelines`;
                 const createInferencePipelineQuery = this.resolvedQuery(createInferencePipelineEndpoint, { version: this.version });
                 const createInferencePipelineResponse = yield fetch(createInferencePipelineQuery, {
@@ -121,7 +140,7 @@ class OpenlayerClient {
             try {
                 return yield this.loadProject(name);
             }
-            catch (_c) {
+            catch (_b) {
                 const projectsEndpoint = '/projects';
                 const projectsQuery = this.resolvedQuery(projectsEndpoint);
                 const response = yield fetch(projectsQuery, {
@@ -209,6 +228,45 @@ class OpenlayerClient {
             }
             return project;
         });
+        /**
+         * Streams data to the Openlayer inference pipeline.
+         * @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.');
+            }
+            try {
+                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(((_c = data.timestamp) !== null && _c !== void 0 ? _c : 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();
+            }
+            catch (error) {
+                console.error('Error streaming data to Openlayer:', error);
+                throw error;
+            }
+        });
         this.openlayerApiKey = openlayerApiKey;
         if (openlayerServerUrl) {
             this.openlayerServerUrl = openlayerServerUrl;
@@ -227,6 +285,18 @@ class OpenAIMonitor {
     constructor({ openAiApiKey, openlayerApiKey, openlayerProjectName, openlayerInferencePipelineName, openlayerServerUrl, }) {
         this.openlayerInferencePipelineName = 'production';
         this.monitoringOn = false;
+        this.cost = (model, inputTokens, outputTokens) => {
+            const pricing = OpenAIPricing[model];
+            const inputCost = typeof pricing === 'undefined'
+                ? undefined
+                : (inputTokens / 1000) * pricing.input;
+            const outputCost = typeof pricing === 'undefined'
+                ? undefined
+                : (outputTokens / 1000) * pricing.output;
+            return typeof pricing === 'undefined'
+                ? undefined
+                : (inputCost !== null && inputCost !== void 0 ? inputCost : 0) + (outputCost !== null && outputCost !== void 0 ? outputCost : 0);
+        };
         this.formatChatCompletionInput = (messages) => messages.map(({ content, role }, i) => (role === 'user'
             ? `{{ message_${i} }}`
             : content));
@@ -237,9 +307,9 @@ class OpenAIMonitor {
          * @returns {Promise<ChatCompletion | Stream<ChatCompletionChunk>>} Promise of a ChatCompletion or a Stream
          * @throws {Error} Throws an error if monitoring is not active or if no output is received from OpenAI.
          */
-        this.createChatCompletion = (body, options) => __awaiter(this, void 0, void 0, function* () {
+        this.createChatCompletion = (body, options, additionalLogs) => __awaiter(this, void 0, void 0, function* () {
             var _a, e_1, _b, _c;
-            var _d, _e;
+            var _d, _e, _f, _g, _h, _j, _k;
             if (!this.monitoringOn) {
                 throw new Error('Monitoring is not active.');
             }
@@ -248,7 +318,7 @@ class OpenAIMonitor {
             // Start a timer to measure latency
             const startTime = Date.now();
             // Accumulate output for streamed responses
-            let outputData = '';
+            let streamedOutput = '';
             const response = yield this.openAIClient.chat.completions.create(body, options);
             const prompt = this.formatChatCompletionInput(body.messages);
             const inputVariableNames = prompt
@@ -263,24 +333,25 @@ class OpenAIMonitor {
             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) {
+                    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;
-                        _f = false;
+                        _l = false;
                         const chunk = _c;
                         // Process each chunk - for example, accumulate input data
-                        outputData += chunk.choices[0].delta.content;
+                        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 (!_f && !_a && (_b = streamedResponse_1.return)) yield _b.call(streamedResponse_1);
+                        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({ latency, output: outputData, timestamp: startTime }, inputVariablesMap), config, inferencePipeline.id);
+                this.openlayerClient.streamData(Object.assign(Object.assign({ latency, output: streamedOutput, timestamp: startTime }, inputVariablesMap), additionalLogs), config, inferencePipeline.id);
             }
             else {
                 const nonStreamedResponse = response;
@@ -288,11 +359,16 @@ class OpenAIMonitor {
                 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({ latency,
-                    output, timestamp: startTime, tokens: (_e = (_d = nonStreamedResponse.usage) === null || _d === void 0 ? void 0 : _d.total_tokens) !== null && _e !== void 0 ? _e : 0 }, inputVariablesMap), config, inferencePipeline.id);
+                this.openlayerClient.streamData(Object.assign(Object.assign({ cost,
+                    latency,
+                    output, timestamp: startTime, tokens }, inputVariablesMap), additionalLogs), config, inferencePipeline.id);
             }
             return response;
         });
@@ -303,9 +379,9 @@ class OpenAIMonitor {
          * @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) => __awaiter(this, void 0, void 0, function* () {
-            var _g, e_2, _h, _j;
-            var _k, _l, _m, _o;
+        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.');
             }
@@ -317,51 +393,50 @@ class OpenAIMonitor {
             // Start a timer to measure latency
             const startTime = Date.now();
             // Accumulate output and tokens data for streamed responses
-            let outputData = '';
-            let tokensData = 0;
+            let streamedModel = body.model;
+            let streamedOutput = '';
+            let streamedTokens = 0;
+            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 _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;
+                    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
-                        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;
+                        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 (!_p && !_g && (_h = streamedResponse_2.return)) yield _h.call(streamedResponse_2);
+                        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;
-                this.openlayerClient.streamData({
-                    input: body.prompt,
-                    latency,
-                    output: outputData,
-                    timestamp: startTime,
-                    tokens: tokensData,
-                }, config, inferencePipeline.id);
+                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, inferencePipeline.id);
             }
             else {
                 const nonStreamedResponse = response;
                 // Handle regular (non-streamed) response
                 const endTime = Date.now();
                 const latency = endTime - startTime;
-                this.openlayerClient.streamData({
-                    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,
-                }, config, inferencePipeline.id);
+                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, inferencePipeline.id);
             }
             return response;
         });

package/package.json

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