openlayer 0.1.4 → 0.1.5

package/dist/index.d.ts

@@ -1,13 +1,66 @@
 import { RequestOptions } from 'openai/core';
 import { ChatCompletion, ChatCompletionChunk, ChatCompletionCreateParams, Completion, CompletionCreateParams } from 'openai/resources';
 import { Stream } from 'openai/streaming';
+/**
+ * Represents the data structure for a chat completion.
+ */
 export interface ChatCompletionData {
-    input: string | string[] | number[] | number[][] | null;
-    latency: number;
-    output: string | null;
-    timestamp: number;
+    [key: string]: any;
+    /**
+     * The input data for the chat completion. It can be a string, an array of strings,
+     * or a nested array of numbers.
+     */
+    input: string | string[] | number[] | number[][];
+    /**
+     * The latency of the chat completion in milliseconds. Optional.
+     */
+    latency?: number;
+    /**
+     * The output string generated by the chat completion.
+     */
+    output: string;
+    /**
+     * A timestamp representing when the chat completion occurred. Optional.
+     */
+    timestamp?: number;
+    /**
+     * The number of tokens used in the chat completion. Optional.
+     */
     tokens?: number;
 }
+/**
+ * Configuration settings for uploading chat completion data to Openlayer.
+ */
+export interface ChatCompletionConfig {
+    /**
+     * The name of the column that stores the ground truth data. Can be null.
+     */
+    groundTruthColumnName: string | null;
+    /**
+     * The name of the column that stores inference IDs. Can be null.
+     */
+    inferenceIdColumnName: string | null;
+    /**
+     * An array of names for input variable columns. Can be null.
+     */
+    inputVariableNames: string[] | null;
+    /**
+     * The name of the column that stores latency data. Can be null.
+     */
+    latencyColumnName: string | null;
+    /**
+     * The name of the column that stores the number of tokens. Can be null.
+     */
+    numOfTokenColumnName: string | null;
+    /**
+     * The name of the column that stores output data. Can be null.
+     */
+    outputColumnName: string | null;
+    /**
+     * The name of the column that stores timestamp data. Can be null.
+     */
+    timestampColumnName: string | null;
+}
 type ConstructorProps = {
     openAiApiKey: string;
     openlayerApiKey?: string;
@@ -15,10 +68,66 @@ type ConstructorProps = {
     openlayerProjectName?: string;
     openlayerServerUrl?: string;
 };
+type OpenlayerInferencePipeline = {
+    dataVolumeGraphs?: OpenlayerSampleVolumeGraph;
+    dateCreated: string;
+    dateLastEvaluated?: string;
+    dateLastSampleReceived?: string;
+    dateOfNextEvaluation?: string;
+    dateUpdated: string;
+    description?: string;
+    failingGoalCount: number;
+    id: string;
+    name: string;
+    passingGoalCount: number;
+    projectId: string;
+    status: OpenlayerInferencePipelineStatus;
+    statusMessage?: string;
+    totalGoalCount: number;
+};
+type OpenlayerInferencePipelineStatus = 'completed' | 'failed' | 'paused' | 'queued' | 'running' | 'unknown';
+type OpenlayerProject = {
+    dateCreated: string;
+    dateUpdated: string;
+    description?: string;
+    developmentGoalCount: number;
+    goalCount: number;
+    id: string;
+    inferencePipelineCount: number;
+    memberIds: string[];
+    monitoringGoalCount: number;
+    name: string;
+    sample?: boolean;
+    slackChannelId?: string;
+    slackChannelName?: string;
+    slackChannelNotificationsEnabled: boolean;
+    taskType: OpenlayerTaskType;
+    unreadNotificationCount: number;
+    versionCount: number;
+};
+type OpenlayerSampleVolumeGraphBucket = {
+    title: string;
+    xAxis: {
+        data: string[];
+        title: string;
+    };
+    yAxis: {
+        data: number[];
+        title: string;
+    };
+};
+type OpenlayerSampleVolumeGraph = {
+    daily: OpenlayerSampleVolumeGraphBucket;
+    hourly: OpenlayerSampleVolumeGraphBucket;
+    monthly: OpenlayerSampleVolumeGraphBucket;
+    weekly: OpenlayerSampleVolumeGraphBucket;
+};
+type OpenlayerTaskType = 'llm-base' | 'tabular-classification' | 'tabular-regression' | 'text-classification';
 declare class OpenAIMonitor {
     private OpenAIClient;
     private monitoringOn;
     private openlayerApiKey?;
+    private openlayerDefaultDataConfig;
     private openlayerProjectName?;
     private openlayerInferencePipelineName?;
     private openlayerServerUrl;
@@ -26,10 +135,67 @@ declare class OpenAIMonitor {
     constructor({ openAiApiKey, openlayerApiKey, openlayerInferencePipelineName, openlayerProjectName, openlayerServerUrl, }: ConstructorProps);
     private formatChatCompletionInput;
     private resolvedQuery;
-    uploadDataToOpenlayer: (data: ChatCompletionData) => Promise<void>;
-    startMonitoring(): void;
-    stopMonitoring(): void;
+    private uploadToInferencePipeline;
+    /**
+     * Uploads data to Openlayer. This function takes ChatCompletionData and an optional
+     * ChatCompletionConfig, then uploads the data to the specified Openlayer Inference Pipeline.
+     * @param data The ChatCompletionData to be uploaded.
+     * @param config Configuration for the data upload.
+     * @throws Throws an error if Openlayer API key or project name are not set.
+     * @returns A promise that resolves when the data has been successfully uploaded.
+     */
+    uploadDataToOpenlayer: (data: ChatCompletionData, config: ChatCompletionConfig) => Promise<void>;
+    /**
+     * Creates a new ChatCompletion instance. If monitoring is not active, an error is thrown.
+     * This function also measures latency and uploads data to Openlayer.
+     * @param body The parameters for creating a chat completion.
+     * @param options Optional request options.
+     * @throws Throws an error if monitoring is not active or if there is no output received from OpenAI.
+     * @returns A promise that resolves to a ChatCompletion or a Stream of ChatCompletionChunks.
+     */
     createChatCompletion: (body: ChatCompletionCreateParams, options?: RequestOptions) => Promise<ChatCompletion | Stream<ChatCompletionChunk>>;
+    /**
+     * Creates a new Completion instance. If monitoring is not active, an error is thrown.
+     * This function also measures latency and uploads data to Openlayer.
+     * @param body The parameters for creating a completion.
+     * @param options Optional request options.
+     * @throws Throws an error if monitoring is not active or if no prompt is provided.
+     * @returns A promise that resolves to a Completion or a Stream of Completions.
+     */
     createCompletion: (body: CompletionCreateParams, options?: RequestOptions) => Promise<Completion | Stream<Completion>>;
+    /**
+     * Creates a new inference pipeline in Openlayer, or loads an existing one if it already exists.
+     * @param name The name of the inference pipeline.
+     * @param projectId The project ID containing the inference pipeline.
+     * @throws Throws an error if the inference pipeline cannot be created or found.
+     * @returns A promise that resolves to an OpenlayerInferencePipeline object.
+     */
+    createInferencePipeline: (name: string, projectId: string) => Promise<OpenlayerInferencePipeline>;
+    /**
+     * Creates a new project in Openlayer, or loads an existing one if it already exists.
+     * @param name The name of the project.
+     * @param taskType The type of task associated with the project.
+     * @param description Optional description of the project.
+     * @throws Throws an error if the project cannot be created or found.
+     * @returns A promise that resolves to an OpenlayerProject object.
+     */
+    createProject: (name: string, taskType: OpenlayerTaskType, description?: string) => Promise<OpenlayerProject>;
+    /**
+     * Loads an existing inference pipeline from Openlayer based on its name and project ID.
+     * @param name The name of the inference pipeline.
+     * @param projectId The project ID containing the inference pipeline.
+     * @throws Throws an error if the inference pipeline is not found.
+     * @returns A promise that resolves to an OpenlayerInferencePipeline object.
+     */
+    loadInferencePipeline: (name: string, projectId: string) => Promise<OpenlayerInferencePipeline>;
+    loadProject: (name: string) => Promise<OpenlayerProject>;
+    /**
+     * Starts monitoring for the OpenAI Monitor instance. If monitoring is already active, a warning is logged.
+     */
+    startMonitoring(): void;
+    /**
+     * Stops monitoring for the OpenAI Monitor instance. If monitoring is not active, a warning is logged.
+     */
+    stopMonitoring(): void;
 }
 export default OpenAIMonitor;

package/dist/index.js

@@ -22,6 +22,15 @@ const request_1 = require("./utils/request");
 class OpenAIMonitor {
     constructor({ openAiApiKey, openlayerApiKey, openlayerInferencePipelineName, openlayerProjectName, openlayerServerUrl, }) {
         this.monitoringOn = false;
+        this.openlayerDefaultDataConfig = {
+            groundTruthColumnName: null,
+            inferenceIdColumnName: 'id',
+            inputVariableNames: ['input'],
+            latencyColumnName: 'latency',
+            numOfTokenColumnName: 'tokens',
+            outputColumnName: 'output',
+            timestampColumnName: 'timestamp',
+        };
         this.openlayerServerUrl = 'https://api.openlayer.com/v1';
         this.version = '0.1.0a16';
         this.formatChatCompletionInput = (messages) => messages
@@ -30,115 +39,62 @@ class OpenAIMonitor {
             .join('\n')
             .trim();
         this.resolvedQuery = (endpoint, args = {}) => (0, request_1.resolvedQuery)(this.openlayerServerUrl, endpoint, args);
-        this.uploadDataToOpenlayer = (data) => __awaiter(this, void 0, void 0, function* () {
-            const uploadToInferencePipeline = (id) => __awaiter(this, void 0, void 0, function* () {
-                const dataStreamEndpoint = `/inference-pipelines/${id}/data-stream`;
-                const dataStreamQuery = this.resolvedQuery(dataStreamEndpoint);
-                const response = yield fetch(dataStreamQuery, {
-                    body: JSON.stringify({
-                        config: {
-                            groundTruthColumnName: null,
-                            inferenceIdColumnName: 'id',
-                            inputVariableNames: ['input'],
-                            latencyColumnName: 'latency',
-                            numOfTokenColumnName: 'tokens',
-                            outputColumnName: 'output',
-                            timestampColumnName: 'timestamp',
-                        },
-                        rows: [
-                            Object.assign(Object.assign({}, data), { id: (0, uuid_1.v4)(), timestamp: Math.round(data.timestamp / 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();
+        this.uploadToInferencePipeline = (inferencePipelineId, data, config) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            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();
+        });
+        /**
+         * Uploads data to Openlayer. This function takes ChatCompletionData and an optional
+         * ChatCompletionConfig, then uploads the data to the specified Openlayer Inference Pipeline.
+         * @param data The ChatCompletionData to be uploaded.
+         * @param config Configuration for the data upload.
+         * @throws Throws an error if Openlayer API key or project name are not set.
+         * @returns A promise that resolves when the data has been successfully uploaded.
+         */
+        this.uploadDataToOpenlayer = (data, config) => __awaiter(this, void 0, void 0, function* () {
             if (!this.openlayerApiKey || !this.openlayerProjectName) {
                 throw new Error('Openlayer API key and project name are required for publishing.');
             }
             try {
-                const projectsEndpoint = '/projects';
-                const projectsQueryParameters = {
-                    name: this.openlayerProjectName,
-                    version: this.version,
-                };
-                const projectsQuery = this.resolvedQuery(projectsEndpoint, projectsQueryParameters);
-                const projectsResponse = yield fetch(projectsQuery, {
-                    headers: {
-                        Authorization: `Bearer ${this.openlayerApiKey}`,
-                        'Content-Type': 'application/json',
-                    },
-                    method: 'GET',
-                });
-                const { items: projects } = yield projectsResponse.json();
-                if (!Array.isArray(projects)) {
-                    throw new Error('Invalid response from Openlayer');
-                }
-                const project = projects.find(({ name }) => name === this.openlayerProjectName);
-                if (!(project === null || project === void 0 ? void 0 : project.id)) {
-                    throw new Error('Project not found');
-                }
-                const inferencePipelineEndpoint = `/projects/${project.id}/inference-pipelines`;
-                const inferencePipelineQueryParameters = {
-                    name: this.openlayerInferencePipelineName,
-                    version: this.version,
-                };
-                const inferencePipelineQuery = this.resolvedQuery(inferencePipelineEndpoint, inferencePipelineQueryParameters);
-                const inferencePipelineResponse = yield fetch(inferencePipelineQuery, {
-                    headers: {
-                        Authorization: `Bearer ${this.openlayerApiKey}`,
-                        'Content-Type': 'application/json',
-                    },
-                    method: 'GET',
-                });
-                const { items: inferencePipelines } = yield inferencePipelineResponse.json();
-                const inferencePipeline = Array.isArray(inferencePipelines)
-                    ? inferencePipelines.find(({ name }) => typeof this.openlayerInferencePipelineName === 'undefined' ||
-                        name === this.openlayerInferencePipelineName)
-                    : undefined;
-                if (inferencePipeline === null || inferencePipeline === void 0 ? void 0 : inferencePipeline.id) {
-                    const { id: inferencePipelineId } = inferencePipeline;
-                    yield uploadToInferencePipeline(inferencePipelineId);
-                }
-                else {
-                    const createInferencePipelineEndpoint = `/projects/${project.id}/inference-pipelines`;
-                    const createInferencePipelineQuery = this.resolvedQuery(createInferencePipelineEndpoint, { version: this.version });
-                    const createInferencePipelineResponse = yield fetch(createInferencePipelineQuery, {
-                        body: JSON.stringify({
-                            description: '',
-                            name: typeof this.openlayerInferencePipelineName === 'undefined'
-                                ? 'production'
-                                : this.openlayerInferencePipelineName,
-                        }),
-                        headers: {
-                            Authorization: `Bearer ${this.openlayerApiKey}`,
-                            'Content-Type': 'application/json',
-                        },
-                        method: 'POST',
-                    });
-                    const { id: inferencePipelineId } = yield createInferencePipelineResponse.json();
-                    if (!inferencePipelineId) {
-                        throw new Error('Error creating inference pipeline');
-                    }
-                    yield uploadToInferencePipeline(inferencePipelineId);
-                }
+                const project = yield this.createProject(this.openlayerProjectName, 'llm-base');
+                const inferencePipeline = yield this.createInferencePipeline(this.openlayerProjectName, project.id);
+                yield this.uploadToInferencePipeline(inferencePipeline.id, data, config);
             }
             catch (error) {
                 console.error('Error publishing data to Openlayer:', error);
                 throw error;
             }
         });
+        /**
+         * Creates a new ChatCompletion instance. If monitoring is not active, an error is thrown.
+         * This function also measures latency and uploads data to Openlayer.
+         * @param body The parameters for creating a chat completion.
+         * @param options Optional request options.
+         * @throws Throws an error if monitoring is not active or if there is no output received from OpenAI.
+         * @returns A promise that resolves to a ChatCompletion or a Stream of ChatCompletionChunks.
+         */
         this.createChatCompletion = (body, options) => __awaiter(this, void 0, void 0, function* () {
-            var _a, e_1, _b, _c;
-            var _d, _e;
+            var _b, e_1, _c, _d;
+            var _e, _f;
             if (!this.monitoringOn) {
                 throw new Error('Monitoring is not active.');
             }
@@ -150,10 +106,10 @@ 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) {
-                        _c = streamedResponse_1_1.value;
-                        _f = false;
-                        const chunk = _c;
+                    for (var _g = true, streamedResponse_1 = __asyncValues(streamedResponse), streamedResponse_1_1; streamedResponse_1_1 = yield streamedResponse_1.next(), _b = streamedResponse_1_1.done, !_b; _g = true) {
+                        _d = streamedResponse_1_1.value;
+                        _g = false;
+                        const chunk = _d;
                         // Process each chunk - for example, accumulate input data
                         outputData += chunk.choices[0].delta.content;
                     }
@@ -161,7 +117,7 @@ class OpenAIMonitor {
                 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 (!_g && !_b && (_c = streamedResponse_1.return)) yield _c.call(streamedResponse_1);
                     }
                     finally { if (e_1) throw e_1.error; }
                 }
@@ -172,29 +128,44 @@ class OpenAIMonitor {
                     latency,
                     output: outputData,
                     timestamp: startTime,
-                });
+                }, this.openlayerDefaultDataConfig);
             }
             else {
                 const nonStreamedResponse = response;
                 // Handle regular (non-streamed) response
                 const endTime = Date.now();
                 const latency = endTime - startTime;
+                const output = nonStreamedResponse.choices[0].message.content;
+                if (typeof output !== 'string') {
+                    throw new Error('No output received from OpenAI.');
+                }
                 this.uploadDataToOpenlayer({
                     input: this.formatChatCompletionInput(body.messages),
                     latency,
-                    output: nonStreamedResponse.choices[0].message.content,
+                    output,
                     timestamp: startTime,
-                    tokens: (_e = (_d = nonStreamedResponse.usage) === null || _d === void 0 ? void 0 : _d.total_tokens) !== null && _e !== void 0 ? _e : 0,
-                });
+                    tokens: (_f = (_e = nonStreamedResponse.usage) === null || _e === void 0 ? void 0 : _e.total_tokens) !== null && _f !== void 0 ? _f : 0,
+                }, this.openlayerDefaultDataConfig);
             }
             return response;
         });
+        /**
+         * Creates a new Completion instance. If monitoring is not active, an error is thrown.
+         * This function also measures latency and uploads data to Openlayer.
+         * @param body The parameters for creating a completion.
+         * @param options Optional request options.
+         * @throws Throws an error if monitoring is not active or if no prompt is provided.
+         * @returns A promise that resolves to a Completion or a Stream of Completions.
+         */
         this.createCompletion = (body, options) => __awaiter(this, void 0, void 0, function* () {
-            var _g, e_2, _h, _j;
-            var _k, _l, _m, _o;
+            var _h, e_2, _j, _k;
+            var _l, _m, _o, _p;
             if (!this.monitoringOn) {
                 throw new Error('Monitoring is not active.');
             }
+            if (!body.prompt) {
+                throw new Error('No prompt provided.');
+            }
             // Start a timer to measure latency
             const startTime = Date.now();
             // Accumulate output and tokens data for streamed responses
@@ -204,19 +175,19 @@ class OpenAIMonitor {
             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 _q = true, streamedResponse_2 = __asyncValues(streamedResponse), streamedResponse_2_1; streamedResponse_2_1 = yield streamedResponse_2.next(), _h = streamedResponse_2_1.done, !_h; _q = true) {
+                        _k = streamedResponse_2_1.value;
+                        _q = false;
+                        const chunk = _k;
                         // 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;
+                        tokensData += (_m = (_l = chunk.usage) === null || _l === void 0 ? void 0 : _l.total_tokens) !== null && _m !== void 0 ? _m : 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 (!_q && !_h && (_j = streamedResponse_2.return)) yield _j.call(streamedResponse_2);
                     }
                     finally { if (e_2) throw e_2.error; }
                 }
@@ -228,7 +199,7 @@ class OpenAIMonitor {
                     output: outputData,
                     timestamp: startTime,
                     tokens: tokensData,
-                });
+                }, this.openlayerDefaultDataConfig);
             }
             else {
                 const nonStreamedResponse = response;
@@ -240,11 +211,137 @@ class OpenAIMonitor {
                     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,
-                });
+                    tokens: (_p = (_o = nonStreamedResponse.usage) === null || _o === void 0 ? void 0 : _o.total_tokens) !== null && _p !== void 0 ? _p : 0,
+                }, this.openlayerDefaultDataConfig);
             }
             return response;
         });
+        /**
+         * Creates a new inference pipeline in Openlayer, or loads an existing one if it already exists.
+         * @param name The name of the inference pipeline.
+         * @param projectId The project ID containing the inference pipeline.
+         * @throws Throws an error if the inference pipeline cannot be created or found.
+         * @returns A promise that resolves to an OpenlayerInferencePipeline object.
+         */
+        this.createInferencePipeline = (name, projectId) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.loadInferencePipeline(name, projectId);
+            }
+            catch (_r) {
+                const createInferencePipelineEndpoint = `/projects/${projectId}/inference-pipelines`;
+                const createInferencePipelineQuery = this.resolvedQuery(createInferencePipelineEndpoint, { version: this.version });
+                const createInferencePipelineResponse = yield fetch(createInferencePipelineQuery, {
+                    body: JSON.stringify({
+                        description: '',
+                        name: typeof this.openlayerInferencePipelineName === 'undefined'
+                            ? 'production'
+                            : this.openlayerInferencePipelineName,
+                    }),
+                    headers: {
+                        Authorization: `Bearer ${this.openlayerApiKey}`,
+                        'Content-Type': 'application/json',
+                    },
+                    method: 'POST',
+                });
+                const inferencePipeline = yield createInferencePipelineResponse.json();
+                if (!(inferencePipeline === null || inferencePipeline === void 0 ? void 0 : inferencePipeline.id)) {
+                    throw new Error('Error creating inference pipeline');
+                }
+                return inferencePipeline;
+            }
+        });
+        /**
+         * Creates a new project in Openlayer, or loads an existing one if it already exists.
+         * @param name The name of the project.
+         * @param taskType The type of task associated with the project.
+         * @param description Optional description of the project.
+         * @throws Throws an error if the project cannot be created or found.
+         * @returns A promise that resolves to an OpenlayerProject object.
+         */
+        this.createProject = (name, taskType, description) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.loadProject(name);
+            }
+            catch (_s) {
+                const projectsEndpoint = '/projects';
+                const projectsQuery = this.resolvedQuery(projectsEndpoint);
+                const projectsResponse = yield fetch(projectsQuery, {
+                    body: JSON.stringify({
+                        description,
+                        name,
+                        taskType,
+                    }),
+                    headers: {
+                        Authorization: `Bearer ${this.openlayerApiKey}`,
+                        'Content-Type': 'application/json',
+                    },
+                    method: 'POST',
+                });
+                const { items: projects } = yield projectsResponse.json();
+                if (!Array.isArray(projects)) {
+                    throw new Error('Invalid response from Openlayer');
+                }
+                const project = projects.find((p) => p.name === name);
+                if (!(project === null || project === void 0 ? void 0 : project.id)) {
+                    throw new Error('Project not found');
+                }
+                return project;
+            }
+        });
+        /**
+         * Loads an existing inference pipeline from Openlayer based on its name and project ID.
+         * @param name The name of the inference pipeline.
+         * @param projectId The project ID containing the inference pipeline.
+         * @throws Throws an error if the inference pipeline is not found.
+         * @returns A promise that resolves to an OpenlayerInferencePipeline object.
+         */
+        this.loadInferencePipeline = (name, projectId) => __awaiter(this, void 0, void 0, function* () {
+            const inferencePipelineEndpoint = `/projects/${projectId}/inference-pipelines`;
+            const inferencePipelineQueryParameters = {
+                name: this.openlayerInferencePipelineName,
+                version: this.version,
+            };
+            const inferencePipelineQuery = this.resolvedQuery(inferencePipelineEndpoint, inferencePipelineQueryParameters);
+            const inferencePipelineResponse = yield fetch(inferencePipelineQuery, {
+                headers: {
+                    Authorization: `Bearer ${this.openlayerApiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                method: 'GET',
+            });
+            const { items: inferencePipelines } = yield inferencePipelineResponse.json();
+            const inferencePipeline = Array.isArray(inferencePipelines)
+                ? inferencePipelines.find((p) => p.name === name)
+                : undefined;
+            if (!(inferencePipeline === null || inferencePipeline === void 0 ? void 0 : inferencePipeline.id)) {
+                throw new Error('Inference pipeline not found');
+            }
+            return inferencePipeline;
+        });
+        this.loadProject = (name) => __awaiter(this, void 0, void 0, function* () {
+            const projectsEndpoint = '/projects';
+            const projectsQueryParameters = {
+                name,
+                version: this.version,
+            };
+            const projectsQuery = this.resolvedQuery(projectsEndpoint, projectsQueryParameters);
+            const projectsResponse = yield fetch(projectsQuery, {
+                headers: {
+                    Authorization: `Bearer ${this.openlayerApiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                method: 'GET',
+            });
+            const { items: projects } = yield projectsResponse.json();
+            if (!Array.isArray(projects)) {
+                throw new Error('Invalid response from Openlayer');
+            }
+            const project = projects.find((p) => p.name === name);
+            if (!(project === null || project === void 0 ? void 0 : project.id)) {
+                throw new Error('Project not found');
+            }
+            return project;
+        });
         this.OpenAIClient = new openai_1.default({
             apiKey: openAiApiKey,
             dangerouslyAllowBrowser: true,
@@ -259,6 +356,9 @@ class OpenAIMonitor {
             throw new Error('Openlayer API key and project name are required for publishing.');
         }
     }
+    /**
+     * Starts monitoring for the OpenAI Monitor instance. If monitoring is already active, a warning is logged.
+     */
     startMonitoring() {
         if (this.monitoringOn) {
             console.warn('Monitoring is already on!');
@@ -267,6 +367,9 @@ class OpenAIMonitor {
         this.monitoringOn = true;
         console.info('Monitoring started.');
     }
+    /**
+     * Stops monitoring for the OpenAI Monitor instance. If monitoring is not active, a warning is logged.
+     */
     stopMonitoring() {
         if (!this.monitoringOn) {
             console.warn('Monitoring is not active.');

package/package.json

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