openlayer 0.0.1 → 0.0.2

package/.eslintrc.json

@@ -1,6 +1,5 @@
 {
   "extends": [
-    "next/core-web-vitals",
     "plugin:typescript-sort-keys/recommended",
     "plugin:prettier/recommended"
   ],
@@ -22,7 +21,6 @@
     "multiline-comment-style": ["error", "starred-block"],
     "new-cap": "error",
     "no-alert": "error",
-    "no-console": "error",
     "no-duplicate-imports": "error",
     "no-else-return": "error",
     "no-empty-function": "error",
@@ -121,56 +119,6 @@
     "switch-colon-spacing": "error",
     "template-curly-spacing": "error",
     "template-tag-spacing": "error",
-    "yield-star-spacing": "error",
-
-    // React
-    "react/boolean-prop-naming": "error",
-    "react/button-has-type": "error",
-    "react/destructuring-assignment": "error",
-    // FIXME: This fails to load
-    // "react/hook-use-state": "error",
-    "react/no-array-index-key": "error",
-    "react/no-arrow-function-lifecycle": "error",
-    "react/no-danger": "error",
-    "react/no-invalid-html-attribute": "error",
-    "react/no-multi-comp": "warn",
-    "react/no-this-in-sfc": "error",
-    "react/no-typos": "warn",
-    "react/no-unsafe": "error",
-    "react/no-unstable-nested-components": "warn",
-    "react/no-unused-class-component-methods": "error",
-    "react/no-unused-prop-types": "error",
-    "react/no-unused-state": "error",
-    "react/prefer-es6-class": "error",
-    "react/prefer-stateless-function": "error",
-    "react/self-closing-comp": "error",
-    "react/sort-comp": "error",
-    "react/sort-prop-types": "error",
-    "react/static-property-placement": "error",
-    "react/style-prop-object": "error",
-    "react/void-dom-elements-no-children": "error",
-
-    // JSX
-    "react/jsx-boolean-value": "error",
-    "react/jsx-child-element-spacing": "error",
-    "react/jsx-closing-tag-location": "error",
-    "react/jsx-curly-brace-presence": "error",
-    "react/jsx-curly-spacing": "error",
-    "react/jsx-equals-spacing": "error",
-    "react/jsx-filename-extension": [
-      2,
-      { "extensions": [".js", ".jsx", ".ts", ".tsx"] }
-    ],
-    "react/jsx-first-prop-new-line": "error",
-    "react/jsx-handler-names": "error",
-    // "react/jsx-indent": ["error", 2, { "checkAttributes": true }],
-    // "react/jsx-indent-props": ["error", 2],
-    "react/jsx-newline": "warn",
-    "react/jsx-pascal-case": "error",
-    "react/jsx-props-no-multi-spaces": "error",
-    "react/jsx-sort-default-props": "error",
-    "react/jsx-sort-props": "error",
-    "react/jsx-tag-spacing": ["error", { "beforeSelfClosing": "always" }],
-    "react/jsx-wrap-multilines": "error"
+    "yield-star-spacing": "error"
   }
 }

package/dist/index.d.ts

@@ -1,16 +1,24 @@
 import { RequestOptions } from 'openai/core';
 import { ChatCompletion, ChatCompletionChunk, ChatCompletionCreateParams, Completion, CompletionCreateParams } from 'openai/resources';
 import { Stream } from 'openai/streaming';
+type ConstructorProps = {
+    openAiApiKey: string;
+    openlayerApiKey?: string;
+    openlayerInferencePipelineName?: string;
+    openlayerProjectName?: string;
+    openlayerServerUrl?: string;
+};
 declare class OpenAIMonitor {
+    private OpenAIClient;
+    private monitoringOn;
     private openlayerApiKey?;
     private openlayerProjectName?;
     private openlayerInferencePipelineName?;
     private openlayerServerUrl;
-    private OpenAIClient;
-    private monitoringOn;
     private version;
-    constructor(openAiApiKey: string, openlayerApiKey?: string | undefined, openlayerProjectName?: string | undefined, openlayerInferencePipelineName?: string | undefined, openlayerServerUrl?: string);
+    constructor({ openAiApiKey, openlayerApiKey, openlayerInferencePipelineName, openlayerProjectName, openlayerServerUrl, }: ConstructorProps);
     private formatChatCompletionInput;
+    private resolvedQuery;
     private uploadDataToOpenlayer;
     startMonitoring(): void;
     stopMonitoring(): void;

package/dist/index.js

@@ -28,39 +28,41 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const openai_1 = require("openai");
+const request_1 = require("./utils/request");
 class OpenAIMonitor {
-    constructor(openAiApiKey, openlayerApiKey, openlayerProjectName, openlayerInferencePipelineName, openlayerServerUrl = 'https://api.openlayer.com/v1') {
-        this.openlayerApiKey = openlayerApiKey;
-        this.openlayerProjectName = openlayerProjectName;
-        this.openlayerInferencePipelineName = openlayerInferencePipelineName;
-        this.openlayerServerUrl = openlayerServerUrl;
+    constructor({ openAiApiKey, openlayerApiKey, openlayerInferencePipelineName, openlayerProjectName, openlayerServerUrl, }) {
         this.monitoringOn = false;
+        this.openlayerServerUrl = 'https://api.openlayer.com/v1';
         this.version = '0.1.0a16';
         this.formatChatCompletionInput = (messages) => messages
             .filter(({ role }) => role === 'user')
             .map(({ content }) => content)
             .join('\n')
             .trim();
+        this.resolvedQuery = (endpoint, args = {}) => (0, request_1.resolvedQuery)(this.openlayerServerUrl, endpoint, Object.assign({ version: this.version }, 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?version=${this.version}`;
-                const dataStreamUrl = `${this.openlayerServerUrl}${dataStreamEndpoint}`;
-                console.log('boy', dataStreamUrl, JSON.stringify({
-                    dataset: [data],
-                    datasetConfig: {},
-                }));
-                const response = yield fetch(dataStreamUrl, {
-                    method: 'POST',
+                const dataStreamEndpoint = `/inference-pipelines/${id}/data-stream`;
+                const dataStreamQuery = this.resolvedQuery(dataStreamEndpoint);
+                const response = yield fetch(dataStreamQuery, {
+                    body: JSON.stringify({
+                        config: {
+                            inferenceIdColumnName: 'inference_id',
+                            inputVariableNames: ['input'],
+                            latencyColumnName: 'latency',
+                            outputColumnName: 'output',
+                            timestampColumnName: 'timestamp',
+                            tokensColumnName: 'tokens',
+                        },
+                        rows: [data],
+                    }),
                     headers: {
-                        'Content-Type': 'application/json',
                         Authorization: `Bearer ${this.openlayerApiKey}`,
+                        'Content-Type': 'application/json',
                     },
-                    body: JSON.stringify({
-                        dataset: [data],
-                        datasetConfig: {},
-                    }),
+                    method: 'POST',
                 });
-                console.log('uhh', response);
+                console.log('bruh', response, dataStreamQuery);
                 if (!response.ok) {
                     console.error('Error making POST request:', response.status);
                     throw new Error(`Error: ${response.status}`);
@@ -71,16 +73,19 @@ class OpenAIMonitor {
                 throw new Error('Openlayer API key and project name are required for publishing.');
             }
             try {
-                const projectsEndpoint = `/projects?perPage=100&name=${this.openlayerProjectName}&version=${this.version}`;
-                const projectsUrl = `${this.openlayerServerUrl}${projectsEndpoint}`;
-                const projectsResponse = yield fetch(projectsUrl, {
-                    method: 'GET',
+                const projectsEndpoint = '/projects';
+                const projectsQueryParameters = {
+                    name: this.openlayerProjectName,
+                };
+                const projectsQuery = this.resolvedQuery(projectsEndpoint, projectsQueryParameters);
+                const projectsResponse = yield fetch(projectsQuery, {
                     headers: {
-                        'Content-Type': 'application/json',
                         Authorization: `Bearer ${this.openlayerApiKey}`,
+                        'Content-Type': 'application/json',
                     },
+                    method: 'GET',
                 });
-                const _a = yield projectsResponse.json(), { items: projects } = _a, data = __rest(_a, ["items"]);
+                const { items: projects } = yield projectsResponse.json();
                 if (!Array.isArray(projects)) {
                     throw new Error('Invalid response from Openlayer');
                 }
@@ -88,46 +93,50 @@ class OpenAIMonitor {
                 if (!(project === null || project === void 0 ? void 0 : project.id)) {
                     throw new Error('Project not found');
                 }
-                const inferencePipelineEndpoint = `/projects/${project.id}/inference-pipelines?perPage=100&name=${this.openlayerInferencePipelineName}&version=${this.version}`;
-                const inferencePipelineUrl = `${this.openlayerServerUrl}${inferencePipelineEndpoint}`;
-                const inferencePipelineResponse = yield fetch(inferencePipelineUrl, {
-                    method: 'GET',
+                const inferencePipelineEndpoint = `/projects/${project.id}/inference-pipelines`;
+                const inferencePipelineQueryParameters = {
+                    name: this.openlayerInferencePipelineName,
+                };
+                const inferencePipelineQuery = this.resolvedQuery(inferencePipelineEndpoint, inferencePipelineQueryParameters);
+                const inferencePipelineResponse = yield fetch(inferencePipelineQuery, {
                     headers: {
-                        'Content-Type': 'application/json',
                         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 createInferencePipelineEndpoint = `/projects/${project.id}/inference-pipelines?version=${this.version}`;
-                    const createInferencePipelineUrl = `${this.openlayerServerUrl}${createInferencePipelineEndpoint}`;
-                    const createInferencePipelineResponse = yield fetch(createInferencePipelineUrl, {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            Authorization: `Bearer ${this.openlayerApiKey}`,
-                        },
+                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);
+                    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 _b = yield createInferencePipelineResponse.json(), { id: inferencePipelineId } = _b, response = __rest(_b, ["id"]);
+                    const _a = yield createInferencePipelineResponse.json(), { id: inferencePipelineId } = _a, response = __rest(_a, ["id"]);
+                    console.log(createInferencePipelineResponse, response, inferencePipelineId);
                     if (!inferencePipelineId) {
                         throw new Error('Error creating inference pipeline');
                     }
                     yield uploadToInferencePipeline(inferencePipelineId);
                 }
-                else {
-                    const { id: inferencePipelineId } = inferencePipeline;
-                    yield uploadToInferencePipeline(inferencePipelineId);
-                }
             }
             catch (error) {
                 console.error('Error publishing data to Openlayer:', error);
@@ -135,8 +144,8 @@ class OpenAIMonitor {
             }
         });
         this.createChatCompletion = (body, options) => __awaiter(this, void 0, void 0, function* () {
-            var _c, e_1, _d, _e;
-            var _f, _g;
+            var _b, e_1, _c, _d;
+            var _e, _f;
             if (!this.monitoringOn) {
                 throw new Error('Monitoring is not active.');
             }
@@ -148,10 +157,10 @@ class OpenAIMonitor {
             if (body.stream) {
                 const streamedResponse = response;
                 try {
-                    for (var _h = true, streamedResponse_1 = __asyncValues(streamedResponse), streamedResponse_1_1; streamedResponse_1_1 = yield streamedResponse_1.next(), _c = streamedResponse_1_1.done, !_c; _h = true) {
-                        _e = streamedResponse_1_1.value;
-                        _h = false;
-                        const chunk = _e;
+                    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;
                     }
@@ -159,7 +168,7 @@ class OpenAIMonitor {
                 catch (e_1_1) { e_1 = { error: e_1_1 }; }
                 finally {
                     try {
-                        if (!_h && !_c && (_d = streamedResponse_1.return)) yield _d.call(streamedResponse_1);
+                        if (!_g && !_b && (_c = streamedResponse_1.return)) yield _c.call(streamedResponse_1);
                     }
                     finally { if (e_1) throw e_1.error; }
                 }
@@ -167,7 +176,7 @@ class OpenAIMonitor {
                 const latency = endTime - startTime;
                 this.uploadDataToOpenlayer({
                     input: this.formatChatCompletionInput(body.messages),
-                    latency: latency,
+                    latency,
                     output: outputData,
                 });
             }
@@ -178,16 +187,16 @@ class OpenAIMonitor {
                 const latency = endTime - startTime;
                 this.uploadDataToOpenlayer({
                     input: this.formatChatCompletionInput(body.messages),
+                    latency,
                     output: nonStreamedResponse.choices[0].message.content,
-                    latency: latency,
-                    tokens: (_g = (_f = nonStreamedResponse.usage) === null || _f === void 0 ? void 0 : _f.total_tokens) !== null && _g !== void 0 ? _g : 0,
+                    tokens: (_f = (_e = nonStreamedResponse.usage) === null || _e === void 0 ? void 0 : _e.total_tokens) !== null && _f !== void 0 ? _f : 0,
                 });
             }
             return response;
         });
         this.createCompletion = (body, options) => __awaiter(this, void 0, void 0, function* () {
-            var _j, e_2, _k, _l;
-            var _m, _o, _p, _q;
+            var _h, e_2, _j, _k;
+            var _l, _m, _o, _p;
             if (!this.monitoringOn) {
                 throw new Error('Monitoring is not active.');
             }
@@ -200,19 +209,19 @@ class OpenAIMonitor {
             if (body.stream) {
                 const streamedResponse = response;
                 try {
-                    for (var _r = true, streamedResponse_2 = __asyncValues(streamedResponse), streamedResponse_2_1; streamedResponse_2_1 = yield streamedResponse_2.next(), _j = streamedResponse_2_1.done, !_j; _r = true) {
-                        _l = streamedResponse_2_1.value;
-                        _r = false;
-                        const chunk = _l;
+                    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 += (_o = (_m = chunk.usage) === null || _m === void 0 ? void 0 : _m.total_tokens) !== null && _o !== void 0 ? _o : 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 (!_r && !_j && (_k = streamedResponse_2.return)) yield _k.call(streamedResponse_2);
+                        if (!_q && !_h && (_j = streamedResponse_2.return)) yield _j.call(streamedResponse_2);
                     }
                     finally { if (e_2) throw e_2.error; }
                 }
@@ -220,7 +229,7 @@ class OpenAIMonitor {
                 const latency = endTime - startTime;
                 this.uploadDataToOpenlayer({
                     input: body.prompt,
-                    latency: latency,
+                    latency,
                     output: outputData,
                     tokens: tokensData,
                 });
@@ -232,17 +241,20 @@ class OpenAIMonitor {
                 const latency = endTime - startTime;
                 this.uploadDataToOpenlayer({
                     input: body.prompt,
+                    latency,
                     output: nonStreamedResponse.choices[0].text,
-                    latency: latency,
-                    tokens: (_q = (_p = nonStreamedResponse.usage) === null || _p === void 0 ? void 0 : _p.total_tokens) !== null && _q !== void 0 ? _q : 0,
+                    tokens: (_p = (_o = nonStreamedResponse.usage) === null || _o === void 0 ? void 0 : _o.total_tokens) !== null && _p !== void 0 ? _p : 0,
                 });
             }
             return response;
         });
         this.OpenAIClient = new openai_1.default({ apiKey: openAiApiKey });
         this.openlayerApiKey = openlayerApiKey;
+        this.openlayerInferencePipelineName = openlayerInferencePipelineName;
         this.openlayerProjectName = openlayerProjectName;
-        this.openlayerServerUrl = this.openlayerServerUrl;
+        if (openlayerServerUrl) {
+            this.openlayerServerUrl = openlayerServerUrl;
+        }
         if (!this.openlayerApiKey || !this.openlayerProjectName) {
             throw new Error('Openlayer API key and project name are required for publishing.');
         }
@@ -264,20 +276,4 @@ class OpenAIMonitor {
         console.info('Monitoring stopped.');
     }
 }
-// Usage Example
-(() => __awaiter(void 0, void 0, void 0, function* () {
-    const monitor = new OpenAIMonitor('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', 'UyKge0qbzrnAg_vehsTtw_e_mArrHHyT', 'aoeuaoeuaoeu', 'production', 'http://127.0.0.1:8080/v1');
-    monitor.startMonitoring();
-    const chatCompletion = yield monitor.createChatCompletion({
-        messages: [{ role: 'user', content: 'Say this is a test' }],
-        model: 'gpt-3.5-turbo',
-    });
-    const completion = yield monitor.createCompletion({
-        model: 'gpt-3.5-turbo-instruct',
-        prompt: 'Say this is a test',
-    });
-    console.log('Client chat completion:', chatCompletion);
-    console.log('Client completion:', completion);
-    monitor.stopMonitoring();
-}))();
 exports.default = OpenAIMonitor;

package/dist/utils/request.d.ts

@@ -0,0 +1,5 @@
+export type RequestParameters = {
+    [key: string]: any;
+};
+export declare const resolvedQuery: (baseUrl: string, endpoint: string, args?: RequestParameters) => string;
+export declare const queryParameters: (args: RequestParameters) => string;

package/dist/utils/request.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryParameters = exports.resolvedQuery = void 0;
+const resolvedQuery = (baseUrl, endpoint, args = {}) => `${baseUrl}${endpoint}${(0, exports.queryParameters)(args)}`;
+exports.resolvedQuery = resolvedQuery;
+const queryParameters = (args) => {
+    const filteredArgs = Object.keys(args)
+        .filter((key) => typeof args[key] !== 'undefined')
+        .reduce((acc, arg) => {
+        if (Array.isArray(args[arg])) {
+            if (args[arg].length === 0) {
+                return acc;
+            }
+            acc[arg] = args[arg].join(`&${arg}=`);
+        }
+        else {
+            if ((typeof args[arg] === 'string' && args[arg].length === 0) ||
+                (typeof args[arg] === 'object' &&
+                    Object.values(args[arg]).length === 0)) {
+                return acc;
+            }
+            acc[arg] = args[arg];
+        }
+        return acc;
+    }, {});
+    if (Object.keys(filteredArgs).length === 0) {
+        return '';
+    }
+    const resolvedArgs = Object.keys(filteredArgs)
+        .map((key) => `${key}=${filteredArgs[key]}`)
+        .join('&');
+    return `?${resolvedArgs}`;
+};
+exports.queryParameters = queryParameters;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openlayer",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "The Openlayer TypeScript client",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +16,7 @@
     "@typescript-eslint/parser": "^6.11.0",
     "eslint": "^8.54.0",
     "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-prettier": "^5.0.1",
     "eslint-plugin-typescript-sort-keys": "^3.1.0",
     "openai": "^4.19.0"
   },