openlayer 0.1.27 → 0.1.29

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { RequestOptions } from 'openai/core';
 import { ChatCompletion, ChatCompletionChunk, ChatCompletionCreateParams, ChatCompletionMessageParam, Completion, CompletionCreateParams } from 'openai/resources';
+import { Run } from 'openai/resources/beta/threads/runs/runs';
 import { Stream } from 'openai/streaming';
 /**
  * Represents the data structure for a chat completion.
@@ -143,7 +144,6 @@ export declare class OpenlayerClient {
     /**
      * Constructs an OpenlayerClient instance.
      * @param {OpenlayerClientConstructorProps} props - The config for the Openlayer client. The API key is required.
-     * @throws {Error} Throws an error if the Openlayer API key is not provided.
      */
     constructor({ openlayerApiKey, openlayerServerUrl, }: OpenlayerClientConstructorProps);
     private resolvedQuery;
@@ -201,22 +201,36 @@ export declare class OpenAIMonitor {
      */
     constructor({ openAiApiKey, openlayerApiKey, openlayerProjectName, openlayerInferencePipelineName, openlayerServerUrl, }: OpenAIMonitorConstructorProps);
     private cost;
-    private formatChatCompletionInput;
+    private chatCompletionPrompt;
+    private threadPrompt;
+    private inputVariables;
     /**
      * Creates a chat completion using the OpenAI client and streams the result to Openlayer.
      * @param {ChatCompletionCreateParams} body - The parameters for creating a chat completion.
      * @param {RequestOptions} [options] - Optional request options.
+     * @param {StreamingData} [additionalLogs] - Optional metadata logs to include with the request sent to Openlayer.
      * @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.
+     * @throws {Error} Throws errors from the OpenAI client.
      */
     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.
      * @param {RequestOptions} [options] - Optional request options.
+     * @param {StreamingData} [additionalLogs] - Optional metadata logs to include with the request sent to Openlayer.
      * @returns {Promise<Completion | Stream<Completion>>} Promise that resolves to a Completion or a Stream.
+     * @throws {Error} Throws errors from the OpenAI client.
      */
     createCompletion: (body: CompletionCreateParams, options?: RequestOptions, additionalLogs?: StreamingData) => Promise<Completion | Stream<Completion>>;
+    /**
+     * Monitor a run from an OpenAI assistant.
+     * Once the run is completed, the thread data is published to Openlayer,
+     * along with the latency, cost, and number of tokens used.
+     * @param {Run} run - The run created by the OpenAI assistant.
+     * @param {StreamingData} [additionalLogs] - Optional metadata logs to include with the request sent to Openlayer.
+     * @returns {Promise<void>} A promise that resolves when the run data has been successfully published to Openlayer.
+     */
+    logThreadRun(run: Run, additionalLogs?: StreamingData): Promise<void>;
     /**
      * Starts monitoring for the OpenAI Monitor instance. If monitoring is already active, a warning is logged.
      */

package/dist/index.js

@@ -98,7 +98,6 @@ class OpenlayerClient {
     /**
      * Constructs an OpenlayerClient instance.
      * @param {OpenlayerClientConstructorProps} props - The config for the Openlayer client. The API key is required.
-     * @throws {Error} Throws an error if the Openlayer API key is not provided.
      */
     constructor({ openlayerApiKey, openlayerServerUrl, }) {
         this.defaultConfig = {
@@ -311,20 +310,64 @@ class OpenAIMonitor {
                 ? undefined
                 : (inputCost !== null && inputCost !== void 0 ? inputCost : 0) + (outputCost !== null && outputCost !== void 0 ? outputCost : 0);
         };
-        this.formatChatCompletionInput = (messages) => messages.map(({ content, role }, i) => ({
+        this.chatCompletionPrompt = (fromMessages) => fromMessages.map(({ content, role }, i) => ({
             content: role === 'user' ? `{{ message_${i} }}` : content,
             role,
         }));
+        this.threadPrompt = (fromMessages) => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            const messages = [];
+            try {
+                for (var _d = true, _e = __asyncValues(fromMessages.iterPages()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const page = _c;
+                    messages.push(...page.getPaginatedItems());
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return messages
+                .map(({ content, role }) => content.map((item) => ({
+                content: (() => {
+                    switch (item.type) {
+                        case 'image_file':
+                            return item.image_file.file_id;
+                        case 'text':
+                        default:
+                            return item.text.value;
+                    }
+                })(),
+                role,
+            })))
+                .flat();
+        });
+        this.inputVariables = (fromPrompt, andMessages) => {
+            const inputVariableNames = fromPrompt
+                .filter(({ role }) => role === 'user')
+                .map(({ content }) => String(content).replace(/{{\s*|\s*}}/g, ''));
+            const inputVariables = andMessages
+                .filter(({ role }) => role === 'user')
+                .map(({ content }) => content);
+            const inputVariablesMap = inputVariableNames.reduce((acc, name, i) => (Object.assign(Object.assign({}, acc), { [name]: inputVariables[i] })), {});
+            return { inputVariableNames, inputVariables, inputVariablesMap };
+        };
         /**
          * Creates a chat completion using the OpenAI client and streams the result to Openlayer.
          * @param {ChatCompletionCreateParams} body - The parameters for creating a chat completion.
          * @param {RequestOptions} [options] - Optional request options.
+         * @param {StreamingData} [additionalLogs] - Optional metadata logs to include with the request sent to Openlayer.
          * @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.
+         * @throws {Error} Throws errors from the OpenAI client.
          */
         this.createChatCompletion = (body, options, additionalLogs) => __awaiter(this, void 0, void 0, function* () {
-            var _a, e_1, _b, _c;
-            var _d, _e, _f, _g, _h, _j, _k;
+            var _g, e_2, _h, _j;
+            var _k, _l, _m, _o, _p, _q, _r;
             if (!this.monitoringOn) {
                 console.warn('Monitoring is not active.');
             }
@@ -338,34 +381,28 @@ class OpenAIMonitor {
             const response = yield this.openAIClient.chat.completions.create(body, options);
             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 prompt = this.chatCompletionPrompt(body.messages);
+                    const { inputVariableNames, inputVariablesMap } = this.inputVariables(prompt, body.messages);
                     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;
+                            for (var _s = true, streamedResponse_1 = __asyncValues(streamedResponse), streamedResponse_1_1; streamedResponse_1_1 = yield streamedResponse_1.next(), _g = streamedResponse_1_1.done, !_g; _s = true) {
+                                _j = streamedResponse_1_1.value;
+                                _s = false;
+                                const chunk = _j;
                                 // Process each chunk - for example, accumulate input data
-                                const chunkOutput = (_d = chunk.choices[0].delta.content) !== null && _d !== void 0 ? _d : '';
+                                const chunkOutput = (_k = chunk.choices[0].delta.content) !== null && _k !== void 0 ? _k : '';
                                 streamedOutput += chunkOutput;
                             }
                         }
-                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
                         finally {
                             try {
-                                if (!_l && !_a && (_b = streamedResponse_1.return)) yield _b.call(streamedResponse_1);
+                                if (!_s && !_g && (_h = streamedResponse_1.return)) yield _h.call(streamedResponse_1);
                             }
-                            finally { if (e_1) throw e_1.error; }
+                            finally { if (e_2) throw e_2.error; }
                         }
                         const endTime = Date.now();
                         const latency = endTime - startTime;
@@ -377,9 +414,9 @@ 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 tokens = (_m = (_l = nonStreamedResponse.usage) === null || _l === void 0 ? void 0 : _l.total_tokens) !== null && _m !== void 0 ? _m : 0;
+                        const inputTokens = (_p = (_o = nonStreamedResponse.usage) === null || _o === void 0 ? void 0 : _o.prompt_tokens) !== null && _p !== void 0 ? _p : 0;
+                        const outputTokens = (_r = (_q = nonStreamedResponse.usage) === null || _q === void 0 ? void 0 : _q.completion_tokens) !== null && _r !== void 0 ? _r : 0;
                         const cost = this.cost(nonStreamedResponse.model, inputTokens, outputTokens);
                         if (typeof output === 'string') {
                             this.openlayerClient.streamData(Object.assign(Object.assign({ cost,
@@ -400,11 +437,13 @@ class OpenAIMonitor {
          * Creates a completion using the OpenAI client and streams the result to Openlayer.
          * @param {CompletionCreateParams} body - The parameters for creating a completion.
          * @param {RequestOptions} [options] - Optional request options.
+         * @param {StreamingData} [additionalLogs] - Optional metadata logs to include with the request sent to Openlayer.
          * @returns {Promise<Completion | Stream<Completion>>} Promise that resolves to a Completion or a Stream.
+         * @throws {Error} Throws errors from the OpenAI client.
          */
         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;
+            var _t, e_3, _u, _v;
+            var _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7;
             if (!body.prompt) {
                 console.error('No prompt provided.');
             }
@@ -429,24 +468,24 @@ class OpenAIMonitor {
                     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;
+                            for (var _8 = true, streamedResponse_2 = __asyncValues(streamedResponse), streamedResponse_2_1; streamedResponse_2_1 = yield streamedResponse_2.next(), _t = streamedResponse_2_1.done, !_t; _8 = true) {
+                                _v = streamedResponse_2_1.value;
+                                _8 = false;
+                                const chunk = _v;
                                 // 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;
+                                streamedTokens += (_x = (_w = chunk.usage) === null || _w === void 0 ? void 0 : _w.total_tokens) !== null && _x !== void 0 ? _x : 0;
+                                streamedInputTokens += (_z = (_y = chunk.usage) === null || _y === void 0 ? void 0 : _y.prompt_tokens) !== null && _z !== void 0 ? _z : 0;
+                                streamedOutputTokens += (_1 = (_0 = chunk.usage) === null || _0 === void 0 ? void 0 : _0.completion_tokens) !== null && _1 !== void 0 ? _1 : 0;
                             }
                         }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
                         finally {
                             try {
-                                if (!_2 && !_m && (_o = streamedResponse_2.return)) yield _o.call(streamedResponse_2);
+                                if (!_8 && !_t && (_u = streamedResponse_2.return)) yield _u.call(streamedResponse_2);
                             }
-                            finally { if (e_2) throw e_2.error; }
+                            finally { if (e_3) throw e_3.error; }
                         }
                         const endTime = Date.now();
                         const latency = endTime - startTime;
@@ -458,9 +497,9 @@ class OpenAIMonitor {
                         // 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 tokens = (_3 = (_2 = nonStreamedResponse.usage) === null || _2 === void 0 ? void 0 : _2.total_tokens) !== null && _3 !== void 0 ? _3 : 0;
+                        const inputTokens = (_5 = (_4 = nonStreamedResponse.usage) === null || _4 === void 0 ? void 0 : _4.prompt_tokens) !== null && _5 !== void 0 ? _5 : 0;
+                        const outputTokens = (_7 = (_6 = nonStreamedResponse.usage) === null || _6 === void 0 ? void 0 : _6.completion_tokens) !== null && _7 !== void 0 ? _7 : 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);
                     }
@@ -484,6 +523,61 @@ class OpenAIMonitor {
             dangerouslyAllowBrowser: true,
         });
     }
+    /**
+     * Monitor a run from an OpenAI assistant.
+     * Once the run is completed, the thread data is published to Openlayer,
+     * along with the latency, cost, and number of tokens used.
+     * @param {Run} run - The run created by the OpenAI assistant.
+     * @param {StreamingData} [additionalLogs] - Optional metadata logs to include with the request sent to Openlayer.
+     * @returns {Promise<void>} A promise that resolves when the run data has been successfully published to Openlayer.
+     */
+    logThreadRun(run, additionalLogs) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof this.inferencePipeline === 'undefined') {
+                console.error('No inference pipeline found.');
+                return;
+            }
+            if (run.status !== 'completed') {
+                return;
+            }
+            try {
+                const { assistant_id, completed_at, created_at, model, thread_id, 
+                // @ts-ignore
+                usage, } = run;
+                // @ts-ignore
+                const { completion_tokens, prompt_tokens, total_tokens } = typeof usage === 'undefined' ||
+                    typeof usage !== 'object' ||
+                    usage === null
+                    ? {}
+                    : usage;
+                const cost = this.cost(model, prompt_tokens, completion_tokens);
+                const latency = completed_at === null ||
+                    created_at === null ||
+                    isNaN(completed_at) ||
+                    isNaN(created_at)
+                    ? undefined
+                    : (completed_at - created_at) * 1000;
+                const messages = yield this.openAIClient.beta.threads.messages.list(thread_id, { order: 'asc' });
+                const populatedPrompt = yield this.threadPrompt(messages);
+                const prompt = this.chatCompletionPrompt(populatedPrompt);
+                const { inputVariableNames, inputVariablesMap } = this.inputVariables(prompt, populatedPrompt);
+                const config = Object.assign(Object.assign({}, this.openlayerClient.defaultConfig), { inputVariableNames, prompt: prompt.slice(0, prompt.length - 1) });
+                const output = (_a = prompt[prompt.length - 1]) === null || _a === void 0 ? void 0 : _a.content;
+                const resolvedOutput = typeof output === 'string'
+                    ? output
+                    : typeof output === 'undefined' || output === null
+                        ? ''
+                        : `${output}`;
+                this.openlayerClient.streamData(Object.assign(Object.assign({ assistant_id,
+                    cost,
+                    latency, output: resolvedOutput, thread_id, timestamp: run.created_at, tokens: total_tokens }, inputVariablesMap), additionalLogs), config, this.inferencePipeline.id);
+            }
+            catch (error) {
+                console.error('Error logging thread run:', error);
+            }
+        });
+    }
     /**
      * Starts monitoring for the OpenAI Monitor instance. If monitoring is already active, a warning is logged.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openlayer",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "description": "The Openlayer TypeScript client",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,6 +20,7 @@
     "eslint-plugin-typescript-sort-keys": "^3.1.0",
     "node-fetch": "^3.3.2",
     "openai": "^4.19.0",
+    "openlayer": "^0.1.27",
     "uuid": "^9.0.1"
   },
   "devDependencies": {