@rethink-ai/core 0.1.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 R-Universe Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,184 @@
+<div align="center">
+
+# ReThink Core SDK
+
+[![NPM Version](https://img.shields.io/npm/v/@rethink-ai/core?style=flat-square&color=blue)](https://www.npmjs.com/package/@rethink-ai/core)
+[![License](https://img.shields.io/badge/license-MIT-green?style=flat-square)](LICENSE)
+[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-3178C6?style=flat-square&logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+[![R-Universe Labs](https://img.shields.io/badge/Author-R--Universe%20Labs-purple?style=flat-square)](https://core.rethink.web.id)
+
+**Official SDK untuk mengakses ReThink Core API dengan mudah dan efisien**
+
+[Bahasa Indonesia](#dokumentasi-bahasa-indonesia) | [English Documentation](#english-documentation)
+
+</div>
+
+---
+
+## Dokumentasi Bahasa Indonesia
+
+**@rethink-ai/core** adalah library client resmi yang dirancang untuk mempermudah integrasi dengan layanan AI dari ReThink Core. Mendukung text generation (streaming & non-streaming) serta image generation
+
+### 📦 Instalasi
+
+Install package menggunakan npm, yarn, atau pnpm:
+
+```bash
+npm install @rethink-ai/core
+```
+
+### 🚀 Penggunaan Dasar
+
+#### 1. Inisialisasi Client
+
+Import dan inisialisasi client. API Key bersifat opsional untuk tier gratis (dengan batasan tertentu)
+
+```typescript
+import { rethink } from '@rethink-ai/core';
+
+const client = new rethink({
+  apiKey: 'YOUR_API_KEY_HERE' 
+});
+```
+
+#### 2. Generate Teks (Chat Completion)
+
+Mendapatkan respons teks sederhana dari model AI
+
+```typescript
+async function contohGenerateTeks() {
+  try {
+    const response = await client.text.generate({
+      model: 'rethink-v1', // atau 'mistral', 'gpt-oss-120b', dll.
+      prompt: 'Jelaskan apa itu nebula'
+    });
+
+    console.log('AI:', response.content);
+    // Output: Nebula adalah...
+  } catch (error) {
+    console.error('Terjadi kesalahan:', error.message);
+  }
+}
+```
+
+#### 3. Streaming Teks (Real-time)
+
+Mendapatkan respons secara bertahap (per kata/chunk) seperti efek mengetik. Sangat disarankan untuk pengalaman pengguna yang lebih baik
+
+```typescript
+async function contohStreaming() {
+  try {
+    const stream = await client.text.generate({
+      model: 'rethink-v1',
+      prompt: 'Buatkan puisi pendek tentang hujan.',
+      stream: true // Aktifkan mode streaming
+    });
+
+    process.stdout.write('AI: ');
+    
+    // Loop async iterator
+    for await (const chunk of stream) {
+      process.stdout.write(chunk);
+    }
+    
+    console.log('\n--- Selesai ---');
+  } catch (error) {
+    console.error('Error streaming:', error.message);
+  }
+}
+```
+
+#### 4. Generate Gambar
+
+Membuat gambar berdasarkan deskripsi teks (prompt)
+
+```typescript
+async function contohGenerateGambar() {
+  try {
+    const response = await client.image.generate({
+      model: 'flux', // Model gambar
+      prompt: 'Buatkan gambar galaksi bima sakti',
+      width: 1024,
+      height: 768
+    });
+
+    console.log('URL Gambar:', response.url);
+  } catch (error) {
+    console.error('Gagal membuat gambar:', error.message);
+  }
+}
+```
+
+### 🛠️ Fitur Utama
+
+- **Type-Safe**: Dibangun dengan TypeScript, memberikan autocompletion dan validasi tipe yang kuat
+- **Convenience Methods**: API yang intuitif (`text.generate`, `image.generate`)
+- **Streaming Support**: Dukungan native untuk Server-Sent Events (SSE) yang mudah digunakan
+- **Multi-Model**: Akses ke berbagai model AI (OpenAI, Mistral, Gemini, Flux, dll) melalui satu interface
+
+---
+
+## English Documentation
+
+**@rethink-ai/core** is the official client library for integrating with ReThink Core AI services. It supports text generation (streaming & non-streaming) and image generation
+
+### 📦 Installation
+
+```bash
+npm install @rethink-ai/core
+```
+
+### 🚀 Basic Usage
+
+#### 1. Client Initialization
+
+```typescript
+import { rethink } from '@rethink-ai/core';
+
+const client = new rethink({
+  apiKey: 'YOUR_API_KEY_HERE'
+});
+```
+
+#### 2. Text Generation
+
+```typescript
+const response = await client.text.generate({
+  model: 'rethink-v1',
+  prompt: 'Explain AI in one sentence.'
+});
+console.log(response.content);
+```
+
+#### 3. Text Streaming
+
+```typescript
+const stream = await client.text.generate({
+  model: 'rethink-v1',
+  prompt: 'Write a haiku about code.',
+  stream: true
+});
+
+for await (const chunk of stream) {
+  process.stdout.write(chunk);
+}
+```
+
+#### 4. Image Generation
+
+```typescript
+const response = await client.image.generate({
+  model: 'flux',
+  prompt: 'Generate an image of milky way',
+  width: 1024,
+  height: 768
+});
+console.log(response.url);
+```
+
+---
+
+<div align="center">
+  <p>Created with ❤️ by <b>R-Universe Labs</b></p>
+  <p>Rio Fernanda © 2026 ReThink AI. All rights reserved</p>
+</div>

package/dist/client.d.ts

@@ -0,0 +1,14 @@
+import { RethinkConfig, TextGenerationRequest, TextGenerationResponse, ImageGenerationRequest, ImageGenerationResponse } from './types';
+export declare class RethinkCoreClient {
+    private apiKey?;
+    private baseUrl;
+    constructor(config?: RethinkConfig);
+    private request;
+    private streamRequest;
+    text: {
+        generate: (request: TextGenerationRequest) => Promise<TextGenerationResponse> | AsyncGenerator<string, void, unknown>;
+    };
+    image: {
+        generate: (request: ImageGenerationRequest) => Promise<ImageGenerationResponse>;
+    };
+}

package/dist/client.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RethinkCoreClient = void 0;
+class RethinkCoreClient {
+    constructor(config = {}) {
+        this.text = {
+            generate: (request) => {
+                let messages = request.messages || [];
+                if (messages.length === 0) {
+                    if (request.system) {
+                        messages.push({ role: 'system', content: request.system });
+                    }
+                    if (request.prompt) {
+                        messages.push({ role: 'user', content: request.prompt });
+                    }
+                }
+                const payload = {
+                    model: request.model,
+                    messages,
+                    stream: request.stream || false,
+                    max_tokens: request.max_tokens,
+                    temperature: request.temperature,
+                    top_p: request.top_p
+                };
+                if (request.stream) {
+                    return this.streamRequest('/v1/chat/completions', payload);
+                }
+                return this.request('/v1/chat/completions', {
+                    method: 'POST',
+                    body: JSON.stringify(payload)
+                }).then(res => {
+                    return {
+                        content: res.choices?.[0]?.message?.content || '',
+                        model: res.model,
+                        usage: res.usage,
+                    };
+                });
+            }
+        };
+        this.image = {
+            generate: async (request) => {
+                return this.request('/api/generate/image', {
+                    method: 'POST',
+                    body: JSON.stringify(request)
+                });
+            }
+        };
+        this.apiKey = config.apiKey;
+        this.baseUrl = config.baseUrl || 'https://core.rethink.web.id';
+    }
+    async request(endpoint, options = {}) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            ...(options.headers || {})
+        };
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        const response = await fetch(url, {
+            ...options,
+            headers
+        });
+        if (!response.ok) {
+            let errorMessage = `Request failed to ${url} with status ${response.status}`;
+            try {
+                const errorBody = await response.json();
+                if (errorBody.error && errorBody.error.message) {
+                    errorMessage += `: ${errorBody.error.message}`;
+                }
+                else if (errorBody.message) {
+                    errorMessage += `: ${errorBody.message}`;
+                }
+            }
+            catch (e) {
+            }
+            throw new Error(errorMessage);
+        }
+        return response.json();
+    }
+    async *streamRequest(endpoint, body) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'text/event-stream'
+        };
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+            let errorMessage = `Stream request failed to ${url} with status ${response.status}`;
+            try {
+                const errorText = await response.text();
+                try {
+                    const errorBody = JSON.parse(errorText);
+                    if (errorBody.error && errorBody.error.message) {
+                        errorMessage += `: ${errorBody.error.message}`;
+                    }
+                    else if (errorBody.message) {
+                        errorMessage += `: ${errorBody.message}`;
+                    }
+                }
+                catch (jsonErr) {
+                    errorMessage += `: ${errorText}`;
+                }
+            }
+            catch (e) {
+            }
+            throw new Error(errorMessage);
+        }
+        if (!response.body) {
+            throw new Error('No response body for stream');
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed.startsWith('data: '))
+                        continue;
+                    const data = trimmed.slice(6);
+                    if (data === '[DONE]')
+                        return;
+                    try {
+                        const parsed = JSON.parse(data);
+                        const delta = parsed.choices?.[0]?.delta?.content;
+                        if (delta) {
+                            yield delta;
+                        }
+                    }
+                    catch (e) {
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}
+exports.RethinkCoreClient = RethinkCoreClient;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { RethinkCoreClient } from './client';
+export * from './types';
+export * from './client';
+export declare const rethink: typeof RethinkCoreClient;

package/dist/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rethink = void 0;
+const client_1 = require("./client");
+__exportStar(require("./types"), exports);
+__exportStar(require("./client"), exports);
+exports.rethink = client_1.RethinkCoreClient;

package/dist/types.d.ts

@@ -0,0 +1,52 @@
+export interface RethinkConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+export interface TextGenerationRequest {
+    model: string;
+    prompt?: string;
+    messages?: ChatMessage[];
+    system?: string;
+    stream?: boolean;
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+}
+export interface TextGenerationResponse {
+    content: string;
+    model: string;
+    ad?: string;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+export interface ImageGenerationRequest {
+    model: string;
+    prompt: string;
+    width?: number;
+    height?: number;
+    seed?: number;
+}
+export interface ImageGenerationResponse {
+    url: string;
+    model: string;
+    width: number;
+    height: number;
+    ad?: string;
+}
+export interface Model {
+    id: string;
+    name: string;
+    modelId: string;
+    apiId: string;
+    type: string;
+    status: string;
+    description?: string;
+    allowedTiers: string[];
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "@rethink-ai/core",
+    "version": "0.1.5",
+    "description": "Official TypeScript SDK for ReThink Core API",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "dev": "tsc --watch",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "rethink",
+        "ai",
+        "sdk",
+        "wrapper"
+    ],
+    "author": "R-Universe Labs",
+    "license": "MIT",
+    "devDependencies": {
+        "typescript": "^5.3.3"
+    },
+    "dependencies": {}
+}

package/src/client.ts

@@ -0,0 +1,175 @@
+import {
+    RethinkConfig,
+    TextGenerationRequest,
+    TextGenerationResponse,
+    ImageGenerationRequest,
+    ImageGenerationResponse,
+    ChatMessage
+} from './types';
+
+export class RethinkCoreClient {
+    private apiKey?: string;
+    private baseUrl: string;
+
+    constructor(config: RethinkConfig = {}) {
+        this.apiKey = config.apiKey;
+        this.baseUrl = config.baseUrl || 'https://core.rethink.web.id';
+    }
+
+    private async request<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
+        const url = `${this.baseUrl}${endpoint}`;
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json',
+            ...((options.headers as Record<string, string>) || {})
+        };
+
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+
+        const response = await fetch(url, {
+            ...options,
+            headers
+        });
+
+        if (!response.ok) {
+            let errorMessage = `Request failed to ${url} with status ${response.status}`;
+            try {
+                const errorBody = await response.json();
+                if (errorBody.error && errorBody.error.message) {
+                    errorMessage += `: ${errorBody.error.message}`;
+                } else if (errorBody.message) {
+                    errorMessage += `: ${errorBody.message}`;
+                }
+            } catch (e) {
+            }
+            throw new Error(errorMessage);
+        }
+
+        return response.json() as Promise<T>;
+    }
+
+    private async *streamRequest(endpoint: string, body: any): AsyncGenerator<string, void, unknown> {
+        const url = `${this.baseUrl}${endpoint}`;
+        const headers: Record<string, string> = {
+            'Content-Type': 'application/json',
+            'Accept': 'text/event-stream'
+        };
+
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body)
+        });
+
+        if (!response.ok) {
+            let errorMessage = `Stream request failed to ${url} with status ${response.status}`;
+            try {
+                const errorText = await response.text();
+                try {
+                    const errorBody = JSON.parse(errorText);
+                    if (errorBody.error && errorBody.error.message) {
+                        errorMessage += `: ${errorBody.error.message}`;
+                    } else if (errorBody.message) {
+                        errorMessage += `: ${errorBody.message}`;
+                    }
+                } catch (jsonErr) {
+                    errorMessage += `: ${errorText}`;
+                }
+            } catch (e) {
+            }
+            throw new Error(errorMessage);
+        }
+
+        if (!response.body) {
+            throw new Error('No response body for stream');
+        }
+
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+
+                buffer += decoder.decode(value, { stream: true });
+
+                const lines = buffer.split('\n\n');
+                buffer = lines.pop() || '';
+
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed.startsWith('data: ')) continue;
+
+                    const data = trimmed.slice(6);
+                    if (data === '[DONE]') return;
+
+                    try {
+                        const parsed = JSON.parse(data);
+                        const delta = parsed.choices?.[0]?.delta?.content;
+                        if (delta) {
+                            yield delta;
+                        }
+                    } catch (e) {
+                    }
+                }
+            }
+        } finally {
+            reader.releaseLock();
+        }
+    }
+
+    public text = {
+        generate: (request: TextGenerationRequest): Promise<TextGenerationResponse> | AsyncGenerator<string, void, unknown> => {
+            let messages: ChatMessage[] = request.messages || [];
+
+            if (messages.length === 0) {
+                if (request.system) {
+                    messages.push({ role: 'system', content: request.system });
+                }
+                if (request.prompt) {
+                    messages.push({ role: 'user', content: request.prompt });
+                }
+            }
+
+            const payload = {
+                model: request.model,
+                messages,
+                stream: request.stream || false,
+                max_tokens: request.max_tokens,
+                temperature: request.temperature,
+                top_p: request.top_p
+            };
+
+            if (request.stream) {
+                return this.streamRequest('/v1/chat/completions', payload);
+            }
+
+            return this.request<any>('/v1/chat/completions', {
+                method: 'POST',
+                body: JSON.stringify(payload)
+            }).then(res => {
+                return {
+                    content: res.choices?.[0]?.message?.content || '',
+                    model: res.model,
+                    usage: res.usage,
+                };
+            });
+        }
+    };
+
+    public image = {
+        generate: async (request: ImageGenerationRequest): Promise<ImageGenerationResponse> => {
+            return this.request<ImageGenerationResponse>('/api/generate/image', {
+                method: 'POST',
+                body: JSON.stringify(request)
+            });
+        }
+    };
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+import { RethinkCoreClient } from './client';
+
+export * from './types';
+export * from './client';
+
+export const rethink = RethinkCoreClient;

package/src/types.ts

@@ -0,0 +1,58 @@
+export interface RethinkConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+
+export interface TextGenerationRequest {
+    model: string;
+    prompt?: string;
+    messages?: ChatMessage[];
+    system?: string;
+    stream?: boolean;
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+}
+
+export interface TextGenerationResponse {
+    content: string;
+    model: string;
+    ad?: string;
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+
+export interface ImageGenerationRequest {
+    model: string;
+    prompt: string;
+    width?: number;
+    height?: number;
+    seed?: number;
+}
+
+export interface ImageGenerationResponse {
+    url: string;
+    model: string;
+    width: number;
+    height: number;
+    ad?: string;
+}
+
+export interface Model {
+    id: string;
+    name: string;
+    modelId: string;
+    apiId: string;
+    type: string;
+    status: string;
+    description?: string;
+    allowedTiers: string[];
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "commonjs",
+        "declaration": true,
+        "outDir": "./dist",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "include": [
+        "src/**/*"
+    ]
+}