primellm 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,31 +1,47 @@
 /**
- * PrimeLLM JavaScript SDK - Main Client
+ * PrimeLLM JavaScript SDK v0.2.0
  *
- * This is the main SDK file. Developers import this to talk to PrimeLLM
- * from JavaScript or TypeScript.
+ * Production-grade SDK with streaming, retries, and full API parity.
  *
- * Example usage:
+ * @example
+ * import PrimeLLM from "primellm";
  *
- *   import { PrimeLLMClient } from "primellm";
- *
- *   const client = new PrimeLLMClient({ apiKey: "primellm_live_XXX" });
- *
- *   const response = await client.chat({
- *     model: "gpt-5.1",
- *     messages: [{ role: "user", content: "Hello!" }],
- *   });
- *
- *   console.log(response.choices[0].message.content);
+ * const client = new PrimeLLM({ apiKey: "primellm_XXX" });
+ * const response = await client.chat({
+ *   model: "gpt-5.1",
+ *   messages: [{ role: "user", content: "Hello!" }],
+ * });
+ * console.log(response.choices[0].message.content);
  */
-// Re-export types for convenience
+import { PrimeLLMError, createErrorFromStatus, } from "./errors.js";
+import { countTokens, setTokenizerAdapter } from "./tokenizer.js";
+import { streamReader } from "./streaming.js";
+// Re-export types and utilities
 export * from "./types.js";
+export * from "./errors.js";
+export { countTokens, setTokenizerAdapter } from "./tokenizer.js";
+const DEFAULT_RETRY = {
+    maxAttempts: 3,
+    baseDelayMs: 300,
+    maxDelayMs: 10000,
+};
+/**
+ * Retryable status codes
+ */
+const RETRYABLE_STATUSES = [429, 502, 503, 504];
+/**
+ * Sleep with exponential backoff and jitter
+ */
+async function sleep(attempt, config) {
+    const delay = Math.min(config.maxDelayMs, config.baseDelayMs * Math.pow(2, attempt) + Math.random() * 300);
+    await new Promise(resolve => setTimeout(resolve, delay));
+}
 /**
  * PrimeLLM API Client
  *
- * This class handles all communication with the PrimeLLM API.
- * It provides methods for chat, completions, and the legacy generate endpoint.
+ * Production-grade client with streaming, retries, and full API access.
  */
-export class PrimeLLMClient {
+export class PrimeLLM {
     /**
      * Create a new PrimeLLM client.
      *
@@ -33,144 +49,231 @@ export class PrimeLLMClient {
      * @param options.apiKey - Your PrimeLLM API key (required)
      * @param options.baseURL - API base URL (default: "https://api.primellm.in")
      * @param options.timeoutMs - Request timeout in ms (default: 60000)
-     *
-     * @example
-     * const client = new PrimeLLMClient({
-     *   apiKey: "primellm_live_XXX",
-     * });
+     * @param options.maxRetries - Max retry attempts (default: 3)
      */
     constructor(options) {
         if (!options.apiKey) {
-            throw new Error("PrimeLLMClient: apiKey is required");
+            throw new PrimeLLMError("PrimeLLM: apiKey is required");
         }
         this.apiKey = options.apiKey;
         this.baseURL = (options.baseURL ?? "https://api.primellm.in").replace(/\/$/, "");
         this.timeoutMs = options.timeoutMs ?? 60000;
+        this.retry = {
+            ...DEFAULT_RETRY,
+            maxAttempts: options.maxRetries ?? 3,
+        };
+        // Initialize sub-clients
+        this.embeddings = new EmbeddingsClient(this);
+        this.models = new ModelsClient(this);
+        this.keys = new KeysClient(this);
+        this.credits = new CreditsClient(this);
+        this.tokens = new TokensClient();
+        this.chat = new ChatClient(this);
     }
     /**
-     * Internal helper to make API requests.
-     * Handles authentication, JSON parsing, and error handling.
+     * Internal HTTP request with retries and error handling
      */
     async request(path, body, options) {
+        const method = options?.method ?? "POST";
+        let lastError = null;
+        for (let attempt = 0; attempt < this.retry.maxAttempts; attempt++) {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+            try {
+                const fetchOptions = {
+                    method,
+                    headers: {
+                        "Authorization": `Bearer ${this.apiKey}`,
+                        "Content-Type": "application/json",
+                    },
+                    signal: controller.signal,
+                };
+                if (body && method !== "GET") {
+                    fetchOptions.body = JSON.stringify(body);
+                }
+                const res = await fetch(`${this.baseURL}${path}`, fetchOptions);
+                if (!res.ok) {
+                    const text = await res.text().catch(() => "");
+                    let detail = text;
+                    try {
+                        const json = JSON.parse(text);
+                        detail = json.detail || text;
+                    }
+                    catch { }
+                    // Check if retryable
+                    if (RETRYABLE_STATUSES.includes(res.status) && attempt < this.retry.maxAttempts - 1) {
+                        lastError = createErrorFromStatus(res.status, `Request failed: ${res.status}`, detail);
+                        await sleep(attempt, this.retry);
+                        continue;
+                    }
+                    throw createErrorFromStatus(res.status, `PrimeLLM API error: ${res.status}`, detail);
+                }
+                return await res.json();
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                if (error instanceof PrimeLLMError) {
+                    throw error;
+                }
+                if (error instanceof Error && error.name === "AbortError") {
+                    throw new PrimeLLMError(`Request timed out after ${this.timeoutMs}ms`);
+                }
+                // Network error - retry
+                if (attempt < this.retry.maxAttempts - 1) {
+                    lastError = error;
+                    await sleep(attempt, this.retry);
+                    continue;
+                }
+                throw new PrimeLLMError(error.message);
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        }
+        throw lastError || new PrimeLLMError("Request failed after retries");
+    }
+    /**
+     * Internal streaming request
+     */
+    async *streamRequest(path, body) {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
         try {
             const res = await fetch(`${this.baseURL}${path}`, {
-                method: options?.method ?? "POST",
+                method: "POST",
                 headers: {
                     "Authorization": `Bearer ${this.apiKey}`,
                     "Content-Type": "application/json",
                 },
-                body: JSON.stringify(body),
+                body: JSON.stringify({ ...body, stream: true }),
                 signal: controller.signal,
             });
             if (!res.ok) {
                 const text = await res.text().catch(() => "");
-                throw new Error(`PrimeLLM API error: ${res.status} ${res.statusText} - ${text}`);
+                throw createErrorFromStatus(res.status, `Streaming failed: ${res.status}`, text);
             }
-            const json = await res.json();
-            return json;
-        }
-        catch (error) {
-            if (error instanceof Error && error.name === "AbortError") {
-                throw new Error(`PrimeLLM API request timed out after ${this.timeoutMs}ms`);
+            if (!res.body) {
+                throw new PrimeLLMError("Response body is null");
             }
-            throw error;
+            const reader = res.body.getReader();
+            yield* streamReader(reader);
         }
         finally {
             clearTimeout(timeout);
         }
     }
+}
+/**
+ * Chat sub-client
+ */
+class ChatClient {
+    constructor(client) {
+        this.client = client;
+    }
     /**
-     * Send a chat completion request using /v1/chat endpoint.
-     *
-     * This is the recommended method for most use cases.
-     * Returns an OpenAI-compatible response format.
-     *
-     * @param request - The chat request with model and messages
-     * @returns The chat response with choices, usage, and credits
+     * Send a chat completion request
+     */
+    async create(request) {
+        return this.client.request("/v1/chat", request);
+    }
+    /**
+     * Stream chat completion (async iterator)
      *
      * @example
-     * const response = await client.chat({
-     *   model: "gpt-5.1",
-     *   messages: [
-     *     { role: "system", content: "You are a helpful assistant." },
-     *     { role: "user", content: "What is TypeScript?" },
-     *   ],
-     * });
-     * console.log(response.choices[0].message.content);
+     * for await (const chunk of client.chat.stream({...})) {
+     *   console.log(chunk.delta?.content);
+     * }
      */
-    async chat(request) {
-        return this.request("/v1/chat", request);
+    async *stream(request) {
+        yield* this.client.streamRequest("/v1/chat", request);
+    }
+}
+/**
+ * Embeddings sub-client
+ */
+class EmbeddingsClient {
+    constructor(client) {
+        this.client = client;
     }
     /**
-     * Send a chat completion request using /v1/chat/completions endpoint.
-     *
-     * This is an alternative endpoint that also returns OpenAI-compatible format.
-     * Use this if you need compatibility with OpenAI's exact endpoint path.
-     *
-     * @param request - The chat request with model and messages
-     * @returns The chat response with choices, usage, and credits
+     * Create embeddings for input text
      */
-    async completions(request) {
-        return this.request("/v1/chat/completions", request);
+    async create(request) {
+        return this.client.request("/v1/embeddings", request);
+    }
+}
+/**
+ * Models sub-client
+ */
+class ModelsClient {
+    constructor(client) {
+        this.client = client;
     }
     /**
-     * Send a request to the legacy /generate endpoint.
-     *
-     * This endpoint returns a different response format than chat().
-     * Use chat() for new projects; this is for backwards compatibility.
-     *
-     * @param request - The generate request with model and messages
-     * @returns The generate response with reply, tokens_used, cost
-     *
-     * @example
-     * const response = await client.generate({
-     *   model: "gpt-5.1",
-     *   messages: [{ role: "user", content: "Hello!" }],
-     * });
-     * console.log(response.reply);
+     * List available models
      */
-    async generate(request) {
-        return this.request("/generate", request);
+    async list() {
+        return this.client.request("/v1/models", undefined, { method: "GET" });
+    }
+}
+/**
+ * Keys sub-client
+ */
+class KeysClient {
+    constructor(client) {
+        this.client = client;
     }
-    // ============================================================
-    // STREAMING METHODS (Not implemented yet)
-    // ============================================================
     /**
-     * Stream a chat completion response.
-     *
-     * ⚠️ NOT IMPLEMENTED YET - Backend streaming support coming soon.
-     *
-     * @throws Error always - streaming not supported in this version
+     * List API keys
      */
-    async *streamChat(_request) {
-        throw new Error("streamChat is not implemented yet: backend streaming not supported in this SDK version.");
-        // This yield is never reached but satisfies TypeScript
-        yield undefined;
+    async list() {
+        return this.client.request("/v1/keys", undefined, { method: "GET" });
     }
     /**
-     * Stream a completions response.
-     *
-     * ⚠️ NOT IMPLEMENTED YET - Backend streaming support coming soon.
-     *
-     * @throws Error always - streaming not supported in this version
+     * Create a new API key
      */
-    async *streamCompletions(_request) {
-        throw new Error("streamCompletions is not implemented yet: backend streaming not supported in this SDK version.");
-        yield undefined;
+    async create(label) {
+        return this.client.request("/v1/keys", { label });
     }
     /**
-     * Stream a generate response.
-     *
-     * ⚠️ NOT IMPLEMENTED YET - Backend streaming support coming soon.
-     *
-     * @throws Error always - streaming not supported in this version
+     * Revoke an API key
+     */
+    async revoke(keyId) {
+        return this.client.request("/v1/keys/revoke", { key_id: keyId });
+    }
+}
+/**
+ * Credits sub-client
+ */
+class CreditsClient {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get current credit balance
+     */
+    async get() {
+        return this.client.request("/v1/credits", undefined, { method: "GET" });
+    }
+}
+/**
+ * Tokens sub-client (utility)
+ */
+class TokensClient {
+    /**
+     * Count tokens in text or messages
+     */
+    count(input) {
+        return countTokens(input);
+    }
+    /**
+     * Set custom tokenizer adapter
      */
-    async *streamGenerate(_request) {
-        throw new Error("streamGenerate is not implemented yet: backend streaming not supported in this SDK version.");
-        yield undefined;
+    setAdapter(adapter) {
+        setTokenizerAdapter(adapter);
     }
 }
-// Default export for convenience
-export default PrimeLLMClient;
+// Backwards compatibility alias
+export { PrimeLLM as PrimeLLMClient };
+// Default export
+export default PrimeLLM;

package/dist/streaming.d.ts

@@ -0,0 +1,29 @@
+/**
+ * PrimeLLM Streaming Utilities
+ *
+ * Async iterator for streaming chat completions.
+ */
+/**
+ * Chat stream chunk from SSE
+ */
+export interface StreamChunk {
+    id: string;
+    object: string;
+    delta?: {
+        role?: string;
+        content?: string;
+    };
+    done?: boolean;
+    finish_reason?: string;
+}
+/**
+ * Parse SSE data line to chunk object
+ */
+export declare function parseSSELine(line: string): StreamChunk | null;
+/**
+ * Create async iterator from SSE response stream
+ *
+ * @param reader - ReadableStreamDefaultReader from fetch response
+ */
+export declare function streamReader(reader: ReadableStreamDefaultReader<Uint8Array>): AsyncGenerator<StreamChunk, void, unknown>;
+//# sourceMappingURL=streaming.d.ts.map

package/dist/streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.d.ts","sourceRoot":"","sources":["../src/streaming.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE;QACJ,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAe7D;AAED;;;;GAIG;AACH,wBAAuB,YAAY,CAC/B,MAAM,EAAE,2BAA2B,CAAC,UAAU,CAAC,GAChD,cAAc,CAAC,WAAW,EAAE,IAAI,EAAE,OAAO,CAAC,CAyC5C"}

package/dist/streaming.js

@@ -0,0 +1,64 @@
+/**
+ * PrimeLLM Streaming Utilities
+ *
+ * Async iterator for streaming chat completions.
+ */
+/**
+ * Parse SSE data line to chunk object
+ */
+export function parseSSELine(line) {
+    if (!line.startsWith('data:')) {
+        return null;
+    }
+    const data = line.slice(5).trim();
+    if (!data || data === '[DONE]') {
+        return null;
+    }
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Create async iterator from SSE response stream
+ *
+ * @param reader - ReadableStreamDefaultReader from fetch response
+ */
+export async function* streamReader(reader) {
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            // Process complete lines
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || ''; // Keep incomplete line in buffer
+            for (const line of lines) {
+                const chunk = parseSSELine(line);
+                if (chunk) {
+                    yield chunk;
+                    // Check for done
+                    if (chunk.object === 'chat.completion.done' || chunk.done) {
+                        return;
+                    }
+                }
+            }
+        }
+        // Process remaining buffer
+        if (buffer) {
+            const chunk = parseSSELine(buffer);
+            if (chunk) {
+                yield chunk;
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/dist/tokenizer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * PrimeLLM Token Counter
+ *
+ * Simple token estimation using chars/4 approximation.
+ * Provides adapter point for future tiktoken integration.
+ */
+import { Message } from './types.js';
+/**
+ * Token counter adapter function type
+ */
+export type TokenizerAdapter = (text: string) => number;
+/**
+ * Count tokens in text or messages array
+ *
+ * @param input - Text string or array of messages
+ * @returns Estimated token count
+ *
+ * @example
+ * countTokens("Hello world") // ~3
+ * countTokens([{role:"user", content:"Hello"}]) // ~2
+ */
+export declare function countTokens(input: string | Message[]): number;
+/**
+ * Set custom tokenizer adapter (for tiktoken or other)
+ *
+ * @param adapter - Function that takes text and returns token count
+ *
+ * @example
+ * import { encoding_for_model } from 'tiktoken';
+ * const enc = encoding_for_model('gpt-4');
+ * setTokenizerAdapter((text) => enc.encode(text).length);
+ */
+export declare function setTokenizerAdapter(adapter: TokenizerAdapter | null): void;
+/**
+ * Get current tokenizer adapter
+ */
+export declare function getTokenizerAdapter(): TokenizerAdapter | null;
+/**
+ * Reset tokenizer to default (chars/4)
+ */
+export declare function resetTokenizer(): void;
+//# sourceMappingURL=tokenizer.d.ts.map

package/dist/tokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenizer.d.ts","sourceRoot":"","sources":["../src/tokenizer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;AAOxD;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,EAAE,GAAG,MAAM,CAiB7D;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,GAAG,IAAI,CAE1E;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,gBAAgB,GAAG,IAAI,CAE7D;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAErC"}

package/dist/tokenizer.js

@@ -0,0 +1,61 @@
+/**
+ * PrimeLLM Token Counter
+ *
+ * Simple token estimation using chars/4 approximation.
+ * Provides adapter point for future tiktoken integration.
+ */
+/**
+ * Current tokenizer adapter (defaults to simple chars/4)
+ */
+let tokenizerAdapter = null;
+/**
+ * Count tokens in text or messages array
+ *
+ * @param input - Text string or array of messages
+ * @returns Estimated token count
+ *
+ * @example
+ * countTokens("Hello world") // ~3
+ * countTokens([{role:"user", content:"Hello"}]) // ~2
+ */
+export function countTokens(input) {
+    let text;
+    if (Array.isArray(input)) {
+        text = input.map(m => m.content).join(' ');
+    }
+    else {
+        text = input;
+    }
+    // Use custom adapter if set
+    if (tokenizerAdapter) {
+        return tokenizerAdapter(text);
+    }
+    // Default: chars / 4 (simple approximation)
+    const chars = text.length;
+    return Math.max(1, Math.ceil(chars / 4));
+}
+/**
+ * Set custom tokenizer adapter (for tiktoken or other)
+ *
+ * @param adapter - Function that takes text and returns token count
+ *
+ * @example
+ * import { encoding_for_model } from 'tiktoken';
+ * const enc = encoding_for_model('gpt-4');
+ * setTokenizerAdapter((text) => enc.encode(text).length);
+ */
+export function setTokenizerAdapter(adapter) {
+    tokenizerAdapter = adapter;
+}
+/**
+ * Get current tokenizer adapter
+ */
+export function getTokenizerAdapter() {
+    return tokenizerAdapter;
+}
+/**
+ * Reset tokenizer to default (chars/4)
+ */
+export function resetTokenizer() {
+    tokenizerAdapter = null;
+}