openlayer 0.1.29 → 0.1.31

package/dist/index.d.ts

@@ -72,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;
@@ -188,18 +187,16 @@ 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 chatCompletionPrompt;
     private threadPrompt;
@@ -230,14 +227,10 @@ export declare class OpenAIMonitor {
      * @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>;
+    monitorThreadRun(run: Run, additionalLogs?: StreamingData): Promise<void>;
     /**
      * Starts monitoring for the OpenAI Monitor instance. If monitoring is already active, a warning is logged.
      */
-    startMonitoring(): Promise<void>;
-    /**
-     * Stops monitoring for the OpenAI Monitor instance. If monitoring is not 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'
@@ -368,10 +367,7 @@ class OpenAIMonitor {
         this.createChatCompletion = (body, options, additionalLogs) => __awaiter(this, void 0, void 0, function* () {
             var _g, e_2, _h, _j;
             var _k, _l, _m, _o, _p, _q, _r;
-            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
@@ -380,7 +376,7 @@ class OpenAIMonitor {
             let streamedOutput = '';
             const response = yield this.openAIClient.chat.completions.create(body, options);
             try {
-                if (this.monitoringOn && typeof this.inferencePipeline !== 'undefined') {
+                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,
@@ -406,7 +402,7 @@ class OpenAIMonitor {
                         }
                         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;
@@ -420,7 +416,7 @@ class OpenAIMonitor {
                         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.');
@@ -447,10 +443,7 @@ class OpenAIMonitor {
             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
@@ -463,7 +456,7 @@ 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;
@@ -490,7 +483,7 @@ class OpenAIMonitor {
                         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;
@@ -501,7 +494,7 @@ class OpenAIMonitor {
                         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);
                     }
                 }
             }
@@ -511,6 +504,7 @@ class OpenAIMonitor {
             return response;
         });
         this.openlayerProjectName = openlayerProjectName;
+        this.openlayerInferencePipelineId = openlayerInferencePipelineId;
         if (openlayerInferencePipelineName) {
             this.openlayerInferencePipelineName = openlayerInferencePipelineName;
         }
@@ -531,14 +525,14 @@ class OpenAIMonitor {
      * @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) {
+    monitorThreadRun(run, additionalLogs) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (typeof this.inferencePipeline === 'undefined') {
-                console.error('No inference pipeline found.');
+            if (run.status !== 'completed') {
                 return;
             }
-            if (run.status !== 'completed') {
+            if (typeof this.openlayerInferencePipelineId === 'undefined') {
+                console.error('No inference pipeline found.');
                 return;
             }
             try {
@@ -569,9 +563,8 @@ class OpenAIMonitor {
                     : 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);
+                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);
@@ -581,40 +574,34 @@ class OpenAIMonitor {
     /**
      * 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,57 @@
+/*
+ * 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: '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',
+});
+
+// Create monitor with your credentials
+const monitor = new OpenAIMonitor({
+  openAiApiKey: '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',
+  openlayerApiKey: 'UyKge0qbzrnAg_vehsTtw_e_mArrHHyT',
+  // EITHER specify an existing inference pipeline ID
+  openlayerInferencePipelineId: 'ef604fd7-2237-419f-90a0-4a456020ecbb',
+  // OR the project and inference pipeline names to create or load one
+  // openlayerInferencePipelineName: 'production',
+  // openlayerProjectName: 'Python QA5',
+  openlayerServerUrl: 'http://localhost:8080/v1',
+});
+
+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.29",
+  "version": "0.1.31",
   "description": "The Openlayer TypeScript client",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,7 +20,7 @@
     "eslint-plugin-typescript-sort-keys": "^3.1.0",
     "node-fetch": "^3.3.2",
     "openai": "^4.19.0",
-    "openlayer": "^0.1.27",
+    "openlayer": "^0.1.30",
     "uuid": "^9.0.1"
   },
   "devDependencies": {