@ragion/sdk 0.1.0-alpha.0

package/dist/esm/client.js

@@ -0,0 +1,235 @@
+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());
+    });
+};
+const DEFAULT_CONFIG = {
+    baseUrl: "https://api.ragion.com.br",
+    timeout: 30000,
+    retryAttempts: 3,
+    retryDelay: 1000,
+};
+const generateRequestId = () => {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+};
+const sleep = (ms) => {
+    return new Promise(resolve => setTimeout(resolve, ms));
+};
+const isRetryableError = (status) => {
+    return status >= 500 || status === 429;
+};
+const safeJsonParse = (response) => __awaiter(void 0, void 0, void 0, function* () {
+    const text = yield response.text();
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch (_a) {
+        return null;
+    }
+});
+const buildErrorResponse = (error, requestId, status) => {
+    if (error instanceof Error) {
+        return {
+            data: null,
+            status: status || 0,
+            ok: false,
+            error: {
+                error: "NetworkError",
+                message: error.message,
+                statusCode: status || 0,
+                requestId,
+            },
+            requestId,
+        };
+    }
+    return {
+        data: null,
+        status: status || 500,
+        ok: false,
+        error: {
+            error: "UnknownError",
+            message: "An unknown error occurred",
+            statusCode: status || 500,
+            requestId,
+        },
+        requestId,
+    };
+};
+const combineAbortSignals = (signal1, signal2) => {
+    const combinedController = new AbortController();
+    signal1.addEventListener("abort", () => combinedController.abort());
+    signal2.addEventListener("abort", () => combinedController.abort());
+    return combinedController.signal;
+};
+export class RagionClient {
+    constructor(config) {
+        var _a;
+        this.createHeaders = (customHeaders) => {
+            const headers = Object.assign({ "Content-Type": "application/json", "x-Api-Key": this.config.apiKey }, customHeaders);
+            return headers;
+        };
+        this.getBaseUrl = () => {
+            return this.config.baseUrl;
+        };
+        this.fetchWithTimeout = (url, options, timeout) => __awaiter(this, void 0, void 0, function* () {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            try {
+                const signal = options.signal ? combineAbortSignals(options.signal, controller.signal) : controller.signal;
+                const response = yield fetch(url, Object.assign(Object.assign({}, options), { signal }));
+                clearTimeout(timeoutId);
+                return response;
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                if (error instanceof Error && error.name === "AbortError") {
+                    throw new Error(`Request timeout after ${timeout}ms`);
+                }
+                throw error;
+            }
+        });
+        this.prepareHeaders = (options) => {
+            const isMultipart = options.body instanceof FormData;
+            const headers = {};
+            if (!isMultipart) {
+                Object.assign(headers, this.createHeaders());
+            }
+            else {
+                const authHeaders = this.createHeaders();
+                Object.entries(authHeaders).forEach(([key, value]) => {
+                    if (key.toLowerCase() !== "content-type") {
+                        headers[key] = value;
+                    }
+                });
+            }
+            if (options.headers) {
+                Object.assign(headers, options.headers);
+            }
+            return headers;
+        };
+        this.prepareBody = (body) => {
+            if (!body)
+                return undefined;
+            if (body instanceof FormData) {
+                return body;
+            }
+            return JSON.stringify(body);
+        };
+        this.handleErrorResponse = (response, data, requestId, attempt) => {
+            const errorData = data || {
+                error: "HTTPError",
+                message: response.statusText,
+                statusCode: response.status,
+            };
+            if (response.status < 500 && response.status !== 429) {
+                return {
+                    data: null,
+                    status: response.status,
+                    ok: false,
+                    error: Object.assign(Object.assign({}, errorData), { requestId }),
+                    requestId,
+                };
+            }
+            if (attempt < this.config.retryAttempts && isRetryableError(response.status)) {
+                return null;
+            }
+            return {
+                data: null,
+                status: response.status,
+                ok: false,
+                error: Object.assign(Object.assign({}, errorData), { requestId }),
+                requestId,
+            };
+        };
+        this.request = (endpoint_1, ...args_1) => __awaiter(this, [endpoint_1, ...args_1], void 0, function* (endpoint, options = {}) {
+            var _a;
+            const requestId = generateRequestId();
+            const url = `${this.config.baseUrl}${endpoint}`;
+            const method = options.method || "GET";
+            const timeout = options.timeout || this.config.timeout;
+            const headers = this.prepareHeaders(options);
+            const body = this.prepareBody(options.body);
+            let lastError = null;
+            let lastStatus;
+            for (let attempt = 0; attempt <= this.config.retryAttempts; attempt++) {
+                try {
+                    const response = yield this.fetchWithTimeout(url, {
+                        method,
+                        headers,
+                        body,
+                        signal: options.signal,
+                    }, timeout);
+                    lastStatus = response.status;
+                    const data = yield safeJsonParse(response);
+                    if (!response.ok) {
+                        const errorResponse = this.handleErrorResponse(response, data, requestId, attempt);
+                        if (errorResponse === null) {
+                            yield sleep(this.config.retryDelay * (attempt + 1));
+                            continue;
+                        }
+                        return errorResponse;
+                    }
+                    return {
+                        data: data,
+                        status: response.status,
+                        ok: true,
+                        requestId,
+                    };
+                }
+                catch (error) {
+                    lastError = error instanceof Error ? error : new Error(String(error));
+                    if ((_a = options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+                        return buildErrorResponse(lastError, requestId, 0);
+                    }
+                    if (attempt < this.config.retryAttempts) {
+                        yield sleep(this.config.retryDelay * (attempt + 1));
+                        continue;
+                    }
+                }
+            }
+            return buildErrorResponse(lastError || new Error("Request failed"), requestId, lastStatus);
+        });
+        this.get = (endpoint, options) => __awaiter(this, void 0, void 0, function* () {
+            return this.request(endpoint, Object.assign(Object.assign({}, options), { method: "GET" }));
+        });
+        this.post = (endpoint, body, options) => __awaiter(this, void 0, void 0, function* () {
+            return this.request(endpoint, Object.assign(Object.assign({}, options), { method: "POST", body }));
+        });
+        this.patch = (endpoint, body, options) => __awaiter(this, void 0, void 0, function* () {
+            return this.request(endpoint, Object.assign(Object.assign({}, options), { method: "PATCH", body }));
+        });
+        this.delete = (endpoint, options) => __awaiter(this, void 0, void 0, function* () {
+            return this.request(endpoint, Object.assign(Object.assign({}, options), { method: "DELETE" }));
+        });
+        this.updateConfig = (config) => {
+            if (config.apiKey) {
+                this.config.apiKey = config.apiKey;
+            }
+            if (config.timeout !== undefined) {
+                this.config.timeout = config.timeout;
+            }
+            if (config.retryAttempts !== undefined) {
+                this.config.retryAttempts = config.retryAttempts;
+            }
+            if (config.retryDelay !== undefined) {
+                this.config.retryDelay = config.retryDelay;
+            }
+        };
+        if (!config.apiKey) {
+            throw new Error("API Key is required");
+        }
+        this.config = {
+            apiKey: config.apiKey,
+            baseUrl: DEFAULT_CONFIG.baseUrl,
+            timeout: config.timeout || DEFAULT_CONFIG.timeout,
+            retryAttempts: (_a = config.retryAttempts) !== null && _a !== void 0 ? _a : DEFAULT_CONFIG.retryAttempts,
+            retryDelay: config.retryDelay || DEFAULT_CONFIG.retryDelay,
+        };
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export { ChatModule } from "./chat";
+export { RagionClient } from "./client";
+export { RagionSDK } from "./sdk";
+export { createStreamingRequest, SSEParser } from "./streaming";

package/dist/esm/sdk.js

@@ -0,0 +1,37 @@
+import { ChatModule } from "./chat";
+import { RagionClient } from "./client";
+/**
+ * Main SDK class for interacting with Ragion API
+ * @example
+ * ```typescript
+ * const sdk = new RagionSDK({
+ *   apiKey: 'your-api-key'
+ * });
+ * ```
+ */
+export class RagionSDK {
+    /**
+     * Creates a new instance of RagionSDK
+     * @param config - Configuration object containing API key and optional settings
+     * @param config.apiKey - Your API key for authentication (required)
+     * @param config.timeout - Request timeout in milliseconds (optional, default: 30000)
+     * @param config.retryAttempts - Number of retry attempts for failed requests (optional, default: 3)
+     * @param config.retryDelay - Delay between retries in milliseconds (optional, default: 1000)
+     * @throws {Error} If API key is not provided
+     */
+    constructor(config) {
+        /**
+         * Updates the SDK configuration
+         * @param config - Partial configuration object with properties to update
+         * @example
+         * ```typescript
+         * sdk.updateConfig({ timeout: 60000 });
+         * ```
+         */
+        this.updateConfig = (config) => {
+            this.client.updateConfig(config);
+        };
+        this.client = new RagionClient(config);
+        this.chat = new ChatModule(this.client);
+    }
+}

package/dist/esm/streaming.js

@@ -0,0 +1,143 @@
+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());
+    });
+};
+export 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();
+    }
+}
+export 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();
+        },
+    };
+};

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { ChatModule } from "./chat";
+export { RagionClient } from "./client";
+export { RagionSDK } from "./sdk";
+export { createStreamingRequest, SSEParser } from "./streaming";
+export type { ApiError, ApiResponse, ChatMessage, ChatOptions, RagionConfig, RequestOptions, StreamingController } from "./types";

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSEParser = exports.createStreamingRequest = exports.RagionSDK = exports.RagionClient = exports.ChatModule = void 0;
+var chat_1 = require("./chat");
+Object.defineProperty(exports, "ChatModule", { enumerable: true, get: function () { return chat_1.ChatModule; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "RagionClient", { enumerable: true, get: function () { return client_1.RagionClient; } });
+var sdk_1 = require("./sdk");
+Object.defineProperty(exports, "RagionSDK", { enumerable: true, get: function () { return sdk_1.RagionSDK; } });
+var streaming_1 = require("./streaming");
+Object.defineProperty(exports, "createStreamingRequest", { enumerable: true, get: function () { return streaming_1.createStreamingRequest; } });
+Object.defineProperty(exports, "SSEParser", { enumerable: true, get: function () { return streaming_1.SSEParser; } });

package/dist/sdk.d.ts

@@ -0,0 +1,34 @@
+import { ChatModule } from "./chat";
+import type { RagionConfig } from "./types";
+/**
+ * Main SDK class for interacting with Ragion API
+ * @example
+ * ```typescript
+ * const sdk = new RagionSDK({
+ *   apiKey: 'your-api-key'
+ * });
+ * ```
+ */
+export declare class RagionSDK {
+    readonly chat: ChatModule;
+    private client;
+    /**
+     * Creates a new instance of RagionSDK
+     * @param config - Configuration object containing API key and optional settings
+     * @param config.apiKey - Your API key for authentication (required)
+     * @param config.timeout - Request timeout in milliseconds (optional, default: 30000)
+     * @param config.retryAttempts - Number of retry attempts for failed requests (optional, default: 3)
+     * @param config.retryDelay - Delay between retries in milliseconds (optional, default: 1000)
+     * @throws {Error} If API key is not provided
+     */
+    constructor(config: RagionConfig);
+    /**
+     * Updates the SDK configuration
+     * @param config - Partial configuration object with properties to update
+     * @example
+     * ```typescript
+     * sdk.updateConfig({ timeout: 60000 });
+     * ```
+     */
+    updateConfig: (config: Partial<RagionConfig>) => void;
+}

package/dist/sdk.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RagionSDK = void 0;
+const chat_1 = require("./chat");
+const client_1 = require("./client");
+/**
+ * Main SDK class for interacting with Ragion API
+ * @example
+ * ```typescript
+ * const sdk = new RagionSDK({
+ *   apiKey: 'your-api-key'
+ * });
+ * ```
+ */
+class RagionSDK {
+    /**
+     * Creates a new instance of RagionSDK
+     * @param config - Configuration object containing API key and optional settings
+     * @param config.apiKey - Your API key for authentication (required)
+     * @param config.timeout - Request timeout in milliseconds (optional, default: 30000)
+     * @param config.retryAttempts - Number of retry attempts for failed requests (optional, default: 3)
+     * @param config.retryDelay - Delay between retries in milliseconds (optional, default: 1000)
+     * @throws {Error} If API key is not provided
+     */
+    constructor(config) {
+        /**
+         * Updates the SDK configuration
+         * @param config - Partial configuration object with properties to update
+         * @example
+         * ```typescript
+         * sdk.updateConfig({ timeout: 60000 });
+         * ```
+         */
+        this.updateConfig = (config) => {
+            this.client.updateConfig(config);
+        };
+        this.client = new client_1.RagionClient(config);
+        this.chat = new chat_1.ChatModule(this.client);
+    }
+}
+exports.RagionSDK = RagionSDK;

package/dist/streaming.d.ts

@@ -0,0 +1,28 @@
+export declare class SSEParser {
+    private buffer;
+    private decoder;
+    constructor();
+    processChunk: (chunk: Uint8Array, callbacks: {
+        onData?: (data: string) => void;
+        onError?: (error: Error) => void;
+        onDone?: () => void;
+    }) => void;
+    private processDataLine;
+    processFinal: (callbacks: {
+        onData?: (data: string) => void;
+        onDone?: () => void;
+    }) => void;
+    reset: () => void;
+}
+export declare const createStreamingRequest: (url: string, options: {
+    method?: string;
+    headers?: HeadersInit;
+    body?: unknown;
+    signal?: AbortSignal;
+    timeout?: number;
+    onChunk?: (chunk: string) => void;
+    onComplete?: () => void;
+    onError?: (error: Error) => void;
+}) => {
+    abort: () => void;
+};