@ragion/sdk 0.1.0-alpha.0

package/dist/streaming.js

@@ -0,0 +1,148 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStreamingRequest = exports.SSEParser = void 0;
+class SSEParser {
+    constructor() {
+        this.buffer = "";
+        this.processChunk = (chunk, callbacks) => {
+            var _a;
+            this.buffer += this.decoder.decode(chunk, { stream: true });
+            const lines = this.buffer.split("\n");
+            this.buffer = lines.pop() || "";
+            for (const line of lines) {
+                const trimmedLine = line.trim();
+                if (!trimmedLine)
+                    continue;
+                if (trimmedLine.startsWith("data: ")) {
+                    const data = trimmedLine.slice(6);
+                    if (data === "[DONE]") {
+                        (_a = callbacks.onDone) === null || _a === void 0 ? void 0 : _a.call(callbacks);
+                        return;
+                    }
+                    this.processDataLine(data, callbacks);
+                }
+            }
+        };
+        this.processDataLine = (data, callbacks) => {
+            var _a, _b, _c;
+            try {
+                const parsedData = JSON.parse(data);
+                if (parsedData.type === "error" || parsedData.error) {
+                    const error = new Error(parsedData.message || parsedData.error || "Unknown error occurred");
+                    (_a = callbacks.onError) === null || _a === void 0 ? void 0 : _a.call(callbacks, error);
+                    return;
+                }
+                (_b = callbacks.onData) === null || _b === void 0 ? void 0 : _b.call(callbacks, data);
+            }
+            catch (_d) {
+                (_c = callbacks.onData) === null || _c === void 0 ? void 0 : _c.call(callbacks, data);
+            }
+        };
+        this.processFinal = (callbacks) => {
+            var _a, _b;
+            if (this.buffer.trim()) {
+                const trimmedLine = this.buffer.trim();
+                if (trimmedLine.startsWith("data: ")) {
+                    const data = trimmedLine.slice(6);
+                    if (data !== "[DONE]") {
+                        (_a = callbacks.onData) === null || _a === void 0 ? void 0 : _a.call(callbacks, data);
+                    }
+                }
+            }
+            (_b = callbacks.onDone) === null || _b === void 0 ? void 0 : _b.call(callbacks);
+        };
+        this.reset = () => {
+            this.buffer = "";
+        };
+        this.decoder = new TextDecoder();
+    }
+}
+exports.SSEParser = SSEParser;
+const createStreamingRequest = (url, options) => {
+    const { method = "POST", headers = {}, body, signal, timeout = 30000, onChunk, onComplete, onError } = options;
+    const abortController = new AbortController();
+    const combinedSignal = signal
+        ? (() => {
+            const combined = new AbortController();
+            signal.addEventListener("abort", () => combined.abort());
+            abortController.signal.addEventListener("abort", () => combined.abort());
+            return combined.signal;
+        })()
+        : abortController.signal;
+    const timeoutId = setTimeout(() => {
+        abortController.abort();
+    }, timeout);
+    const parser = new SSEParser();
+    const performStream = () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        try {
+            const requestHeaders = new Headers(headers);
+            requestHeaders.set("Accept", "text/event-stream");
+            const response = yield fetch(url, {
+                method,
+                headers: requestHeaders,
+                body: body ? JSON.stringify(body) : undefined,
+                signal: combinedSignal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = yield response.text().catch(() => "Unknown error");
+                throw new Error(`HTTP ${response.status}: ${response.statusText} - ${errorText}`);
+            }
+            const reader = (_a = response.body) === null || _a === void 0 ? void 0 : _a.getReader();
+            if (!reader) {
+                throw new Error("Response body is not readable");
+            }
+            while (true) {
+                const { done, value } = yield reader.read();
+                if (done) {
+                    parser.processFinal({
+                        onData: onChunk,
+                        onDone: onComplete,
+                    });
+                    break;
+                }
+                parser.processChunk(value, {
+                    onData: onChunk,
+                    onError: error => {
+                        reader.cancel();
+                        onError === null || onError === void 0 ? void 0 : onError(error);
+                    },
+                    onDone: () => {
+                        reader.cancel();
+                        onComplete === null || onComplete === void 0 ? void 0 : onComplete();
+                    },
+                });
+            }
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === "AbortError") {
+                onError === null || onError === void 0 ? void 0 : onError(new Error("Request aborted"));
+            }
+            else if (error instanceof Error) {
+                onError === null || onError === void 0 ? void 0 : onError(error);
+            }
+            else {
+                onError === null || onError === void 0 ? void 0 : onError(new Error(String(error)));
+            }
+        }
+    });
+    performStream();
+    return {
+        abort: () => {
+            clearTimeout(timeoutId);
+            abortController.abort();
+        },
+    };
+};
+exports.createStreamingRequest = createStreamingRequest;

package/dist/types.d.ts

@@ -0,0 +1,45 @@
+export interface RagionConfig {
+    apiKey: string;
+    timeout?: number;
+    retryAttempts?: number;
+    retryDelay?: number;
+}
+export interface RequestOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    signal?: AbortSignal;
+    timeout?: number;
+}
+export interface ApiResponse<T> {
+    data: T | null;
+    status: number;
+    ok: boolean;
+    error?: ApiError;
+    requestId?: string;
+}
+export interface ApiError {
+    error: string;
+    message: string;
+    statusCode: number;
+    requestId?: string;
+    timestamp?: string;
+    details?: unknown;
+}
+export interface ChatMessage {
+    id: string;
+    role: "user" | "assistant";
+    content: string;
+    timestamp: Date;
+}
+export interface ChatOptions {
+    message: string;
+    sessionId?: string;
+    onChunk?: (chunk: string) => void;
+    onComplete?: () => void;
+    onError?: (error: Error) => void;
+    signal?: AbortSignal;
+}
+export interface StreamingController {
+    abort: () => void;
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,51 @@
+{
+	"name": "@ragion/sdk",
+	"version": "0.1.0-alpha.0",
+	"description": "Official Ragion SDK for JavaScript and TypeScript - External integrations with x-Api-Key",
+	"main": "./dist/index.js",
+	"module": "./dist/esm/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/esm/index.js",
+			"require": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "rimraf dist && tsc && tsc --project tsconfig.esm.json",
+		"dev": "tsc --watch",
+		"clean": "rimraf dist"
+	},
+	"keywords": [
+		"ragion",
+		"rag",
+		"ai",
+		"chat",
+		"knowledge-base",
+		"sdk"
+	],
+	"author": "Ragion",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/ragion/ragion-app"
+	},
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"devDependencies": {
+		"@types/node": "^25.0.0",
+		"eslint": "^9.18.0",
+		"eslint-config-prettier": "^10.0.1",
+		"eslint-plugin-prettier": "^5.2.2",
+		"prettier": "^3.4.2",
+		"rimraf": "^5.0.0",
+		"ts-node": "^10.9.2",
+		"typescript": "^5.6.3",
+		"typescript-eslint": "^8.20.0"
+	}
+}