openlayer 0.1.34 → 0.1.35

package/README.md

@@ -1,5 +1,5 @@
 <div align="left">
-  <img src="static/logo.png"><br>
+  <img src="static/logo-purple-text.svg"><br>
 </div>
 
 # Openlayer | JavaScript/TypeScript Library

package/dist/cli/cliHandler.d.ts

@@ -0,0 +1,6 @@
+export declare class CLIHandler {
+    private run;
+    constructor(runFunction: (...args: any[]) => Promise<any>);
+    runFromCLI(): void;
+    private writeOutput;
+}

package/dist/cli/cliHandler.js

@@ -0,0 +1,76 @@
+"use strict";
+/*
+ * Description: This file contains the CLIHandler class which is responsible
+ * For handling the CLI input and output.
+ *
+ * Example Usage:
+ * // Initialize CLI handler with the user's model run method
+ * const cliHandler = new CLIHandler(model.run.bind(model));
+ *
+ * // Setup CLI and process dataset
+ * cliHandler.runFromCLI();
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIHandler = void 0;
+const commander_1 = require("commander");
+const fs = require("fs");
+const path = require("path");
+class CLIHandler {
+    constructor(runFunction) {
+        this.run = runFunction;
+    }
+    runFromCLI() {
+        commander_1.program
+            .requiredOption('--dataset-path <path>', 'Path to the dataset')
+            .requiredOption('--output-dir <path>', 'Directory to place results');
+        commander_1.program.parse(process.argv);
+        const options = commander_1.program.opts();
+        const { datasetPath, outputDir } = options;
+        // Load dataset
+        const datasetFullPath = path.resolve(datasetPath);
+        const rawData = fs.readFileSync(datasetFullPath, 'utf8');
+        const dataset = JSON.parse(rawData);
+        // Process each item in the dataset dynamically
+        Promise.all(dataset.map((item) => __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.run(item);
+            // Merge the original item fields with the result
+            return Object.assign(Object.assign(Object.assign({}, item), result.otherFields), { output: result.output });
+        })))
+            .then((results) => {
+            /*
+             * Wait for all rows to be run
+             * Write results now to output dir or log to console
+             */
+            this.writeOutput(results, outputDir);
+            console.log('Results processing completed. Check console for output.');
+        })
+            .catch((err) => {
+            console.error(`Error processing dataset: ${err}`);
+        });
+    }
+    writeOutput(results, outputDir) {
+        const config = {
+            metadata: { outputTimestamp: Date.now() },
+            outputColumnName: 'output',
+        };
+        // Construct an output directory {outputDir}/{datasetName}/
+        const outputDirPath = path.resolve(outputDir);
+        fs.mkdirSync(outputDirPath, { recursive: true });
+        const datasetPath = path.join(outputDirPath, 'dataset.json');
+        const configPath = path.join(outputDirPath, 'config.json');
+        fs.writeFileSync(datasetPath, JSON.stringify(results, null, 4), 'utf8');
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 4), 'utf8');
+        console.log(`Output written to ${datasetPath}`);
+        console.log(`Config written to ${configPath}`);
+    }
+}
+exports.CLIHandler = CLIHandler;

package/dist/examples/openai_dev_mode.d.ts

@@ -0,0 +1,10 @@
+import { RunReturn } from 'openlayer/lib/utils/run';
+export declare class MyModel {
+    private monitor;
+    private openaiApiKey;
+    private openlayerApiKey;
+    constructor();
+    run({ userQuery }: {
+        userQuery: string;
+    }): Promise<RunReturn>;
+}

package/dist/examples/openai_dev_mode.js

@@ -0,0 +1,55 @@
+"use strict";
+/*
+ * This shows how to use the OpenAI monitor with Openlayer to create a CLI handler
+ * for processing datasets. The script can be called with the following command:
+ * node dist/run.js --dataset-path {{ path }} --dataset-name {{ name }}
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MyModel = void 0;
+const openlayer_1 = require("openlayer");
+const cliHandler_1 = require("openlayer/cli/cliHandler");
+class MyModel {
+    constructor() {
+        this.openaiApiKey = process.env.OPENAI_API_KEY || '';
+        this.openlayerApiKey = process.env.OPENLAYER_API_KEY || '';
+        const openlayerProjectName = process.env.OPENLAYER_PROJECT_NAME || '';
+        this.monitor = new openlayer_1.OpenAIMonitor({
+            openAiApiKey: this.openaiApiKey,
+            openlayerApiKey: this.openlayerApiKey,
+            openlayerProjectName,
+        });
+    }
+    run({ userQuery }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Implement the model run logic here
+            const model = 'gpt-3.5-turbo';
+            const response = yield this.monitor.createChatCompletion({
+                messages: [
+                    {
+                        content: userQuery,
+                        role: 'user',
+                    },
+                ],
+                model,
+            }, undefined);
+            const result = response.choices[0].message.content;
+            return { otherFields: { model }, output: result };
+        });
+    }
+}
+exports.MyModel = MyModel;
+// User implements their model
+const model = new MyModel();
+// Initialize CLI handler with the user's model run method
+const cliHandler = new cliHandler_1.CLIHandler(model.run.bind(model));
+// Setup CLI and process dataset
+cliHandler.runFromCLI();

package/dist/lib/cli/cliHandler.d.ts

@@ -0,0 +1,6 @@
+export declare class CLIHandler {
+    private run;
+    constructor(runFunction: (...args: any[]) => Promise<any>);
+    runFromCLI(): void;
+    private writeOutput;
+}

package/dist/lib/cli/cliHandler.js

@@ -0,0 +1,76 @@
+"use strict";
+/*
+ * Description: This file contains the CLIHandler class which is responsible
+ * For handling the CLI input and output.
+ *
+ * Example Usage:
+ * // Initialize CLI handler with the user's model run method
+ * const cliHandler = new CLIHandler(model.run.bind(model));
+ *
+ * // Setup CLI and process dataset
+ * cliHandler.runFromCLI();
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIHandler = void 0;
+const commander_1 = require("commander");
+const fs = require("fs");
+const path = require("path");
+class CLIHandler {
+    constructor(runFunction) {
+        this.run = runFunction;
+    }
+    runFromCLI() {
+        commander_1.program
+            .requiredOption('--dataset-path <path>', 'Path to the dataset')
+            .requiredOption('--output-dir <path>', 'Directory to place results');
+        commander_1.program.parse(process.argv);
+        const options = commander_1.program.opts();
+        const { datasetPath, outputDir } = options;
+        // Load dataset
+        const datasetFullPath = path.resolve(datasetPath);
+        const rawData = fs.readFileSync(datasetFullPath, 'utf8');
+        const dataset = JSON.parse(rawData);
+        // Process each item in the dataset dynamically
+        Promise.all(dataset.map((item) => __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.run(item);
+            // Merge the original item fields with the result
+            return Object.assign(Object.assign(Object.assign({}, item), result.otherFields), { output: result.output });
+        })))
+            .then((results) => {
+            /*
+             * Wait for all rows to be run
+             * Write results now to output dir or log to console
+             */
+            this.writeOutput(results, outputDir);
+            console.log('Results processing completed. Check console for output.');
+        })
+            .catch((err) => {
+            console.error(`Error processing dataset: ${err}`);
+        });
+    }
+    writeOutput(results, outputDir) {
+        const config = {
+            metadata: { outputTimestamp: Date.now() },
+            outputColumnName: 'output',
+        };
+        // Construct an output directory {outputDir}/{datasetName}/
+        const outputDirPath = path.resolve(outputDir);
+        fs.mkdirSync(outputDirPath, { recursive: true });
+        const datasetPath = path.join(outputDirPath, 'dataset.json');
+        const configPath = path.join(outputDirPath, 'config.json');
+        fs.writeFileSync(datasetPath, JSON.stringify(results, null, 4), 'utf8');
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 4), 'utf8');
+        console.log(`Output written to ${datasetPath}`);
+        console.log(`Config written to ${configPath}`);
+    }
+}
+exports.CLIHandler = CLIHandler;

package/dist/lib/index.d.ts

@@ -0,0 +1,236 @@
+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.
+ * Object keys represent a column name and the values represent the column value.
+ */
+export interface StreamingData {
+    [columnName: string]: any;
+    /**
+     * The total estimated cost of the chat completion in USD. Optional.
+     */
+    cost?: 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.
+ */
+interface StreamingDataConfig {
+    /**
+     * The name of the column that stores the request cost data. Can be null.
+     */
+    costColumnName: string | null;
+    /**
+     * 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 full prompt history for the chat completion.
+     */
+    prompt?: ChatCompletionMessageParam[];
+    /**
+     * The name of the column that stores timestamp data. Can be null.
+     */
+    timestampColumnName: string | null;
+}
+type OpenlayerClientConstructorProps = {
+    openlayerApiKey?: string;
+    openlayerServerUrl?: string;
+};
+type OpenAIMonitorConstructorProps = OpenlayerClientConstructorProps & {
+    openAiApiKey: string;
+    openlayerInferencePipelineId?: string;
+    openlayerInferencePipelineName?: string;
+    openlayerProjectName?: 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';
+export declare class OpenlayerClient {
+    private openlayerApiKey?;
+    defaultConfig: StreamingDataConfig;
+    private openlayerServerUrl;
+    private version;
+    /**
+     * Constructs an OpenlayerClient instance.
+     * @param {OpenlayerClientConstructorProps} props - The config for the Openlayer client. The API key is required.
+     */
+    constructor({ openlayerApiKey, openlayerServerUrl, }: OpenlayerClientConstructorProps);
+    private resolvedQuery;
+    /**
+     * Creates a new inference pipeline in Openlayer or loads an existing one.
+     * @param {string} projectId - The ID of the project containing the inference pipeline.
+     * @param {string} [name='production'] - The name of the inference pipeline, defaults to 'production'.
+     * @returns {Promise<OpenlayerInferencePipeline>} A promise that resolves to an OpenlayerInferencePipeline object.
+     * @throws {Error} Throws an error if the inference pipeline cannot be created or found.
+     */
+    createInferencePipeline: (projectId: string, name?: string) => Promise<OpenlayerInferencePipeline>;
+    /**
+     * Creates a new project in Openlayer or loads an existing one.
+     * @param {string} name - The name of the project.
+     * @param {OpenlayerTaskType} taskType - The type of task associated with the project.
+     * @param {string} [description] - Optional description of the project.
+     * @returns {Promise<OpenlayerProject>} A promise that resolves to an OpenlayerProject object.
+     * @throws {Error} Throws an error if the project cannot be created or found.
+     */
+    createProject: (name: string, taskType: OpenlayerTaskType, description?: string) => Promise<OpenlayerProject>;
+    /**
+     * Loads an existing inference pipeline from Openlayer based on its name and project ID.
+     * @param {string} projectId - The ID of the project containing the inference pipeline.
+     * @param {string} [name='production'] - The name of the inference pipeline, defaults to 'production'.
+     * @returns {Promise<OpenlayerInferencePipeline>} A promise that resolves to an OpenlayerInferencePipeline object.
+     * @throws {Error} Throws an error if the inference pipeline is not found.
+     */
+    loadInferencePipeline: (projectId: string, name?: string) => Promise<OpenlayerInferencePipeline>;
+    /**
+     * Loads an existing project from Openlayer based on its name.
+     * @param {string} name - The name of the project.
+     * @returns {Promise<OpenlayerProject>} A promise that resolves to an OpenlayerProject object.
+     * @throws {Error} Throws an error if the project is not found.
+     */
+    loadProject: (name: string) => Promise<OpenlayerProject>;
+    /**
+     * Streams data to the Openlayer inference pipeline.
+     * @param {StreamingData} data - The chat completion data to be streamed.
+     * @param {string} inferencePipelineId - The ID of the Openlayer inference pipeline to which data is streamed.
+     * @returns {Promise<void>} A promise that resolves when the data has been successfully streamed.
+     */
+    streamData: (data: StreamingData, config: StreamingDataConfig, inferencePipelineId: string) => Promise<void>;
+}
+export declare class OpenAIMonitor {
+    private openlayerClient;
+    private openAIClient;
+    private openlayerProjectName?;
+    private openlayerInferencePipelineId?;
+    private openlayerInferencePipelineName;
+    /**
+     * Constructs an OpenAIMonitor instance.
+     * @param {OpenAIMonitorConstructorProps} props - The configuration properties for the OpenAI and Openlayer clients.
+     */
+    constructor({ openAiApiKey, openlayerApiKey, openlayerProjectName, openlayerInferencePipelineId, openlayerInferencePipelineName, openlayerServerUrl, }: OpenAIMonitorConstructorProps);
+    private cost;
+    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.
+     */
+    createChatCompletion: (body: ChatCompletionCreateParams, options?: RequestOptions, additionalLogs?: StreamingData) => Promise<ChatCompletion | Stream<ChatCompletionChunk>>;
+    /**
+     * Creates a completion using the OpenAI client and streams the result to Openlayer.
+     * @param {CompletionCreateParams} body - The parameters for creating a completion.
+     * @param {RequestOptions} [options] - Optional request options.
+     * @param {StreamingData} [additionalLogs] - Optional metadata logs to include with the request sent to Openlayer.
+     * @returns {Promise<Completion | Stream<Completion>>} Promise that resolves to a Completion or a Stream.
+     * @throws {Error} Throws errors from the OpenAI client.
+     */
+    createCompletion: (body: CompletionCreateParams, options?: RequestOptions, additionalLogs?: StreamingData) => Promise<Completion | Stream<Completion>>;
+    /**
+     * Monitor a run from an OpenAI assistant.
+     * Once the run is completed, the thread data is published to Openlayer,
+     * along with the latency, cost, and number of tokens used.
+     * @param {Run} run - The run created by the OpenAI assistant.
+     * @param {StreamingData} [additionalLogs] - Optional metadata logs to include with the request sent to Openlayer.
+     * @returns {Promise<void>} A promise that resolves when the run data has been successfully published to Openlayer.
+     */
+    monitorThreadRun(run: Run, additionalLogs?: StreamingData): Promise<void>;
+    /**
+     * Starts monitoring for the OpenAI Monitor instance. If monitoring is already active, a warning is logged.
+     */
+    initialize(): Promise<void>;
+}
+export {};

package/dist/lib/index.js

@@ -0,0 +1,608 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIMonitor = exports.OpenlayerClient = void 0;
+const node_fetch_1 = require("node-fetch");
+const openai_1 = require("openai");
+const uuid_1 = require("uuid");
+const request_1 = require("./utils/request");
+const OpenAIPricing = {
+    'babbage-002': {
+        input: 0.0004,
+        output: 0.0004,
+    },
+    'davinci-002': {
+        input: 0.002,
+        output: 0.002,
+    },
+    'gpt-3.5-turbo': {
+        input: 0.0005,
+        output: 0.0015,
+    },
+    'gpt-3.5-turbo-0125': {
+        input: 0.0005,
+        output: 0.0015,
+    },
+    'gpt-3.5-turbo-0301': {
+        input: 0.0015,
+        output: 0.002,
+    },
+    'gpt-3.5-turbo-0613': {
+        input: 0.0015,
+        output: 0.002,
+    },
+    'gpt-3.5-turbo-1106': {
+        input: 0.001,
+        output: 0.002,
+    },
+    'gpt-3.5-turbo-16k-0613': {
+        input: 0.003,
+        output: 0.004,
+    },
+    'gpt-3.5-turbo-instruct': {
+        input: 0.0015,
+        output: 0.002,
+    },
+    'gpt-4': {
+        input: 0.03,
+        output: 0.06,
+    },
+    'gpt-4-0125-preview': {
+        input: 0.01,
+        output: 0.03,
+    },
+    'gpt-4-0314': {
+        input: 0.03,
+        output: 0.06,
+    },
+    'gpt-4-0613': {
+        input: 0.03,
+        output: 0.06,
+    },
+    'gpt-4-1106-preview': {
+        input: 0.01,
+        output: 0.03,
+    },
+    'gpt-4-1106-vision-preview': {
+        input: 0.01,
+        output: 0.03,
+    },
+    'gpt-4-32k': {
+        input: 0.06,
+        output: 0.12,
+    },
+    'gpt-4-32k-0314': {
+        input: 0.06,
+        output: 0.12,
+    },
+    'gpt-4-32k-0613': {
+        input: 0.03,
+        output: 0.06,
+    },
+};
+class OpenlayerClient {
+    /**
+     * Constructs an OpenlayerClient instance.
+     * @param {OpenlayerClientConstructorProps} props - The config for the Openlayer client. The API key is required.
+     */
+    constructor({ openlayerApiKey, openlayerServerUrl, }) {
+        this.defaultConfig = {
+            costColumnName: 'cost',
+            groundTruthColumnName: null,
+            inferenceIdColumnName: 'id',
+            latencyColumnName: 'latency',
+            numOfTokenColumnName: 'tokens',
+            outputColumnName: 'output',
+            timestampColumnName: 'timestamp',
+        };
+        this.openlayerServerUrl = 'https://api.openlayer.com/v1';
+        this.version = '0.1.0a21';
+        this.resolvedQuery = (endpoint, args = {}) => (0, request_1.resolvedQuery)(this.openlayerServerUrl, endpoint, args);
+        /**
+         * Creates a new inference pipeline in Openlayer or loads an existing one.
+         * @param {string} projectId - The ID of the project containing the inference pipeline.
+         * @param {string} [name='production'] - The name of the inference pipeline, defaults to 'production'.
+         * @returns {Promise<OpenlayerInferencePipeline>} A promise that resolves to an OpenlayerInferencePipeline object.
+         * @throws {Error} Throws an error if the inference pipeline cannot be created or found.
+         */
+        this.createInferencePipeline = (projectId, name = 'production') => __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.loadInferencePipeline(projectId, name);
+            }
+            catch (_a) { }
+            const createInferencePipelineEndpoint = `/projects/${projectId}/inference-pipelines`;
+            const createInferencePipelineQuery = this.resolvedQuery(createInferencePipelineEndpoint, { version: this.version });
+            const createInferencePipelineResponse = yield (0, node_fetch_1.default)(createInferencePipelineQuery, {
+                body: JSON.stringify({
+                    description: '',
+                    name,
+                }),
+                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.
+         * @param {string} name - The name of the project.
+         * @param {OpenlayerTaskType} taskType - The type of task associated with the project.
+         * @param {string} [description] - Optional description of the project.
+         * @returns {Promise<OpenlayerProject>} A promise that resolves to an OpenlayerProject object.
+         * @throws {Error} Throws an error if the project cannot be created or found.
+         */
+        this.createProject = (name, taskType, description) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.loadProject(name);
+            }
+            catch (_b) { }
+            const projectsEndpoint = '/projects';
+            const projectsQuery = this.resolvedQuery(projectsEndpoint);
+            const response = yield (0, node_fetch_1.default)(projectsQuery, {
+                body: JSON.stringify({
+                    description,
+                    name,
+                    taskType,
+                }),
+                headers: {
+                    Authorization: `Bearer ${this.openlayerApiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                method: 'POST',
+            });
+            const data = (yield response.json());
+            const { items: projects, error } = data;
+            if (!Array.isArray(projects)) {
+                throw new Error(typeof error === 'string' ? 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 {string} projectId - The ID of the project containing the inference pipeline.
+         * @param {string} [name='production'] - The name of the inference pipeline, defaults to 'production'.
+         * @returns {Promise<OpenlayerInferencePipeline>} A promise that resolves to an OpenlayerInferencePipeline object.
+         * @throws {Error} Throws an error if the inference pipeline is not found.
+         */
+        this.loadInferencePipeline = (projectId, name = 'production') => __awaiter(this, void 0, void 0, function* () {
+            const inferencePipelineEndpoint = `/projects/${projectId}/inference-pipelines`;
+            const inferencePipelineQueryParameters = {
+                name,
+                version: this.version,
+            };
+            const inferencePipelineQuery = this.resolvedQuery(inferencePipelineEndpoint, inferencePipelineQueryParameters);
+            const inferencePipelineResponse = yield (0, node_fetch_1.default)(inferencePipelineQuery, {
+                headers: {
+                    Authorization: `Bearer ${this.openlayerApiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                method: 'GET',
+            });
+            const { items: inferencePipelines, error } = (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(typeof error === 'string' ? error : 'Inference pipeline not found');
+            }
+            return inferencePipeline;
+        });
+        /**
+         * Loads an existing project from Openlayer based on its name.
+         * @param {string} name - The name of the project.
+         * @returns {Promise<OpenlayerProject>} A promise that resolves to an OpenlayerProject object.
+         * @throws {Error} Throws an error if the project is not found.
+         */
+        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 response = yield (0, node_fetch_1.default)(projectsQuery, {
+                headers: {
+                    Authorization: `Bearer ${this.openlayerApiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                method: 'GET',
+            });
+            const data = yield response.json();
+            const { items: projects, error } = data;
+            if (!Array.isArray(projects)) {
+                throw new Error(typeof error === 'string' ? 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;
+        });
+        /**
+         * Streams data to the Openlayer inference pipeline.
+         * @param {StreamingData} data - The chat completion data to be streamed.
+         * @param {string} inferencePipelineId - The ID of the Openlayer inference pipeline to which data is streamed.
+         * @returns {Promise<void>} A promise that resolves when the data has been successfully streamed.
+         */
+        this.streamData = (data, config, inferencePipelineId) => __awaiter(this, void 0, void 0, function* () {
+            var _c;
+            if (!this.openlayerApiKey) {
+                console.error('Openlayer API key are required for streaming data.');
+                return;
+            }
+            try {
+                const dataStreamEndpoint = `/inference-pipelines/${inferencePipelineId}/data-stream`;
+                const dataStreamQuery = this.resolvedQuery(dataStreamEndpoint);
+                const response = yield (0, node_fetch_1.default)(dataStreamQuery, {
+                    body: JSON.stringify({
+                        config,
+                        rows: [
+                            Object.assign(Object.assign({}, data), { id: (0, uuid_1.v4)(), timestamp: Math.round(((_c = data.timestamp) !== null && _c !== void 0 ? _c : 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);
+                    console.error(`Error: ${response.status}`);
+                }
+                yield response.json();
+            }
+            catch (error) {
+                console.error('Error streaming data to Openlayer:', error);
+            }
+        });
+        this.openlayerApiKey = openlayerApiKey;
+        if (openlayerServerUrl) {
+            this.openlayerServerUrl = openlayerServerUrl;
+        }
+        if (!this.openlayerApiKey) {
+            console.error('Openlayer API key are required for publishing.');
+        }
+    }
+}
+exports.OpenlayerClient = OpenlayerClient;
+class OpenAIMonitor {
+    /**
+     * Constructs an OpenAIMonitor instance.
+     * @param {OpenAIMonitorConstructorProps} props - The configuration properties for the OpenAI and Openlayer clients.
+     */
+    constructor({ openAiApiKey, openlayerApiKey, openlayerProjectName, openlayerInferencePipelineId, openlayerInferencePipelineName, openlayerServerUrl, }) {
+        this.openlayerInferencePipelineName = 'production';
+        this.cost = (model, inputTokens, outputTokens) => {
+            const pricing = OpenAIPricing[model];
+            const inputCost = typeof pricing === 'undefined'
+                ? undefined
+                : (inputTokens / 1000) * pricing.input;
+            const outputCost = typeof pricing === 'undefined'
+                ? undefined
+                : (outputTokens / 1000) * pricing.output;
+            return typeof pricing === 'undefined'
+                ? undefined
+                : (inputCost !== null && inputCost !== void 0 ? inputCost : 0) + (outputCost !== null && outputCost !== void 0 ? outputCost : 0);
+        };
+        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 _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
+            const startTime = Date.now();
+            // Accumulate output for streamed responses
+            let streamedOutput = '';
+            const response = yield this.openAIClient.chat.completions.create(body, options);
+            try {
+                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 _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 = (_k = chunk.choices[0].delta.content) !== null && _k !== void 0 ? _k : '';
+                                streamedOutput += chunkOutput;
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (!_s && !_g && (_h = streamedResponse_1.return)) yield _h.call(streamedResponse_1);
+                            }
+                            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.openlayerInferencePipelineId);
+                    }
+                    else {
+                        const nonStreamedResponse = response;
+                        // Handle regular (non-streamed) response
+                        const endTime = Date.now();
+                        const latency = endTime - startTime;
+                        const output = nonStreamedResponse.choices[0].message.content;
+                        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.openlayerInferencePipelineId);
+                        }
+                        else {
+                            console.error('No output received from OpenAI.');
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                console.error(error);
+            }
+            return response;
+        });
+        /**
+         * 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 _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 (typeof this.openlayerInferencePipelineId === 'undefined') {
+                console.error('No inference pipeline found.');
+            }
+            // Start a timer to measure latency
+            const startTime = Date.now();
+            // Accumulate output and tokens data for streamed responses
+            let streamedModel = body.model;
+            let streamedOutput = '';
+            let streamedTokens = 0;
+            let streamedInputTokens = 0;
+            let streamedOutputTokens = 0;
+            const response = yield this.openAIClient.completions.create(body, options);
+            try {
+                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 _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 += (_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_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (!_8 && !_t && (_u = streamedResponse_2.return)) yield _u.call(streamedResponse_2);
+                            }
+                            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.openlayerInferencePipelineId);
+                    }
+                    else {
+                        const nonStreamedResponse = response;
+                        // Handle regular (non-streamed) response
+                        const endTime = Date.now();
+                        const latency = endTime - startTime;
+                        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.openlayerInferencePipelineId);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(error);
+            }
+            return response;
+        });
+        this.openlayerProjectName = openlayerProjectName;
+        this.openlayerInferencePipelineId = openlayerInferencePipelineId;
+        if (openlayerInferencePipelineName) {
+            this.openlayerInferencePipelineName = openlayerInferencePipelineName;
+        }
+        this.openlayerClient = new OpenlayerClient({
+            openlayerApiKey,
+            openlayerServerUrl,
+        });
+        this.openAIClient = new openai_1.default({
+            apiKey: openAiApiKey,
+            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 (run.status !== 'completed') {
+                return;
+            }
+            if (typeof this.openlayerInferencePipelineId === 'undefined') {
+                console.error('No inference pipeline found.');
+                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({ cost,
+                    latency, openai_assistant_id: assistant_id, openai_thread_id: thread_id, 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.
+     */
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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;
+            }
+            try {
+                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);
+            }
+        });
+    }
+}
+exports.OpenAIMonitor = OpenAIMonitor;

package/dist/lib/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/lib/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/dist/lib/utils/run.d.ts

@@ -0,0 +1,13 @@
+export interface RunReturn {
+    otherFields: {
+        [key: string]: any;
+    };
+    output: any;
+}
+export interface Config {
+    inputVariableNames?: string[];
+    metadata: {
+        outputTimestamp: number;
+    };
+    outputColumnName: string;
+}

package/dist/lib/utils/run.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/run.d.ts

@@ -0,0 +1,13 @@
+export interface RunReturn {
+    otherFields: {
+        [key: string]: any;
+    };
+    output: any;
+}
+export interface Config {
+    inputVariableNames?: string[];
+    metadata: {
+        outputTimestamp: number;
+    };
+    outputColumnName: string;
+}

package/dist/utils/run.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/examples/openai_dev_mode.ts

@@ -0,0 +1,58 @@
+/*
+ * This shows how to use the OpenAI monitor with Openlayer to create a CLI handler
+ * for processing datasets. The script can be called with the following command:
+ * node dist/run.js --dataset-path {{ path }} --dataset-name {{ name }}
+ */
+
+import { RunReturn } from 'openlayer/lib/utils/run';
+import { OpenAIMonitor } from 'openlayer';
+import { CLIHandler } from 'openlayer/cli/cliHandler';
+import { ChatCompletion } from 'openai/resources';
+
+export class MyModel {
+  private monitor: OpenAIMonitor;
+
+  private openaiApiKey: string;
+
+  private openlayerApiKey: string;
+
+  constructor() {
+    this.openaiApiKey = process.env.OPENAI_API_KEY || '';
+    this.openlayerApiKey = process.env.OPENLAYER_API_KEY || '';
+    const openlayerProjectName = process.env.OPENLAYER_PROJECT_NAME || '';
+
+    this.monitor = new OpenAIMonitor({
+      openAiApiKey: this.openaiApiKey,
+      openlayerApiKey: this.openlayerApiKey,
+      openlayerProjectName,
+    });
+  }
+
+  async run({ userQuery }: { userQuery: string }): Promise<RunReturn> {
+    // Implement the model run logic here
+    const model = 'gpt-3.5-turbo';
+    const response = await this.monitor.createChatCompletion(
+      {
+        messages: [
+          {
+            content: userQuery,
+            role: 'user',
+          },
+        ],
+        model,
+      },
+      undefined
+    );
+    const result = (response as ChatCompletion).choices[0].message.content;
+    return { otherFields: { model }, output: result };
+  }
+}
+
+// User implements their model
+const model = new MyModel();
+
+// Initialize CLI handler with the user's model run method
+const cliHandler = new CLIHandler(model.run.bind(model));
+
+// Setup CLI and process dataset
+cliHandler.runFromCLI();

package/package.json

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

package/static/logo-purple-text.svg

@@ -0,0 +1,14 @@
+<svg width="2074" height="338" viewBox="0 0 2074 338" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M78.2891 0V77.6246H248.238C255.317 77.6246 261.07 83.3779 261.07 90.4566V260.405H338.694V114.946L223.719 0H78.2891Z" fill="#592FEA"/>
+<path d="M78.2892 247.543V77.6248H0.664551V156.243C0.664551 256.61 82.0243 338 182.421 338H261.04V260.375H91.0911C84.0124 260.375 78.259 254.622 78.259 247.543H78.2892Z" fill="#592FEA"/>
+<path d="M1746.69 76.2997H1712.86L1678.49 173.263C1674.52 184.498 1669.16 200.433 1662.35 221.127L1651.29 187.812L1646.57 173.263L1612.38 76.2997H1577.83L1647.77 253.96V295.679H1589.63V328.391H1603.88C1645.66 328.391 1679.61 294.956 1680.48 253.387L1746.72 76.2695L1746.69 76.2997Z" fill="#592FEA"/>
+<path d="M512.8 245.616C494.938 235.525 481.323 220.735 472.015 201.216C462.707 181.696 458.038 158.051 458.038 130.278C458.038 104.614 462.677 81.9622 471.925 62.3226C481.172 42.683 494.817 27.4111 512.8 16.4467C530.783 5.48222 552.381 0 577.593 0C602.805 0 623.83 5.51234 641.753 16.537C659.676 27.5617 673.351 42.8939 682.719 62.5937C692.087 82.2935 696.786 104.855 696.786 130.278C696.786 155.701 692.117 178.775 682.809 198.414C673.502 218.054 659.856 233.356 641.934 244.29C624.011 255.255 602.564 260.737 577.593 260.737C552.622 260.737 530.663 255.706 512.8 245.616V245.616ZM615.396 225.675C625.698 221.036 634.102 213.987 640.548 204.499C646.994 195.342 651.844 184.679 655.127 172.509C658.41 160.31 660.037 146.243 660.037 130.308C660.037 114.374 658.41 100.397 655.127 88.3782C651.844 76.3595 646.964 65.7264 640.548 56.4789C627.535 37.6225 607.022 28.1642 579.009 28.1642C563.767 28.1642 550.603 30.7245 539.549 35.8152C528.464 40.9058 519.879 47.3218 513.794 55.0632C507.71 63.1359 503.011 73.6786 499.727 86.6311C496.444 99.5836 494.817 114.133 494.817 130.308C494.817 146.484 496.504 161.786 499.908 174.798C503.312 187.811 507.589 197.721 512.74 204.499C519.879 213.535 528.976 220.464 540.001 225.343C551.025 230.223 563.556 232.633 577.623 232.633C592.503 232.633 605.094 230.313 615.426 225.675H615.396Z" fill="#592FEA"/>
+<path d="M865.801 83.3481C878.332 90.969 888.152 101.903 895.261 116.151C902.339 130.399 905.894 147.117 905.894 166.334C905.894 185.552 902.46 201.607 895.622 215.915C888.754 230.223 879.145 241.248 866.795 249.05C854.445 256.851 840.228 260.737 824.172 260.737C798.629 260.737 779.291 251.429 766.157 232.784V328.421H733.806V76.2995H766.157V102.656C772.724 92.3546 780.797 84.6433 790.406 79.5226C800.014 74.432 810.919 71.8716 823.118 71.8716C839.053 71.8716 853.3 75.667 865.831 83.2879L865.801 83.3481ZM857.969 217.572C866.132 206.156 870.199 189.077 870.199 166.334C870.199 151.334 868.633 138.863 865.53 128.893C862.427 118.922 857.006 111.211 849.264 105.759C841.523 100.307 830.86 97.5958 817.274 97.5958C800.045 97.5958 787.032 103.349 778.236 114.826C769.441 126.302 765.043 143.381 765.043 165.973C765.043 186.366 768.657 202.933 775.857 215.644C783.056 228.356 796.641 234.712 816.551 234.712C836.462 234.712 849.806 228.988 857.939 217.572H857.969Z" fill="#592FEA"/>
+<path d="M1339.47 4.2168H1371.82V256.339H1339.47V4.2168Z" fill="#592FEA"/>
+<path d="M1074.64 203.625C1071.87 212.692 1067.32 219.741 1060.9 224.771C1052.47 231.398 1040.57 234.711 1025.21 234.711C1008.34 234.711 995.688 229.922 987.314 220.313C978.94 210.704 974.512 195.944 974.03 176.004H1110.63C1110.75 174.377 1110.81 171.847 1110.81 168.443C1110.81 156.966 1109.46 145.881 1106.78 135.218C1104.07 124.555 1100.33 115.338 1095.51 107.596C1088.25 96.1198 1078.34 87.294 1065.81 81.1491C1053.28 75.0042 1039.73 71.9016 1025.21 71.9016C1012.19 71.9016 1000.3 74.1909 989.513 78.7694C978.729 83.348 969.421 90.0652 961.559 98.9814C954.059 107.295 948.396 117.175 944.6 128.591C940.775 140.008 938.877 152.478 938.877 165.943C938.877 195.131 946.197 217.933 960.836 234.32C975.958 251.911 997.525 260.707 1025.54 260.707C1048.52 260.707 1067.02 255.315 1081.02 244.531C1093.49 234.922 1101.96 221.277 1106.48 203.595H1074.64V203.625ZM976.771 133.531C978.126 127.959 980.265 122.718 983.187 117.808C986.802 111.723 992.314 106.934 999.724 103.47C1007.1 100.006 1015.72 98.2886 1025.57 98.2886C1035.42 98.2886 1043.76 99.8549 1050.63 102.957C1057.5 106.06 1063.19 111.03 1067.77 117.808C1070.57 121.904 1072.86 126.965 1074.64 133.019C1076.41 139.044 1077.35 144.646 1077.44 149.797H974.602C974.723 144.526 975.446 139.104 976.801 133.531H976.771Z" fill="#592FEA"/>
+<path d="M1892.78 203.625C1890.01 212.692 1885.46 219.741 1879.05 224.771C1870.61 231.398 1858.72 234.711 1843.35 234.711C1826.48 234.711 1813.83 229.922 1805.46 220.313C1797.09 210.704 1792.66 195.944 1792.18 176.004H1928.78C1928.9 174.377 1928.96 171.847 1928.96 168.443C1928.96 156.966 1927.6 145.881 1924.92 135.218C1922.21 124.555 1918.48 115.338 1913.66 107.596C1906.4 96.1198 1896.49 87.294 1883.96 81.1491C1871.43 75.0042 1857.87 71.9016 1843.35 71.9016C1830.34 71.9016 1818.44 74.1909 1807.66 78.7694C1796.87 83.348 1787.57 90.0652 1779.71 98.9814C1772.2 107.295 1766.54 117.175 1762.75 128.591C1758.92 140.008 1757.02 152.478 1757.02 165.943C1757.02 195.131 1764.34 217.933 1778.98 234.32C1794.1 251.911 1815.67 260.707 1843.68 260.707C1866.67 260.707 1885.16 255.315 1899.17 244.531C1911.64 234.922 1920.1 221.277 1924.62 203.595H1892.78V203.625ZM1794.92 133.531C1796.27 127.959 1798.41 122.718 1801.33 117.808C1804.95 111.723 1810.46 106.934 1817.87 103.47C1825.25 100.006 1833.86 98.2886 1843.71 98.2886C1853.56 98.2886 1861.91 99.8549 1868.78 102.957C1875.64 106.06 1881.34 111.03 1885.92 117.808C1888.72 121.904 1891.01 126.965 1892.78 133.019C1894.56 139.044 1895.49 144.646 1895.58 149.797H1792.75C1792.87 144.526 1793.59 139.104 1794.95 133.531H1794.92Z" fill="#592FEA"/>
+<path d="M1995.29 105.066H2073.34V71.9314H2039.75C1996.89 71.9314 1962.15 106.662 1962.15 149.526V256.339H1995.23L1995.32 105.066H1995.29Z" fill="#592FEA"/>
+<path d="M1176.36 104.223H1144.01V256.339H1176.36V104.223Z" fill="#592FEA"/>
+<path d="M1223.86 71.9016H1176.36V104.253H1267.27V182.51V256.339H1299.62V147.629C1299.62 105.789 1265.7 71.9016 1223.89 71.9016H1223.86Z" fill="#592FEA"/>
+<path d="M1578.34 231.308H1557.37V131.332C1557.37 111.753 1551.62 96.9632 1540.14 86.9325C1528.67 76.9019 1511.59 71.9016 1489 71.9016C1477.52 71.9016 1467.07 73.0462 1457.7 75.3355C1448.33 77.6248 1440.41 80.9382 1433.96 85.2758C1426.95 89.9749 1421.55 96.2403 1417.79 104.102C1414.44 111.06 1412.49 119.193 1411.82 128.471H1443.75C1444.87 118.862 1448.12 111.572 1453.57 106.753C1460.44 100.668 1471.65 97.5958 1487.25 97.5958C1495.11 97.5958 1501.89 98.65 1507.64 100.759C1513.4 102.867 1517.49 105.729 1519.93 109.373C1522.52 112.898 1524.18 117.024 1524.93 121.754C1525.69 126.513 1526.08 133.321 1526.08 142.237L1466.65 153.653C1455.05 155.882 1444.87 158.834 1436.13 162.539C1427.4 166.244 1420.11 171.847 1414.23 179.347C1408.36 186.847 1405.44 196.697 1405.44 208.867C1405.44 220.012 1408.27 229.5 1413.96 237.362C1419.66 245.224 1427.1 251.068 1436.28 254.954C1445.47 258.809 1455.35 260.737 1465.89 260.737C1496.14 260.737 1516.35 250.375 1526.56 229.621C1528.07 248.387 1538.82 257.755 1558.73 257.755C1566.11 257.755 1572.86 257.273 1578.94 256.339L1578.28 231.338L1578.34 231.308ZM1526.08 188.293C1526.08 202.119 1521.56 213.325 1512.55 221.879C1503.52 230.434 1489.69 234.711 1471.07 234.711C1461.83 234.711 1454.09 232.362 1447.88 227.693C1441.68 222.994 1438.57 216.608 1438.57 208.535C1438.57 201.969 1439.96 196.728 1442.7 192.812C1445.44 188.896 1449.15 185.884 1453.78 183.835C1458.42 181.787 1464.42 179.95 1471.8 178.293L1526.11 166.334V188.293H1526.08Z" fill="#592FEA"/>
+</svg>

package/tsconfig.json

@@ -1,4 +1,5 @@
 {
+  "exclude": ["node_modules", "dist", "test", "examples"],
   "compilerOptions": {
     "target": "ES2015",
     "module": "CommonJS",