llm-proxy 1.0.0 → 1.0.2

package/dist/services/OpenAIService.js

@@ -0,0 +1,104 @@
+"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 __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+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); }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIService = void 0;
+const openai_1 = __importDefault(require("openai"));
+class OpenAIService {
+    constructor(apiKey) {
+        this.openai = new openai_1.default({ apiKey });
+    }
+    generateCompletion(messages, model, maxTokens, temperature, systemPrompt, // Optional parameter
+    tools // Optional parameter
+    ) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (model.type !== "OpenAI") {
+                throw new Error("Unsupported model type for OpenAIService.");
+            }
+            try {
+                const response = yield this.openai.chat.completions.create({
+                    model: model.model,
+                    messages,
+                    max_tokens: maxTokens,
+                    temperature,
+                });
+                return response;
+            }
+            catch (error) {
+                console.error("Error generating text:", error);
+                throw error;
+            }
+        });
+    }
+    generateStreamCompletion(messages, model, maxTokens, temperature, systemPrompt, // Optional parameter
+    tools, // Optional parameter
+    stream // Optional parameter
+    ) {
+        return __asyncGenerator(this, arguments, function* generateStreamCompletion_1() {
+            var _a, e_1, _b, _c;
+            if (model.type !== "OpenAI") {
+                throw new Error("Unsupported model type for OpenAIService.");
+            }
+            try {
+                const stream = yield __await(this.openai.chat.completions.create({
+                    model: model.model,
+                    messages,
+                    max_tokens: maxTokens,
+                    temperature,
+                    stream: true,
+                }));
+                try {
+                    for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield __await(stream_1.next()), _a = stream_1_1.done, !_a; _d = true) {
+                        _c = stream_1_1.value;
+                        _d = false;
+                        const chunk = _c;
+                        yield yield __await(chunk);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = stream_1.return)) yield __await(_b.call(stream_1));
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            catch (error) {
+                console.error("Error in stream completion:", error);
+                throw error;
+            }
+        });
+    }
+}
+exports.OpenAIService = OpenAIService;
+//# sourceMappingURL=OpenAIService.js.map

package/dist/services/OpenAIService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenAIService.js","sourceRoot":"","sources":["../../src/services/OpenAIService.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,oDAA4B;AAI5B,MAAa,aAAa;IAGxB,YAAY,MAAc;QACxB,IAAI,CAAC,MAAM,GAAG,IAAI,gBAAM,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IACvC,CAAC;IAEK,kBAAkB,CACtB,QAAwB,EACxB,KAAoB,EACpB,SAAiB,EACjB,WAAmB,EACnB,YAAqB,EAAE,qBAAqB;IAC5C,KAAW,CAAC,qBAAqB;;;YAEjC,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC5B,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;YAC/D,CAAC;YAED,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;oBACzD,KAAK,EAAE,KAAK,CAAC,KAAK;oBAClB,QAAQ;oBACR,UAAU,EAAE,SAAS;oBACrB,WAAW;iBACZ,CAAC,CAAC;gBACH,OAAO,QAA0B,CAAC;YACpC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,OAAO,CAAC,KAAK,CAAC,wBAAwB,EAAE,KAAK,CAAC,CAAC;gBAC/C,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;KAAA;IAEM,wBAAwB,CAC7B,QAAwB,EACxB,KAAoB,EACpB,SAAiB,EACjB,WAAmB,EACnB,YAAqB,EAAE,qBAAqB;IAC5C,KAAW,EAAE,qBAAqB;IAClC,MAAgB,CAAC,qBAAqB;;;;YAEtC,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBAC5B,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;YAC/D,CAAC;YAED,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,cAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;oBACvD,KAAK,EAAE,KAAK,CAAC,KAAK;oBAClB,QAAQ;oBACR,UAAU,EAAE,SAAS;oBACrB,WAAW;oBACX,MAAM,EAAE,IAAI;iBACb,CAAC,CAAA,CAAC;;oBAEH,KAA0B,eAAA,WAAA,cAAA,MAAM,CAAA,YAAA,qFAAE,CAAC;wBAAT,sBAAM;wBAAN,WAAM;wBAArB,MAAM,KAAK,KAAA,CAAA;wBACpB,oBAAM,KAAK,CAAA,CAAC;oBACd,CAAC;;;;;;;;;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,OAAO,CAAC,KAAK,CAAC,6BAA6B,EAAE,KAAK,CAAC,CAAC;gBACpD,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;KAAA;CACF;AA/DD,sCA+DC"}

package/dist/types/index.d.ts

@@ -0,0 +1,194 @@
+export declare enum Providers {
+    OPENAI = "OpenAI",
+    ANTHROPIC_BEDROCK = "AnthropicBedrock",
+    COHERE_BEDROCK = "CohereBedrock"
+}
+export declare enum OpenAIMessagesRoles {
+    SYSTEM = "system",
+    USER = "user",
+    ASSISTANT = "assistant",
+    TOOL = "tool",
+    FUNCTION = "function"
+}
+export type OpenAISystemMessage = {
+    role: OpenAIMessagesRoles.SYSTEM;
+    content: string;
+};
+export type OpenAIUserMessage = {
+    role: OpenAIMessagesRoles.USER;
+    content: string;
+};
+export type OpenAIAssistantMessage = {
+    role: OpenAIMessagesRoles.ASSISTANT;
+    content: string;
+};
+export type OpenAIToolMessage = {
+    role: OpenAIMessagesRoles.TOOL;
+    content: string;
+    tool_call_id: string;
+};
+export type OpenAIFunctionMessage = {
+    role: OpenAIMessagesRoles.FUNCTION;
+    content: string;
+    name: string;
+};
+export type OpenAIMessage = OpenAISystemMessage | OpenAIUserMessage | OpenAIAssistantMessage | OpenAIToolMessage | OpenAIFunctionMessage;
+export type OpenAIMessages = OpenAIMessage[];
+export declare enum OpenAISupportedLLMs {
+    GPT_4_O_LAEST = "chatgpt-4o-latest",// points to the latest version of gpt-4o
+    GPT_4_O = "gpt-4o",
+    GPT_4_O_MINI = "gpt-4o-mini",
+    GPT_4_TURBO = "gpt-4-turbo",
+    GPT_4_TURBO_PREVIEW = "gpt-4-turbo-preview",// its same  as gpt-4-turbo-2024-04-09
+    GPT_3_5_TURBO = "gpt-3.5-turbo"
+}
+export interface OpenAIChoices {
+    index: number;
+    message: any;
+    logprobs: any;
+    finish_reason: string;
+}
+export interface OpenAIUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    prompt_tokens_details: any;
+    completion_tokens_details: any;
+}
+export interface OpenAIResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        message: {
+            role: string;
+            content: string;
+        };
+        logprobs: null | object;
+        finish_reason: string;
+    }>;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+        prompt_tokens_details: {
+            cached_tokens: number;
+        };
+        completion_tokens_details: {
+            reasoning_tokens: number;
+        };
+    };
+    system_fingerprint: string;
+}
+export declare enum BedrockAnthropicSupportedLLMs {
+    CLAUDE_3_HAIKU = "anthropic.claude-3-haiku-20240307-v1:0",
+    CLAUDE_3_SONNET = "anthropic.claude-3-sonnet-20240229-v1:0",
+    CLAUDE_3_OPUS = "anthropic.claude-3-opus-20240229-v1:0",
+    CLAUDE_3_5_SONNET = "anthropic.claude-3-5-sonnet-20241022-v2:0"
+}
+export declare enum BedrockAnthropicContentType {
+    TEXT = "text",
+    IMAGE = "image",
+    TOOL_USE = "tool_use",
+    TOOL_RESULT = "tool_result"
+}
+export declare enum BedrockAnthropicMessageRole {
+    USER = "user",
+    ASSISTANT = "assistant"
+}
+export interface BedrockAnthropicToolUseContent {
+    type: BedrockAnthropicContentType.TOOL_USE;
+    id: string;
+    name: string;
+    input: any;
+}
+export interface BedrockAnthropicTextContent {
+    type: BedrockAnthropicContentType.TEXT;
+    text: string;
+}
+interface BedrockAnthropicImageContent {
+    type: BedrockAnthropicContentType.IMAGE;
+    source: {
+        type: string;
+        media_type: string;
+        data: string;
+    };
+}
+export interface BedrockAnthropicToolResultContent {
+    type: BedrockAnthropicContentType.TOOL_RESULT;
+    content: string;
+}
+export type BedrockAnthropicContent = BedrockAnthropicToolUseContent | BedrockAnthropicToolResultContent | BedrockAnthropicTextContent | BedrockAnthropicImageContent;
+export interface BedrockAnthropicMessage {
+    role: BedrockAnthropicMessageRole;
+    content: BedrockAnthropicContent[];
+}
+export interface BedrockAnthropicFunctionCall {
+    id: string;
+    name: string;
+    arguments: string;
+}
+export type BedrockAnthropicMessages = BedrockAnthropicMessage[];
+export interface BedrockAnthropicOptions {
+    outputTokenLength: number;
+    temperature: number;
+    systemPrompt: string;
+    messages: BedrockAnthropicMessages;
+    tools: any;
+}
+export interface BedrockAnthropicUsage {
+    input_tokens: number;
+    output_tokens: number;
+}
+export interface BedrockAnthropicResponse {
+    id: string;
+    type: "message";
+    role: BedrockAnthropicMessageRole;
+    model: string;
+    content: BedrockAnthropicContent[];
+    stop_reason: string;
+    stop_sequence: string;
+    usage: BedrockAnthropicUsage;
+}
+export interface BedrockAnthropicMessageChunk {
+    id: string;
+    type: "message";
+    model: string;
+    role: BedrockAnthropicMessageRole;
+    content: BedrockAnthropicContent[];
+    stop_reason: string | null;
+    stop_sequence: string | null;
+    usage: BedrockAnthropicUsage;
+}
+export interface BedrockAnthropicContentBlock {
+    type: string;
+    text: string;
+    name?: string;
+    id?: string;
+    partial_json?: string;
+}
+export interface BedrockAnthropicMetrics {
+    inputTokenCount: number;
+    outputTokenCount: number;
+    invocationLatency: number;
+    firstByteLatency: number;
+}
+export type BedrockAnthropicParsedChunk = {
+    type: "message_start";
+    message?: BedrockAnthropicMessageChunk;
+    content_block?: BedrockAnthropicContentBlock;
+    delta?: BedrockAnthropicContentBlock;
+    "amazon-bedrock-invocationMetrics"?: BedrockAnthropicMetrics;
+};
+export type Messages = OpenAIMessages | BedrockAnthropicMessages;
+export type LLMResponse = OpenAIResponse | BedrockAnthropicResponse;
+export type SupportedLLMs = {
+    type: "OpenAI";
+    model: OpenAISupportedLLMs;
+} | {
+    type: "BedrockAnthropic";
+    model: BedrockAnthropicSupportedLLMs;
+};
+export {};

package/dist/types/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BedrockAnthropicMessageRole = exports.BedrockAnthropicContentType = exports.BedrockAnthropicSupportedLLMs = exports.OpenAISupportedLLMs = exports.OpenAIMessagesRoles = exports.Providers = void 0;
+// GENERAL
+var Providers;
+(function (Providers) {
+    Providers["OPENAI"] = "OpenAI";
+    Providers["ANTHROPIC_BEDROCK"] = "AnthropicBedrock";
+    Providers["COHERE_BEDROCK"] = "CohereBedrock";
+})(Providers || (exports.Providers = Providers = {}));
+// OPENAI
+var OpenAIMessagesRoles;
+(function (OpenAIMessagesRoles) {
+    OpenAIMessagesRoles["SYSTEM"] = "system";
+    OpenAIMessagesRoles["USER"] = "user";
+    OpenAIMessagesRoles["ASSISTANT"] = "assistant";
+    OpenAIMessagesRoles["TOOL"] = "tool";
+    OpenAIMessagesRoles["FUNCTION"] = "function";
+})(OpenAIMessagesRoles || (exports.OpenAIMessagesRoles = OpenAIMessagesRoles = {}));
+var OpenAISupportedLLMs;
+(function (OpenAISupportedLLMs) {
+    OpenAISupportedLLMs["GPT_4_O_LAEST"] = "chatgpt-4o-latest";
+    OpenAISupportedLLMs["GPT_4_O"] = "gpt-4o";
+    OpenAISupportedLLMs["GPT_4_O_MINI"] = "gpt-4o-mini";
+    OpenAISupportedLLMs["GPT_4_TURBO"] = "gpt-4-turbo";
+    OpenAISupportedLLMs["GPT_4_TURBO_PREVIEW"] = "gpt-4-turbo-preview";
+    OpenAISupportedLLMs["GPT_3_5_TURBO"] = "gpt-3.5-turbo";
+})(OpenAISupportedLLMs || (exports.OpenAISupportedLLMs = OpenAISupportedLLMs = {}));
+// AWS BEDROCK
+// AWS BEDROCK ANTHROPIC
+var BedrockAnthropicSupportedLLMs;
+(function (BedrockAnthropicSupportedLLMs) {
+    BedrockAnthropicSupportedLLMs["CLAUDE_3_HAIKU"] = "anthropic.claude-3-haiku-20240307-v1:0";
+    BedrockAnthropicSupportedLLMs["CLAUDE_3_SONNET"] = "anthropic.claude-3-sonnet-20240229-v1:0";
+    BedrockAnthropicSupportedLLMs["CLAUDE_3_OPUS"] = "anthropic.claude-3-opus-20240229-v1:0";
+    BedrockAnthropicSupportedLLMs["CLAUDE_3_5_SONNET"] = "anthropic.claude-3-5-sonnet-20241022-v2:0";
+})(BedrockAnthropicSupportedLLMs || (exports.BedrockAnthropicSupportedLLMs = BedrockAnthropicSupportedLLMs = {}));
+var BedrockAnthropicContentType;
+(function (BedrockAnthropicContentType) {
+    BedrockAnthropicContentType["TEXT"] = "text";
+    BedrockAnthropicContentType["IMAGE"] = "image";
+    BedrockAnthropicContentType["TOOL_USE"] = "tool_use";
+    BedrockAnthropicContentType["TOOL_RESULT"] = "tool_result";
+})(BedrockAnthropicContentType || (exports.BedrockAnthropicContentType = BedrockAnthropicContentType = {}));
+var BedrockAnthropicMessageRole;
+(function (BedrockAnthropicMessageRole) {
+    BedrockAnthropicMessageRole["USER"] = "user";
+    BedrockAnthropicMessageRole["ASSISTANT"] = "assistant";
+})(BedrockAnthropicMessageRole || (exports.BedrockAnthropicMessageRole = BedrockAnthropicMessageRole = {}));
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;AAAA,UAAU;AACV,IAAY,SAIX;AAJD,WAAY,SAAS;IACnB,8BAAiB,CAAA;IACjB,mDAAsC,CAAA;IACtC,6CAAgC,CAAA;AAClC,CAAC,EAJW,SAAS,yBAAT,SAAS,QAIpB;AAED,SAAS;AACT,IAAY,mBAMX;AAND,WAAY,mBAAmB;IAC7B,wCAAiB,CAAA;IACjB,oCAAa,CAAA;IACb,8CAAuB,CAAA;IACvB,oCAAa,CAAA;IACb,4CAAqB,CAAA;AACvB,CAAC,EANW,mBAAmB,mCAAnB,mBAAmB,QAM9B;AAsCD,IAAY,mBAOX;AAPD,WAAY,mBAAmB;IAC7B,0DAAmC,CAAA;IACnC,yCAAkB,CAAA;IAClB,mDAA4B,CAAA;IAC5B,kDAA2B,CAAA;IAC3B,kEAA2C,CAAA;IAC3C,sDAA+B,CAAA;AACjC,CAAC,EAPW,mBAAmB,mCAAnB,mBAAmB,QAO9B;AAyCD,cAAc;AAEd,wBAAwB;AAExB,IAAY,6BAKX;AALD,WAAY,6BAA6B;IACvC,0FAAyD,CAAA;IACzD,4FAA2D,CAAA;IAC3D,wFAAuD,CAAA;IACvD,gGAA+D,CAAA;AACjE,CAAC,EALW,6BAA6B,6CAA7B,6BAA6B,QAKxC;AAED,IAAY,2BAKX;AALD,WAAY,2BAA2B;IACrC,4CAAa,CAAA;IACb,8CAAe,CAAA;IACf,oDAAqB,CAAA;IACrB,0DAA2B,CAAA;AAC7B,CAAC,EALW,2BAA2B,2CAA3B,2BAA2B,QAKtC;AAED,IAAY,2BAGX;AAHD,WAAY,2BAA2B;IACrC,4CAAa,CAAA;IACb,sDAAuB,CAAA;AACzB,CAAC,EAHW,2BAA2B,2CAA3B,2BAA2B,QAGtC"}

package/package.json

@@ -1,9 +1,15 @@
 {
   "name": "llm-proxy",
-  "version": "1.0.0",
-  "description": "An LLM Proxy that allows the  user to interact with different language models from different providers using unified request and response formats.",
-  "main": "index.js",
+  "version": "1.0.2",
+  "description": "An LLM Proxy that allows the user to interact with different language models from different providers using unified request and response formats.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
   "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
     "test": "jest --config jest.config.js",
     "dev": "ts-node src/index.ts"
   },