openlayer 0.1.28 → 0.1.30

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.
@@ -71,14 +72,13 @@ interface StreamingDataConfig {
 }
 type OpenlayerClientConstructorProps = {
     openlayerApiKey?: string;
-    openlayerInferencePipelineName?: string;
-    openlayerProjectName?: string;
     openlayerServerUrl?: string;
 };
 type OpenAIMonitorConstructorProps = OpenlayerClientConstructorProps & {
     openAiApiKey: string;
+    openlayerInferencePipelineId?: string;
     openlayerInferencePipelineName?: string;
-    openlayerProjectName: string;
+    openlayerProjectName?: string;
 };
 type OpenlayerInferencePipeline = {
     dataVolumeGraphs?: OpenlayerSampleVolumeGraph;
@@ -187,24 +187,25 @@ export declare class OpenlayerClient {
     streamData: (data: StreamingData, config: StreamingDataConfig, inferencePipelineId: string) => Promise<void>;
 }
 export declare class OpenAIMonitor {
-    private inferencePipeline?;
     private openlayerClient;
     private openAIClient;
-    private openlayerProjectName;
+    private openlayerProjectName?;
+    private openlayerInferencePipelineId?;
     private openlayerInferencePipelineName;
-    private monitoringOn;
-    private project?;
     /**
      * Constructs an OpenAIMonitor instance.
      * @param {OpenAIMonitorConstructorProps} props - The configuration properties for the OpenAI and Openlayer clients.
      */
-    constructor({ openAiApiKey, openlayerApiKey, openlayerProjectName, openlayerInferencePipelineName, openlayerServerUrl, }: OpenAIMonitorConstructorProps);
+    constructor({ openAiApiKey, openlayerApiKey, openlayerProjectName, openlayerInferencePipelineId, 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 errors from the OpenAI client.
      */
@@ -213,17 +214,23 @@ export declare 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.
      */
     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.
+     * 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.
      */
-    startMonitoring(): Promise<void>;
+    monitorThreadRun(run: Run, additionalLogs?: StreamingData): Promise<void>;
     /**
-     * Stops monitoring for the OpenAI Monitor instance. If monitoring is not active, a warning is logged.
+     * Starts monitoring for the OpenAI Monitor instance. If monitoring is already active, a warning is logged.
      */
-    stopMonitoring(): void;
+    initialize(): Promise<void>;
 }
 export {};

package/dist/index.js

@@ -295,9 +295,8 @@ class OpenAIMonitor {
      * Constructs an OpenAIMonitor instance.
      * @param {OpenAIMonitorConstructorProps} props - The configuration properties for the OpenAI and Openlayer clients.
      */
-    constructor({ openAiApiKey, openlayerApiKey, openlayerProjectName, openlayerInferencePipelineName, openlayerServerUrl, }) {
+    constructor({ openAiApiKey, openlayerApiKey, openlayerProjectName, openlayerInferencePipelineId, openlayerInferencePipelineName, openlayerServerUrl, }) {
         this.openlayerInferencePipelineName = 'production';
-        this.monitoringOn = false;
         this.cost = (model, inputTokens, outputTokens) => {
             const pricing = OpenAIPricing[model];
             const inputCost = typeof pricing === 'undefined'
@@ -310,24 +309,65 @@ 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 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;
-            if (!this.monitoringOn) {
-                console.warn('Monitoring is not active.');
-            }
-            else if (typeof this.inferencePipeline === 'undefined') {
+            var _g, e_2, _h, _j;
+            var _k, _l, _m, _o, _p, _q, _r;
+            if (typeof this.openlayerInferencePipelineId === 'undefined') {
                 console.error('No inference pipeline found.');
             }
             // Start a timer to measure latency
@@ -336,39 +376,33 @@ class OpenAIMonitor {
             let streamedOutput = '';
             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] })), {});
+                if (typeof this.openlayerInferencePipelineId !== 'undefined') {
+                    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;
-                        this.openlayerClient.streamData(Object.assign(Object.assign({ latency, output: streamedOutput, timestamp: startTime }, inputVariablesMap), additionalLogs), config, this.inferencePipeline.id);
+                        this.openlayerClient.streamData(Object.assign(Object.assign({ latency, output: streamedOutput, timestamp: startTime }, inputVariablesMap), additionalLogs), config, this.openlayerInferencePipelineId);
                     }
                     else {
                         const nonStreamedResponse = response;
@@ -376,13 +410,13 @@ 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,
-                                latency, model: nonStreamedResponse.model, output, timestamp: startTime, tokens }, inputVariablesMap), additionalLogs), config, this.inferencePipeline.id);
+                                latency, model: nonStreamedResponse.model, output, timestamp: startTime, tokens }, inputVariablesMap), additionalLogs), config, this.openlayerInferencePipelineId);
                         }
                         else {
                             console.error('No output received from OpenAI.');
@@ -399,19 +433,17 @@ 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.');
             }
-            if (!this.monitoringOn) {
-                console.warn('Monitoring is not active.');
-            }
-            else if (typeof this.inferencePipeline === 'undefined') {
+            if (typeof this.openlayerInferencePipelineId === 'undefined') {
                 console.error('No inference pipeline found.');
             }
             // Start a timer to measure latency
@@ -424,45 +456,45 @@ class OpenAIMonitor {
             let streamedOutputTokens = 0;
             const response = yield this.openAIClient.completions.create(body, options);
             try {
-                if (this.monitoringOn && typeof this.inferencePipeline !== 'undefined') {
+                if (typeof this.openlayerInferencePipelineId !== '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;
+                            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;
                         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);
+                        this.openlayerClient.streamData(Object.assign({ cost, input: body.prompt, latency, output: streamedOutput, timestamp: startTime, tokens: streamedTokens }, additionalLogs), config, this.openlayerInferencePipelineId);
                     }
                     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 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);
+                        this.openlayerClient.streamData(Object.assign({ cost, input: body.prompt, latency, output: nonStreamedResponse.choices[0].text, timestamp: startTime, tokens }, additionalLogs), config, this.openlayerInferencePipelineId);
                     }
                 }
             }
@@ -472,6 +504,7 @@ class OpenAIMonitor {
             return response;
         });
         this.openlayerProjectName = openlayerProjectName;
+        this.openlayerInferencePipelineId = openlayerInferencePipelineId;
         if (openlayerInferencePipelineName) {
             this.openlayerInferencePipelineName = openlayerInferencePipelineName;
         }
@@ -484,43 +517,91 @@ 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.
+     */
+    monitorThreadRun(run, additionalLogs) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof this.openlayerInferencePipelineId === '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({ 'OpenAI Assistant ID': assistant_id, 'OpenAI Thread ID': thread_id, cost,
+                    latency, output: resolvedOutput, timestamp: run.created_at, tokens: total_tokens }, inputVariablesMap), additionalLogs), config, this.openlayerInferencePipelineId);
+            }
+            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.
      */
-    startMonitoring() {
+    initialize() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.monitoringOn) {
-                console.warn('Monitor is already on.');
+            console.info('Initializing monitor: creating or loading an Openlayer project and inference pipeline...');
+            if (typeof this.openlayerInferencePipelineId !== 'undefined') {
+                console.info('Monitor initialized: using inference pipeline ID provided.');
                 return;
             }
-            console.info('Starting monitor: creating or loading an Openlayer project and inference pipeline...');
             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);
+                if (typeof this.openlayerProjectName === 'undefined') {
+                    console.error('No project name provided.');
+                    return;
+                }
+                const project = yield this.openlayerClient.createProject(this.openlayerProjectName, 'llm-base');
+                if (typeof project !== 'undefined') {
+                    const inferencePipeline = yield this.openlayerClient.createInferencePipeline(project.id, this.openlayerInferencePipelineName);
+                    if (typeof (inferencePipeline === null || inferencePipeline === void 0 ? void 0 : inferencePipeline.id) === 'undefined') {
+                        console.error('Unable to locate inference pipeline.');
+                    }
+                    else {
+                        this.openlayerInferencePipelineId = inferencePipeline.id;
+                    }
                 }
                 console.info('Monitor started');
             }
             catch (error) {
                 console.error('An error occurred while starting the monitor:', error);
-                this.stopMonitoring();
             }
         });
     }
-    /**
-     * Stops monitoring for the OpenAI Monitor instance. If monitoring is not active, a warning is logged.
-     */
-    stopMonitoring() {
-        if (!this.monitoringOn) {
-            console.warn('Monitor is not active.');
-            return;
-        }
-        this.monitoringOn = false;
-        this.project = undefined;
-        this.inferencePipeline = undefined;
-        console.info('Monitor stopped.');
-    }
 }
 exports.OpenAIMonitor = OpenAIMonitor;

package/examples/openai_assistant_monitor.mjs

@@ -0,0 +1,56 @@
+/*
+ * This example shows how to use Openlayer to monitor runs from OpenAI assistants.
+ */
+
+import OpenAI from 'openai';
+import { OpenAIMonitor } from 'openlayer';
+
+const openai = new OpenAI({
+  apiKey: 'YOUR_OPENAI_API_KEY',
+});
+
+// Create monitor with your credentials
+const monitor = new OpenAIMonitor({
+  openAiApiKey: 'YOUR_OPENAI_API_KEY',
+  openlayerApiKey: 'YOUR_OPENLAYER_API_KEY',
+  // EITHER specify an existing inference pipeline ID
+  openlayerInferencePipelineId: 'YOUR_OPENLAYER_INFERENCE_PIPELINE_ID',
+  // OR the project and inference pipeline names to create or load one
+  openlayerInferencePipelineName: 'production',
+  openlayerProjectName: 'YOUR_OPENLAYER_PROJECT_NAME',
+});
+
+await monitor.initialize();
+
+// Create the assistant
+const assistant = await openai.beta.assistants.create({
+  description:
+    'You are great at creating and explaining beautiful data visualizations.',
+  model: 'gpt-4',
+  name: 'Data visualizer',
+  tools: [{ type: 'code_interpreter' }],
+});
+
+// Create a thread
+const thread = await openai.beta.threads.create({
+  messages: [
+    {
+      content: 'Create a data visualization of the american GDP.',
+      role: 'user',
+    },
+  ],
+});
+
+// Run the assistant on the thread
+const run = await openai.beta.threads.runs.create(thread.id, {
+  assistant_id: assistant.id,
+});
+
+// Keep polling the run results
+let runStatus = await openai.beta.threads.runs.retrieve(thread.id, run.id);
+while (runStatus.status !== 'completed') {
+  runStatus = await openai.beta.threads.runs.retrieve(thread.id, run.id);
+
+  // Monitor the run. If complete, it will be sent to Openlayer
+  await monitor.monitorThreadRun(runStatus);
+}

package/examples/openai_monitor.mjs

@@ -7,11 +7,14 @@ import { OpenAIMonitor } from 'openlayer';
 const monitor = new OpenAIMonitor({
   openAiApiKey: 'YOUR_OPENAI_API_KEY',
   openlayerApiKey: 'YOUR_OPENLAYER_API_KEY',
+  // EITHER specify an existing inference pipeline ID
+  openlayerInferencePipelineId: 'YOUR_OPENLAYER_INFERENCE_PIPELINE_ID',
+  // OR the project and inference pipeline names to create or load one
   openlayerInferencePipelineName: 'production',
   openlayerProjectName: 'YOUR_OPENLAYER_PROJECT_NAME',
 });
 
-await monitor.startMonitoring();
+await monitor.initialize();
 
 const inputs = [
   {

package/package.json

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