@ragion/sdk 0.1.0-alpha.0

package/README.md

@@ -0,0 +1,41 @@
+# @ragion/sdk
+
+SDK oficial do Ragion para JavaScript e TypeScript.
+
+## Instalação
+
+```bash
+npm install @ragion/sdk
+```
+
+## Uso Básico
+
+```typescript
+import { RagionSDK } from '@ragion/sdk'
+
+const ragion = new RagionSDK({
+  apiKey: 'sk_...',
+  organizationId: 'org_123', // Opcional
+})
+
+// Chat com streaming
+ragion.chat.ask({
+  message: 'Hello',
+  onChunk: (chunk) => console.log(chunk),
+})
+```
+
+## API
+
+Veja a [documentação completa](../../README.md) para detalhes da API.
+
+## Build
+
+```bash
+npm run build
+```
+
+Gera:
+- `dist/index.js` (CommonJS)
+- `dist/index.esm.js` (ES Modules)
+- `dist/index.d.ts` (TypeScript definitions)

package/dist/chat.d.ts

@@ -0,0 +1,49 @@
+import type { RagionClient } from "./client";
+import type { ChatOptions, StreamingController } from "./types";
+export declare class ChatModule {
+    private client;
+    constructor(client: RagionClient);
+    private getHeaders;
+    private getBaseUrl;
+    private validateMessage;
+    private buildChatBody;
+    /**
+     * Sends a chat message and streams the response in real-time
+     * @param options - Chat options configuration
+     * @param options.message - The message to send (required)
+     * @param options.sessionId - Session ID for conversation continuity (optional)
+     * @param options.onChunk - Callback function called for each chunk of the response
+     * @param options.onComplete - Callback function called when streaming is complete
+     * @param options.onError - Callback function called if an error occurs
+     * @param options.signal - AbortSignal to cancel the request (optional)
+     * @returns StreamingController object with abort method to cancel the stream
+     * @example
+     * ```typescript
+     * const controller = sdk.chat.ask({
+     *   message: 'What is AI?',
+     *   onChunk: (chunk) => console.log(chunk),
+     *   onComplete: () => console.log('Done'),
+     *   onError: (error) => console.error(error)
+     * });
+     * // To cancel: controller.abort();
+     * ```
+     */
+    ask: (options: ChatOptions) => StreamingController;
+    /**
+     * Sends a chat message and returns the complete response as a Promise
+     * @param options - Chat options configuration (without streaming callbacks)
+     * @param options.message - The message to send (required)
+     * @param options.sessionId - Session ID for conversation continuity (optional)
+     * @param options.signal - AbortSignal to cancel the request (optional)
+     * @returns Promise that resolves with the complete response string
+     * @throws {Error} If the request fails or is aborted
+     * @example
+     * ```typescript
+     * const response = await sdk.chat.askComplete({
+     *   message: 'Explain quantum computing'
+     * });
+     * console.log(response);
+     * ```
+     */
+    askComplete: (options: Omit<ChatOptions, "onChunk" | "onComplete" | "onError">) => Promise<string>;
+}

package/dist/chat.js

@@ -0,0 +1,126 @@
+"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.ChatModule = void 0;
+const streaming_1 = require("./streaming");
+class ChatModule {
+    constructor(client) {
+        this.client = client;
+        this.getHeaders = () => {
+            const headers = this.client.createHeaders();
+            const headersObj = {};
+            Object.entries(headers).forEach(([key, value]) => {
+                headersObj[key] = String(value);
+            });
+            return headersObj;
+        };
+        this.getBaseUrl = () => {
+            return this.client.getBaseUrl();
+        };
+        this.validateMessage = (message) => {
+            return !!message && message.trim().length > 0;
+        };
+        this.buildChatBody = (options) => {
+            const body = {
+                message: options.message.trim(),
+            };
+            if (options.sessionId) {
+                body.sessionId = options.sessionId;
+            }
+            return body;
+        };
+        /**
+         * Sends a chat message and streams the response in real-time
+         * @param options - Chat options configuration
+         * @param options.message - The message to send (required)
+         * @param options.sessionId - Session ID for conversation continuity (optional)
+         * @param options.onChunk - Callback function called for each chunk of the response
+         * @param options.onComplete - Callback function called when streaming is complete
+         * @param options.onError - Callback function called if an error occurs
+         * @param options.signal - AbortSignal to cancel the request (optional)
+         * @returns StreamingController object with abort method to cancel the stream
+         * @example
+         * ```typescript
+         * const controller = sdk.chat.ask({
+         *   message: 'What is AI?',
+         *   onChunk: (chunk) => console.log(chunk),
+         *   onComplete: () => console.log('Done'),
+         *   onError: (error) => console.error(error)
+         * });
+         * // To cancel: controller.abort();
+         * ```
+         */
+        this.ask = (options) => {
+            const { message, sessionId, onChunk, onComplete, onError, signal } = options;
+            if (!this.validateMessage(message)) {
+                const error = new Error("Message is required");
+                onError === null || onError === void 0 ? void 0 : onError(error);
+                return {
+                    abort: () => { },
+                };
+            }
+            const url = `${this.getBaseUrl()}/ai/ask`;
+            const body = this.buildChatBody({ message, sessionId });
+            const controller = (0, streaming_1.createStreamingRequest)(url, {
+                method: "POST",
+                headers: this.getHeaders(),
+                body,
+                signal,
+                timeout: 30000,
+                onChunk: (chunk) => {
+                    onChunk === null || onChunk === void 0 ? void 0 : onChunk(chunk);
+                },
+                onComplete: () => {
+                    onComplete === null || onComplete === void 0 ? void 0 : onComplete();
+                },
+                onError: (error) => {
+                    onError === null || onError === void 0 ? void 0 : onError(error);
+                },
+            });
+            return controller;
+        };
+        /**
+         * Sends a chat message and returns the complete response as a Promise
+         * @param options - Chat options configuration (without streaming callbacks)
+         * @param options.message - The message to send (required)
+         * @param options.sessionId - Session ID for conversation continuity (optional)
+         * @param options.signal - AbortSignal to cancel the request (optional)
+         * @returns Promise that resolves with the complete response string
+         * @throws {Error} If the request fails or is aborted
+         * @example
+         * ```typescript
+         * const response = await sdk.chat.askComplete({
+         *   message: 'Explain quantum computing'
+         * });
+         * console.log(response);
+         * ```
+         */
+        this.askComplete = (options) => __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                let fullResponse = "";
+                const controller = this.ask(Object.assign(Object.assign({}, options), { onChunk: chunk => {
+                        fullResponse += chunk;
+                    }, onComplete: () => {
+                        resolve(fullResponse);
+                    }, onError: error => {
+                        reject(error);
+                    } }));
+                if (options.signal) {
+                    options.signal.addEventListener("abort", () => {
+                        controller.abort();
+                        reject(new Error("Request was aborted"));
+                    });
+                }
+            });
+        });
+    }
+}
+exports.ChatModule = ChatModule;

package/dist/client.d.ts

@@ -0,0 +1,17 @@
+import type { ApiResponse, RagionConfig, RequestOptions } from "./types";
+export declare class RagionClient {
+    private config;
+    constructor(config: RagionConfig);
+    createHeaders: (customHeaders?: Record<string, string>) => HeadersInit;
+    getBaseUrl: () => string;
+    private fetchWithTimeout;
+    private prepareHeaders;
+    private prepareBody;
+    private handleErrorResponse;
+    request: <T>(endpoint: string, options?: RequestOptions) => Promise<ApiResponse<T>>;
+    get: <T>(endpoint: string, options?: Omit<RequestOptions, "method" | "body">) => Promise<ApiResponse<T>>;
+    post: <T>(endpoint: string, body?: unknown, options?: Omit<RequestOptions, "method" | "body">) => Promise<ApiResponse<T>>;
+    patch: <T>(endpoint: string, body?: unknown, options?: Omit<RequestOptions, "method" | "body">) => Promise<ApiResponse<T>>;
+    delete: <T>(endpoint: string, options?: Omit<RequestOptions, "method" | "body">) => Promise<ApiResponse<T>>;
+    updateConfig: (config: Partial<RagionConfig>) => void;
+}

package/dist/client.js

@@ -0,0 +1,239 @@
+"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.RagionClient = void 0;
+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;
+};
+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,
+        };
+    }
+}
+exports.RagionClient = RagionClient;

package/dist/esm/chat.js

@@ -0,0 +1,122 @@
+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());
+    });
+};
+import { createStreamingRequest } from "./streaming";
+export class ChatModule {
+    constructor(client) {
+        this.client = client;
+        this.getHeaders = () => {
+            const headers = this.client.createHeaders();
+            const headersObj = {};
+            Object.entries(headers).forEach(([key, value]) => {
+                headersObj[key] = String(value);
+            });
+            return headersObj;
+        };
+        this.getBaseUrl = () => {
+            return this.client.getBaseUrl();
+        };
+        this.validateMessage = (message) => {
+            return !!message && message.trim().length > 0;
+        };
+        this.buildChatBody = (options) => {
+            const body = {
+                message: options.message.trim(),
+            };
+            if (options.sessionId) {
+                body.sessionId = options.sessionId;
+            }
+            return body;
+        };
+        /**
+         * Sends a chat message and streams the response in real-time
+         * @param options - Chat options configuration
+         * @param options.message - The message to send (required)
+         * @param options.sessionId - Session ID for conversation continuity (optional)
+         * @param options.onChunk - Callback function called for each chunk of the response
+         * @param options.onComplete - Callback function called when streaming is complete
+         * @param options.onError - Callback function called if an error occurs
+         * @param options.signal - AbortSignal to cancel the request (optional)
+         * @returns StreamingController object with abort method to cancel the stream
+         * @example
+         * ```typescript
+         * const controller = sdk.chat.ask({
+         *   message: 'What is AI?',
+         *   onChunk: (chunk) => console.log(chunk),
+         *   onComplete: () => console.log('Done'),
+         *   onError: (error) => console.error(error)
+         * });
+         * // To cancel: controller.abort();
+         * ```
+         */
+        this.ask = (options) => {
+            const { message, sessionId, onChunk, onComplete, onError, signal } = options;
+            if (!this.validateMessage(message)) {
+                const error = new Error("Message is required");
+                onError === null || onError === void 0 ? void 0 : onError(error);
+                return {
+                    abort: () => { },
+                };
+            }
+            const url = `${this.getBaseUrl()}/ai/ask`;
+            const body = this.buildChatBody({ message, sessionId });
+            const controller = createStreamingRequest(url, {
+                method: "POST",
+                headers: this.getHeaders(),
+                body,
+                signal,
+                timeout: 30000,
+                onChunk: (chunk) => {
+                    onChunk === null || onChunk === void 0 ? void 0 : onChunk(chunk);
+                },
+                onComplete: () => {
+                    onComplete === null || onComplete === void 0 ? void 0 : onComplete();
+                },
+                onError: (error) => {
+                    onError === null || onError === void 0 ? void 0 : onError(error);
+                },
+            });
+            return controller;
+        };
+        /**
+         * Sends a chat message and returns the complete response as a Promise
+         * @param options - Chat options configuration (without streaming callbacks)
+         * @param options.message - The message to send (required)
+         * @param options.sessionId - Session ID for conversation continuity (optional)
+         * @param options.signal - AbortSignal to cancel the request (optional)
+         * @returns Promise that resolves with the complete response string
+         * @throws {Error} If the request fails or is aborted
+         * @example
+         * ```typescript
+         * const response = await sdk.chat.askComplete({
+         *   message: 'Explain quantum computing'
+         * });
+         * console.log(response);
+         * ```
+         */
+        this.askComplete = (options) => __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                let fullResponse = "";
+                const controller = this.ask(Object.assign(Object.assign({}, options), { onChunk: chunk => {
+                        fullResponse += chunk;
+                    }, onComplete: () => {
+                        resolve(fullResponse);
+                    }, onError: error => {
+                        reject(error);
+                    } }));
+                if (options.signal) {
+                    options.signal.addEventListener("abort", () => {
+                        controller.abort();
+                        reject(new Error("Request was aborted"));
+                    });
+                }
+            });
+        });
+    }
+}