@imenam/unified-llm-client 1.4.1 → 2.0.0

package/dist/proxy/ProxyServer.js

@@ -0,0 +1,243 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyServer = void 0;
+const http = __importStar(require("http"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const mime = __importStar(require("mime-types"));
+const UnifiedLLMClient_1 = require("../core/UnifiedLLMClient");
+class ProxyServer {
+    constructor(options) {
+        this.options = options;
+        this.server = http.createServer(this.handleRequest.bind(this));
+    }
+    start() {
+        return new Promise((resolve) => {
+            this.server.listen(this.options.port, () => {
+                console.log(`[ProxyServer] Listening on port ${this.options.port}`);
+                resolve();
+            });
+        });
+    }
+    stop() {
+        return new Promise((resolve, reject) => {
+            this.server.close((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    handleRequest(req, res) {
+        if (req.method !== "POST" || req.url !== "/api/chat") {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Not found" }));
+            return;
+        }
+        if (this.options.apiKey) {
+            const providedKey = req.headers["x-api-key"];
+            if (providedKey !== this.options.apiKey) {
+                res.writeHead(401, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Unauthorized" }));
+                return;
+            }
+        }
+        let body = "";
+        req.on("data", (chunk) => {
+            body += chunk.toString();
+        });
+        req.on("end", () => {
+            this.processChat(body, res).catch((err) => {
+                console.error("[ProxyServer] Unhandled error:", err);
+                if (!res.headersSent) {
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: err.message }));
+                }
+            });
+        });
+        req.on("error", (err) => {
+            console.error("[ProxyServer] Request error:", err);
+        });
+    }
+    processChat(body, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let request;
+            try {
+                request = JSON.parse(body);
+            }
+            catch (_a) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Invalid JSON body" }));
+                return;
+            }
+            let resolvedApiKey;
+            if (this.options.apiKeyResolver) {
+                if (request.apiKeyContext === undefined) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "apiKeyResolver is defined but no apiKeyContext was provided" }));
+                    return;
+                }
+                const result = this.options.apiKeyResolver(request.apiKeyContext);
+                if (result === false) {
+                    res.writeHead(403, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "apiKeyResolver returned false" }));
+                    return;
+                }
+                resolvedApiKey = result;
+            }
+            const tempFiles = [];
+            try {
+                const messages = yield this.decodeAttachedFiles(request.messages, tempFiles);
+                const client = new UnifiedLLMClient_1.UnifiedLLMClient(request.model, resolvedApiKey ? { apiKey: resolvedApiKey } : undefined);
+                if (request.stream) {
+                    res.writeHead(200, {
+                        "Content-Type": "text/event-stream",
+                        "Cache-Control": "no-cache",
+                        "Connection": "keep-alive",
+                    });
+                    try {
+                        yield client.chat({
+                            message: messages,
+                            tools: request.tools,
+                            toolChoice: request.toolChoice,
+                            stream: true,
+                            config: request.config,
+                            onChunk: (chunk) => {
+                                const { rawChunk: _rawChunk } = chunk, safeChunk = __rest(chunk, ["rawChunk"]);
+                                this.writeSSE(res, { type: "chunk", data: safeChunk });
+                            },
+                            onFinalResponse: (finalResponse) => {
+                                const { raw: _raw } = finalResponse, safeResponse = __rest(finalResponse, ["raw"]);
+                                this.writeSSE(res, { type: "final", data: safeResponse });
+                            },
+                        });
+                    }
+                    catch (err) {
+                        this.writeSSE(res, { type: "error", data: { message: err.message } });
+                    }
+                    finally {
+                        res.end();
+                    }
+                }
+                else {
+                    try {
+                        const response = yield client.chat({
+                            message: messages,
+                            tools: request.tools,
+                            toolChoice: request.toolChoice,
+                            stream: false,
+                            config: request.config,
+                        });
+                        const { raw: _raw } = response, safeResponse = __rest(response, ["raw"]);
+                        res.writeHead(200, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify(Object.assign(Object.assign({}, safeResponse), { raw: null })));
+                    }
+                    catch (err) {
+                        res.writeHead(500, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: err.message, statusCode: 500 }));
+                    }
+                }
+            }
+            finally {
+                for (const tmpFile of tempFiles) {
+                    try {
+                        fs.unlinkSync(tmpFile);
+                    }
+                    catch (_b) {
+                        /* ignore cleanup errors */
+                    }
+                }
+            }
+        });
+    }
+    decodeAttachedFiles(messages, tempFiles) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return messages.map((message) => {
+                if (!message.attachedFile)
+                    return message;
+                const files = Array.isArray(message.attachedFile)
+                    ? message.attachedFile
+                    : [message.attachedFile];
+                const decodedFiles = files.map((file) => {
+                    if (typeof file !== "string")
+                        return file;
+                    if (file.startsWith("http://") || file.startsWith("https://"))
+                        return file;
+                    if (file.startsWith("data:")) {
+                        const match = file.match(/^data:([^;]+);base64,(.+)$/);
+                        if (!match)
+                            return file;
+                        const mimeType = match[1];
+                        const base64Data = match[2];
+                        const ext = mime.extension(mimeType) || "bin";
+                        const tmpPath = path.join(os.tmpdir(), `proxy-upload-${Date.now()}-${Math.random().toString(36).slice(2)}.${ext}`);
+                        fs.writeFileSync(tmpPath, Buffer.from(base64Data, "base64"));
+                        tempFiles.push(tmpPath);
+                        return tmpPath;
+                    }
+                    return file;
+                });
+                return Object.assign(Object.assign({}, message), { attachedFile: decodedFiles.length === 1 ? decodedFiles[0] : decodedFiles });
+            });
+        });
+    }
+    writeSSE(res, event) {
+        res.write(`data: ${JSON.stringify(event)}\n\n`);
+    }
+}
+exports.ProxyServer = ProxyServer;

package/dist/proxy/types.d.ts

@@ -0,0 +1,32 @@
+import { ApiKeyResolver, ChatMessage, ToolDefinition, ChatResponse, Model } from "../common/types";
+import { StreamedChatChunk } from "../core/LLMAdapter";
+export interface ProxyServerOptions {
+    port: number;
+    apiKey?: string;
+    apiKeyResolver?: ApiKeyResolver;
+}
+export interface ProxyChatRequest {
+    model: Model;
+    messages: ChatMessage[];
+    tools?: Omit<ToolDefinition, "executor">[];
+    toolChoice?: string;
+    stream?: boolean;
+    config?: {
+        thinkingBudget?: number;
+        metadata?: Record<string, any>;
+    };
+    apiKeyContext?: unknown;
+}
+export type ProxySSEEvent = {
+    type: "chunk";
+    data: StreamedChatChunk;
+} | {
+    type: "final";
+    data: Omit<ChatResponse, "raw">;
+} | {
+    type: "error";
+    data: {
+        message: string;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/proxy/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/proxy/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,cAAc,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACnG,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEvD,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,KAAK,CAAC,EAAE,IAAI,CAAC,cAAc,EAAE,UAAU,CAAC,EAAE,CAAC;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE;QACP,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KAChC,CAAC;IACF,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,CAAC"}

package/dist/proxy/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imenam/unified-llm-client",
-  "version": "1.4.1",
+  "version": "2.0.0",
   "description": "A unified interface for multiple LLM providers (OpenAI, Gemini, Anthropic, Qwen) with tool-calling, streaming, and audio support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,7 +20,11 @@
     "example:audio": "node dist/examples/audio-example.js",
     "example:qwen": "node dist/examples/qwen-vl-example.js",
     "example:anthropic": "node dist/examples/anthropic-example.js",
-    "example:abort": "node dist/examples/chat-abort-example.js"
+    "example:abort": "node dist/examples/chat-abort-example.js",
+    "example:proxy": "node dist/examples/proxy-example.js",
+    "example:proxy-api-key-resolver": "node dist/examples/proxy-api-key-resolver-example.js",
+    "example:api-key-resolver": "node dist/examples/api-key-resolver-example.js",
+    "proxy:start": "node dist/examples/proxy-server-start.js"
   },
   "keywords": [
     "llm",