compress-lightreach 1.0.3 → 1.0.6

package/README.md

@@ -11,10 +11,7 @@ Compress Light Reach is a Node.js/TypeScript SDK that provides intelligent model
 ## Features
 
 - **Intelligent Model Routing**: Automatically selects optimal model based on quality requirements (HLE) and available provider keys
-- **Token-aware Compression**: Replaces repeated substrings with shorter placeholders
-- **Dual Algorithms**: 
-  - Fast greedy (~99% optimal) for daily use
-  - Optimal DP (O(n²)) for critical prompts
+- **Token-aware Compression**: Replaces repeated substrings with shorter placeholders using a fast greedy algorithm
 - **Lossless**: Perfect decompression guaranteed
 - **Output Compression**: Optional model output compression support
 - **Cloud API**: Uses Light Reach's cloud service for compression and routing
@@ -52,7 +49,7 @@ const result = await client.complete({
     { role: 'system', content: 'You are a helpful assistant.' },
     { role: 'user', content: 'Explain quantum computing in simple terms.' },
   ],
-  desired_hle: 30,  // Quality preference (0-40, where 40 is SOTA)
+  desired_hle: 30,  // Quality ceiling (0-100). Current SOTA is ~40%.
 });
 
 console.log(result.decompressed_response);
@@ -60,6 +57,28 @@ console.log(`Selected: ${result.routing_info?.selected_model}`);
 console.log(`Token savings: ${result.compression_stats.token_savings}`);
 ```
 
+## OpenAI-compatible API (Cursor / OpenAI SDKs)
+
+LightReach also exposes a **strict OpenAI-compatible** surface (including streaming SSE) so you can use standard OpenAI tooling without changing your app.
+
+- **Cursor base URL**: `https://compress.lightreach.io/v1/cursor`
+- **Generic OpenAI-compatible base URL**: `https://compress.lightreach.io/v1`
+- **Endpoints**: `GET /models`, `POST /chat/completions`
+- **Model id**: `lightreach`
+
+Example (cURL):
+
+```bash
+curl -sS https://compress.lightreach.io/v1/chat/completions \
+  -H "Authorization: Bearer lr_your_lightreach_key" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "lightreach",
+    "messages": [{"role":"user","content":"Say hello"}],
+    "stream": true
+  }'
+```
+
 ### With Output Compression
 
 ```typescript
@@ -84,7 +103,7 @@ const client = new PcompresslrAPIClient("your-lightreach-api-key");
 // Cross-provider optimization: system picks cheapest model meeting your quality bar
 const result = await client.complete({
   messages: [{ role: 'user', content: 'Explain quantum computing' }],
-  desired_hle: 30,  // Quality preference (0-40, where 40 is SOTA)
+  desired_hle: 30,  // Quality ceiling (0-100). Current SOTA is ~40%.
 });
 
 // Check what was selected
@@ -109,20 +128,16 @@ const result = await client.complete({
 
 ### HLE Cascading with Admin Controls
 
-Admins can set quality **ceilings** via the dashboard (global or per-tag) to control costs. Your `desired_hle` is a preference, but requests will error if they exceed the admin-set ceiling:
+Admins can set quality **ceilings** via the dashboard (global or per-tag) to control costs. Your `desired_hle` is a preference; if it exceeds an admin-set ceiling, the request will **silently clamp** to the ceiling and proceed.
 
 ```typescript
 // Admin set global HLE ceiling to 30%
-// Requesting above the ceiling will error
-try {
-  const result = await client.complete({
-    messages: [{ role: 'user', content: 'Process payment' }],
-    desired_hle: 35,  // ERROR: exceeds ceiling of 30
-    tags: { env: 'production' },
-  });
-} catch (e) {
-  console.error(e.message);  // "Requested HLE 35% exceeds workspace maximum of 30%"
-}
+// Requesting above the ceiling will be clamped to 30 (no error)
+const result = await client.complete({
+  messages: [{ role: 'user', content: 'Process payment' }],
+  desired_hle: 35,  // Will be clamped down to 30
+  tags: { env: 'production' },
+});
 
 // Correct usage: request within ceiling
 const result = await client.complete({
@@ -131,7 +146,7 @@ const result = await client.complete({
   tags: { env: 'production' },
 });
 
-// Check if your HLE was lowered by admin ceiling
+// Check if your HLE was lowered by an admin ceiling
 if (result.routing_info?.hle_clamped) {
   console.log(`HLE lowered from ${result.routing_info.requested_hle} ` +
               `to ${result.routing_info.effective_hle} ` +
@@ -180,7 +195,6 @@ const client = new PcompresslrAPIClient("your-lightreach-api-key");
 const compressed = await client.compress(
   "Your text with repeated content here...",
   "gpt-4",      // Model for tokenization
-  "greedy",     // Algorithm: 'greedy' or 'optimal'
   { env: 'dev' } // Optional tags
 );
 
@@ -200,12 +214,6 @@ export PCOMPRESLR_API_KEY=your-api-key
 
 # Compress a prompt
 npx pcompresslr "Your prompt with repeated text here..."
-
-# Use optimal algorithm only
-npx pcompresslr "Your prompt here" --optimal-only
-
-# Use greedy algorithm only
-npx pcompresslr "Your prompt here" --greedy-only
 ```
 
 ## API Reference
@@ -223,7 +231,7 @@ new PcompresslrAPIClient(apiKey?: string, apiUrl?: string, timeout?: number)
 **Parameters:**
 - `apiKey` (string, optional): LightReach API key. Falls back to `LIGHTREACH_API_KEY` or `PCOMPRESLR_API_KEY` env vars.
 - `apiUrl` (string, optional): Override base API URL. Falls back to `PCOMPRESLR_API_URL` env var. Default: `https://api.compress.lightreach.io`
-- `timeout` (number, optional): Request timeout in milliseconds. Default: `120000` (2 minutes)
+- `timeout` (number, optional): Request timeout in milliseconds. Default: `900000` (15 minutes)
 
 #### Methods
 
@@ -237,10 +245,9 @@ Messages-first completion with intelligent routing (POST `/api/v2/complete`).
 |-----------|------|---------|-------------|
 | `messages` | `Message[]` | required | Conversation history with `role` and `content` |
 | `llm_provider` | `'openai' \| 'anthropic' \| 'google' \| 'deepseek' \| 'moonshot'` | — | Optional provider constraint. Omit for cross-provider optimization |
-| `desired_hle` | `number` | — | Quality preference (0-40, where 40 is SOTA). Must not exceed admin ceilings |
+| `desired_hle` | `number` | — | Quality ceiling (0-100). If above an admin ceiling, it is clamped down |
 | `compress` | `boolean` | `true` | Whether to compress messages |
 | `compress_output` | `boolean` | `false` | Whether to request compressed output from LLM |
-| `algorithm` | `'greedy' \| 'optimal'` | `'greedy'` | Compression algorithm |
 | `compression_config` | `object` | — | Per-role compression settings (see below) |
 | `temperature` | `number` | — | LLM temperature parameter |
 | `max_tokens` | `number` | — | Maximum tokens to generate |
@@ -264,19 +271,23 @@ Messages-first completion with intelligent routing (POST `/api/v2/complete`).
 {
   decompressed_response: string;     // Final decompressed LLM response
   compression_stats: {
-    original_size_chars: number;
-    compressed_size_chars: number;
+    compression_enabled: boolean;
     original_tokens: number;
     compressed_tokens: number;
-    compression_ratio: number;
     token_savings: number;
-    token_savings_percent: number;
+    compression_ratio: number;
+    token_count_exact?: boolean;
+    token_count_source?: string;
+    token_accounting_note?: string;
     processing_time_ms?: number;
   };
   llm_stats: {
-    prompt_tokens: number;
-    completion_tokens: number;
+    provider?: string;
+    model?: string;
+    input_tokens: number;
+    output_tokens: number;
     total_tokens: number;
+    finish_reason?: string | null;
   };
   routing_info?: {
     selected_model: string;          // Model chosen by system
@@ -299,14 +310,16 @@ Messages-first completion with intelligent routing (POST `/api/v2/complete`).
 }
 ```
 
-##### `compress(prompt, model?, algorithm?, tags?): Promise<CompressResponse>`
+##### `compress(prompt, model?, tags?): Promise<CompressResponse>`
+
+Also supports a legacy call shape: `compress(prompt, model, algorithm, tags?)` (only `"greedy"` is supported).
 
 Compression-only (POST `/api/v1/compress`).
 
 **Parameters:**
 - `prompt` (string, required): Text to compress
 - `model` (string, optional): Model for tokenization. Default: `'gpt-4'`
-- `algorithm` (`'greedy' | 'optimal'`, optional): Compression algorithm. Default: `'greedy'`
+- `algorithm` (`"greedy"`, optional): Legacy-only parameter. Only `"greedy"` is supported.
 - `tags` (`Record<string, string>`, optional): Tags for attribution
 
 **Response (`CompressResponse`):**

package/dist/api-client.d.ts

@@ -30,19 +30,23 @@ export interface DecompressResponse {
 export interface CompleteResponse {
     decompressed_response: string;
     compression_stats: {
-        original_size_chars: number;
-        compressed_size_chars: number;
+        compression_enabled: boolean;
         original_tokens: number;
         compressed_tokens: number;
-        compression_ratio: number;
         token_savings: number;
-        token_savings_percent: number;
+        compression_ratio: number;
+        token_count_exact?: boolean;
+        token_count_source?: string;
+        token_accounting_note?: string;
         processing_time_ms?: number;
     };
     llm_stats: {
-        prompt_tokens: number;
-        completion_tokens: number;
+        provider?: string;
+        model?: string;
+        input_tokens: number;
+        output_tokens: number;
         total_tokens: number;
+        finish_reason?: string | null;
     };
     warnings?: string[];
     routing_info?: {
@@ -80,7 +84,7 @@ export interface CompleteV2Request {
         compress_only_last_n_user?: number | null;
     };
     compress_output?: boolean;
-    algorithm?: 'greedy' | 'optimal';
+    algorithm?: 'greedy';
     temperature?: number;
     max_tokens?: number;
     tags?: Record<string, string>;
@@ -95,6 +99,23 @@ export interface HealthCheckResponse {
     status: string;
     version?: string;
 }
+export type CompleteJobStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'canceled';
+export interface CompleteJobCreateResponse {
+    job_id: string;
+    status: CompleteJobStatus;
+    status_url: string;
+}
+export interface CompleteJobStatusResponse {
+    job_id: string;
+    status: CompleteJobStatus;
+    phase?: string | null;
+    progress?: number | null;
+    created_at?: string | null;
+    started_at?: string | null;
+    finished_at?: string | null;
+    result?: any;
+    error?: any;
+}
 export declare class PcompresslrAPIClient {
     private readonly DEFAULT_API_URL;
     private apiKey;
@@ -103,9 +124,42 @@ export declare class PcompresslrAPIClient {
     private session;
     constructor(apiKey?: string, apiUrl?: string, timeout?: number);
     private makeRequest;
-    compress(prompt: string, model?: string, algorithm?: "greedy" | "optimal", tags?: Record<string, string>): Promise<CompressResponse>;
+    /**
+     * Create async /complete job (POST /api/v1/complete/jobs).
+     */
+    createCompleteJob(request: CompleteV2Request, opts?: {
+        idempotencyKey?: string;
+    }): Promise<CompleteJobCreateResponse>;
+    /**
+     * Poll async /complete job (GET /api/v1/complete/jobs/{job_id}).
+     */
+    getCompleteJob(jobId: string): Promise<CompleteJobStatusResponse>;
+    /**
+     * Production-safe complete: enqueue + poll async job endpoints.
+     */
+    completeAsync(request: CompleteV2Request, opts?: {
+        pollIntervalMs?: number;
+        maxWaitMs?: number;
+        idempotencyKey?: string;
+    }): Promise<CompleteResponse>;
+    /**
+     * Compress text without making an LLM call (POST /api/v1/compress).
+     *
+     * Supported call shapes:
+     * - compress(prompt, model?, tags?)
+     * - compress(prompt, model, algorithm, tags?)  (back-compat; only "greedy" is supported)
+     */
+    compress(prompt: string, model?: string, tags?: Record<string, string>): Promise<CompressResponse>;
+    compress(prompt: string, model: string, algorithm: 'greedy', tags?: Record<string, string>): Promise<CompressResponse>;
     decompress(llmFormat: string): Promise<DecompressResponse>;
     healthCheck(): Promise<HealthCheckResponse>;
+    /**
+     * Direct (non-job) complete call (POST /api/v2/complete).
+     *
+     * This hits the synchronous endpoint and is best-effort for small/interactive usage.
+     * For production reliability, prefer `complete()` (async job + polling).
+     */
+    completeSync(request: CompleteV2Request): Promise<CompleteResponse>;
     /**
      * Messages-first complete with intelligent model selection (POST /api/v2/complete).
      *

package/dist/api-client.js

@@ -42,7 +42,7 @@ class APIRequestError extends PcompresslrAPIError {
 }
 exports.APIRequestError = APIRequestError;
 class PcompresslrAPIClient {
-    constructor(apiKey, apiUrl, timeout = 120000 // 2 minutes - complete() calls LLM which can take 30+ seconds
+    constructor(apiKey, apiUrl, timeout = 900000 // 15 minutes - complete() can include long upstream LLM calls
     ) {
         this.DEFAULT_API_URL = "https://api.compress.lightreach.io";
         // Get API key from parameter or environment
@@ -89,7 +89,7 @@ class PcompresslrAPIClient {
             return Promise.reject(error);
         });
     }
-    async makeRequest(endpoint, data, method = 'POST') {
+    async makeRequest(endpoint, data, method = 'POST', opts) {
         const url = `${this.apiUrl}${endpoint}`;
         try {
             const response = await this.session.request({
@@ -97,6 +97,8 @@ class PcompresslrAPIClient {
                 url: endpoint,
                 data: method === 'POST' ? data : undefined,
                 params: method === 'GET' ? data : undefined,
+                headers: opts?.headers,
+                timeout: opts?.timeoutMs,
             });
             return response.data;
         }
@@ -139,15 +141,87 @@ class PcompresslrAPIClient {
             throw new APIRequestError(`Request failed: ${errorMessage}`);
         }
     }
-    async compress(prompt, model = "gpt-4", algorithm = "greedy", tags) {
+    /**
+     * Create async /complete job (POST /api/v1/complete/jobs).
+     */
+    async createCompleteJob(request, opts) {
         const data = {
-            prompt,
-            model,
-            algorithm
+            messages: request.messages,
+            compress: request.compress ?? true,
+            compress_output: request.compress_output ?? false,
+            algorithm: request.algorithm ?? 'greedy',
         };
-        if (tags) {
-            data.tags = tags;
+        if (request.llm_provider !== undefined)
+            data.llm_provider = request.llm_provider;
+        if (request.desired_hle !== undefined)
+            data.desired_hle = request.desired_hle;
+        if (request.compression_config)
+            data.compression_config = request.compression_config;
+        if (request.temperature !== undefined)
+            data.temperature = request.temperature;
+        if (request.max_tokens !== undefined)
+            data.max_tokens = request.max_tokens;
+        if (request.tags !== undefined)
+            data.tags = request.tags;
+        if (request.max_history_messages !== undefined)
+            data.max_history_messages = request.max_history_messages;
+        const headers = {};
+        if (opts?.idempotencyKey)
+            headers['Idempotency-Key'] = opts.idempotencyKey;
+        return this.makeRequest('/api/v1/complete/jobs', data, 'POST', { headers });
+    }
+    /**
+     * Poll async /complete job (GET /api/v1/complete/jobs/{job_id}).
+     */
+    async getCompleteJob(jobId) {
+        if (!jobId)
+            throw new APIRequestError('jobId is required');
+        // Keep polls short even if overall client timeout is high.
+        return this.makeRequest(`/api/v1/complete/jobs/${jobId}`, {}, 'GET', { timeoutMs: Math.min(this.timeout, 30000) });
+    }
+    /**
+     * Production-safe complete: enqueue + poll async job endpoints.
+     */
+    async completeAsync(request, opts) {
+        const job = await this.createCompleteJob(request, { idempotencyKey: opts?.idempotencyKey });
+        const jobId = job.job_id;
+        const pollIntervalMs = Math.max(200, opts?.pollIntervalMs ?? 1000);
+        const maxWaitMs = opts?.maxWaitMs ?? this.timeout;
+        const deadline = Date.now() + maxWaitMs;
+        let interval = pollIntervalMs;
+        while (true) {
+            const st = await this.getCompleteJob(jobId);
+            if (st.status === 'succeeded') {
+                if (st.result)
+                    return st.result;
+                throw new APIRequestError('Async job succeeded but result was missing.');
+            }
+            if (st.status === 'failed' || st.status === 'canceled') {
+                throw new APIRequestError(`Async complete job ${st.status}: ${JSON.stringify(st.error ?? {})}`);
+            }
+            if (Date.now() > deadline) {
+                throw new APIRequestError(`Async complete job timed out after ${maxWaitMs}ms (status=${st.status}).`);
+            }
+            await new Promise((r) => setTimeout(r, interval));
+            interval = Math.min(Math.floor(interval * 1.2), 2000);
+        }
+    }
+    async compress(prompt, model = "gpt-4", algorithmOrTags, maybeTags) {
+        let algorithm = 'greedy';
+        let tags;
+        if (typeof algorithmOrTags === 'string') {
+            if (algorithmOrTags !== 'greedy') {
+                throw new APIRequestError(`Invalid algorithm "${algorithmOrTags}". Only "greedy" is supported.`);
+            }
+            algorithm = 'greedy';
+            tags = maybeTags;
+        }
+        else if (algorithmOrTags && typeof algorithmOrTags === 'object') {
+            tags = algorithmOrTags;
         }
+        const data = { prompt, model, algorithm };
+        if (tags)
+            data.tags = tags;
         return this.makeRequest("/api/v1/compress", data);
     }
     async decompress(llmFormat) {
@@ -172,6 +246,47 @@ class PcompresslrAPIClient {
             throw new APIRequestError(`Health check failed: ${errorMessage}`);
         }
     }
+    /**
+     * Direct (non-job) complete call (POST /api/v2/complete).
+     *
+     * This hits the synchronous endpoint and is best-effort for small/interactive usage.
+     * For production reliability, prefer `complete()` (async job + polling).
+     */
+    async completeSync(request) {
+        const data = {
+            messages: request.messages,
+            compress: request.compress ?? true,
+            compress_output: request.compress_output ?? false,
+            algorithm: request.algorithm ?? 'greedy',
+        };
+        // v1.0.0 parameters
+        if (request.llm_provider !== undefined)
+            data.llm_provider = request.llm_provider;
+        if (request.desired_hle !== undefined)
+            data.desired_hle = request.desired_hle;
+        if (request.compression_config)
+            data.compression_config = request.compression_config;
+        if (request.temperature !== undefined)
+            data.temperature = request.temperature;
+        if (request.max_tokens !== undefined)
+            data.max_tokens = request.max_tokens;
+        if (request.tags !== undefined)
+            data.tags = request.tags;
+        if (request.max_history_messages !== undefined)
+            data.max_history_messages = request.max_history_messages;
+        // Deprecated / backward compatible parameters (still accepted by some deployments)
+        if (request.model !== undefined)
+            data.model = request.model;
+        if (request.hle_target_percent !== undefined)
+            data.hle_target_percent = request.hle_target_percent;
+        if (request.min_hle_score !== undefined)
+            data.min_hle_score = request.min_hle_score;
+        if (request.auto_select_by_hle !== undefined)
+            data.auto_select_by_hle = request.auto_select_by_hle;
+        if (request.same_provider_only !== undefined)
+            data.same_provider_only = request.same_provider_only;
+        return this.makeRequest('/api/v2/complete', data, 'POST');
+    }
     /**
      * Messages-first complete with intelligent model selection (POST /api/v2/complete).
      *
@@ -213,28 +328,9 @@ class PcompresslrAPIClient {
             console.warn('[compress-lightreach v1.0.0] HLE parameters have changed. ' +
                 'Use "desired_hle" and optional "llm_provider" instead.');
         }
-        const data = {
-            messages: request.messages,
-            compress: request.compress ?? true,
-            compress_output: request.compress_output ?? false,
-            algorithm: request.algorithm ?? 'greedy',
-        };
-        // v1.0.0 parameters
-        if (request.llm_provider !== undefined)
-            data.llm_provider = request.llm_provider;
-        if (request.desired_hle !== undefined)
-            data.desired_hle = request.desired_hle;
-        if (request.compression_config)
-            data.compression_config = request.compression_config;
-        if (request.temperature !== undefined)
-            data.temperature = request.temperature;
-        if (request.max_tokens !== undefined)
-            data.max_tokens = request.max_tokens;
-        if (request.tags !== undefined)
-            data.tags = request.tags;
-        if (request.max_history_messages !== undefined)
-            data.max_history_messages = request.max_history_messages;
-        return this.makeRequest("/api/v2/complete", data);
+        // Prefer async jobs for production reliability; sync remains available via /api/v2/complete
+        // by calling makeRequest directly if needed.
+        return this.completeAsync(request);
     }
 }
 exports.PcompresslrAPIClient = PcompresslrAPIClient;

package/dist/cli.js

@@ -8,29 +8,17 @@ const api_client_1 = require("./api-client");
 async function main() {
     const args = process.argv.slice(2);
     if (args.length === 0) {
-        console.log("Usage: pcompresslr <prompt> [--greedy-only|--optimal-only]");
+        console.log("Usage: pcompresslr <prompt>");
         console.log("\nExample:");
         console.log('  pcompresslr "hello world hello world hello world"');
-        console.log('  pcompresslr "your prompt here" --greedy-only  # Only greedy');
-        console.log('  pcompresslr "your prompt here" --optimal-only  # Only optimal');
         console.log("\nNote: Requires PCOMPRESLR_API_KEY environment variable");
         process.exit(0);
     }
-    let prompt = args.join(" ");
-    let showGreedy = true;
-    let showOptimal = true;
-    if (prompt.endsWith("--greedy-only")) {
-        prompt = args.slice(0, -1).join(" ");
-        showOptimal = false;
-    }
-    else if (prompt.endsWith("--optimal-only")) {
-        prompt = args.slice(0, -1).join(" ");
-        showGreedy = false;
-    }
+    const prompt = args.join(" ");
     // Get API key from environment
     const apiKey = process.env.PCOMPRESLR_API_KEY;
     if (!apiKey) {
-        console.error("❌ Error: PCOMPRESLR_API_KEY environment variable is required.");
+        console.error("Error: PCOMPRESLR_API_KEY environment variable is required.");
         console.error("\nTo get an API key, visit https://compress.lightreach.io");
         console.error("Then set it with: export PCOMPRESLR_API_KEY=your-key-here");
         process.exit(1);
@@ -42,7 +30,7 @@ async function main() {
     }
     catch (error) {
         if (error instanceof api_client_1.APIKeyError) {
-            console.error(`❌ Error: ${error.message}`);
+            console.error(`Error: ${error.message}`);
             process.exit(1);
         }
         throw error;
@@ -50,116 +38,38 @@ async function main() {
     console.log(`Original prompt: ${JSON.stringify(prompt)}`);
     console.log(`Length: ${prompt.length} characters\n`);
     console.log("=".repeat(80));
-    // Run both compressors and compare
-    const results = {};
-    if (showGreedy) {
-        console.log("\n🔹 GREEDY COMPRESSOR (Fast, ~99% optimal)");
-        console.log("-".repeat(80));
-        try {
-            const resultGreedy = await client.compress(prompt, "gpt-4", "greedy");
-            const compressedGreedy = resultGreedy.compressed;
-            const dictGreedy = resultGreedy.dictionary;
-            const ratioGreedy = resultGreedy.compression_ratio;
-            const llmFormatGreedy = resultGreedy.llm_format;
-            // Verify decompression
-            const decompressResult = await client.decompress(llmFormatGreedy);
-            const decompressedGreedy = decompressResult.decompressed;
-            results['greedy'] = {
-                compressed: compressedGreedy,
-                dict: dictGreedy,
-                ratio: ratioGreedy,
-                llm_format: llmFormatGreedy,
-                decompressed: decompressedGreedy
-            };
-            console.log(`Compressed: ${JSON.stringify(compressedGreedy)}`);
-            console.log(`Dictionary: ${JSON.stringify(dictGreedy)}`);
-            console.log(`Compression ratio: ${(ratioGreedy * 100).toFixed(2)}%`);
-            console.log(`LLM-ready format length: ${llmFormatGreedy.length} chars`);
-            console.log(`Processing time: ${resultGreedy.processing_time_ms.toFixed(2)}ms`);
-            if (decompressedGreedy === prompt) {
-                console.log("✅ Decompression verified");
-            }
-            else {
-                console.log("❌ Decompression failed");
-            }
-        }
-        catch (error) {
-            if (error instanceof api_client_1.RateLimitError) {
-                console.error(`❌ Rate limit exceeded: ${error.message}`);
-            }
-            else if (error instanceof api_client_1.APIRequestError) {
-                console.error(`❌ API error: ${error.message}`);
-            }
-            else {
-                throw error;
-            }
-        }
-    }
-    if (showOptimal) {
-        console.log("\n🔸 OPTIMAL COMPRESSOR (DP, O(n²), globally optimal)");
-        console.log("-".repeat(80));
-        try {
-            const resultOptimal = await client.compress(prompt, "gpt-4", "optimal");
-            const compressedOptimal = resultOptimal.compressed;
-            const dictOptimal = resultOptimal.dictionary;
-            const ratioOptimal = resultOptimal.compression_ratio;
-            const llmFormatOptimal = resultOptimal.llm_format;
-            // Verify decompression
-            const decompressResult = await client.decompress(llmFormatOptimal);
-            const decompressedOptimal = decompressResult.decompressed;
-            results['optimal'] = {
-                compressed: compressedOptimal,
-                dict: dictOptimal,
-                ratio: ratioOptimal,
-                llm_format: llmFormatOptimal,
-                decompressed: decompressedOptimal
-            };
-            console.log(`Compressed: ${JSON.stringify(compressedOptimal)}`);
-            console.log(`Dictionary: ${JSON.stringify(dictOptimal)}`);
-            console.log(`Compression ratio: ${(ratioOptimal * 100).toFixed(2)}%`);
-            console.log(`LLM-ready format length: ${llmFormatOptimal.length} chars`);
-            console.log(`Processing time: ${resultOptimal.processing_time_ms.toFixed(2)}ms`);
-            if (decompressedOptimal === prompt) {
-                console.log("✅ Decompression verified");
-            }
-            else {
-                console.log("❌ Decompression failed");
-            }
+    console.log("\nGREEDY COMPRESSOR");
+    console.log("-".repeat(80));
+    try {
+        const result = await client.compress(prompt, "gpt-4");
+        const compressed = result.compressed;
+        const dictionary = result.dictionary;
+        const ratio = result.compression_ratio;
+        const llmFormat = result.llm_format;
+        // Verify decompression
+        const decompressResult = await client.decompress(llmFormat);
+        const decompressed = decompressResult.decompressed;
+        console.log(`Compressed: ${JSON.stringify(compressed)}`);
+        console.log(`Dictionary: ${JSON.stringify(dictionary)}`);
+        console.log(`Compression ratio: ${(ratio * 100).toFixed(2)}%`);
+        console.log(`LLM-ready format length: ${llmFormat.length} chars`);
+        console.log(`Processing time: ${result.processing_time_ms.toFixed(2)}ms`);
+        if (decompressed === prompt) {
+            console.log("Decompression verified");
         }
-        catch (error) {
-            if (error instanceof api_client_1.RateLimitError) {
-                console.error(`❌ Rate limit exceeded: ${error.message}`);
-            }
-            else if (error instanceof api_client_1.APIRequestError) {
-                console.error(`❌ API error: ${error.message}`);
-            }
-            else {
-                throw error;
-            }
+        else {
+            console.log("Decompression failed");
         }
     }
-    // Comparison if both were run
-    if (showGreedy && showOptimal && results['greedy'] && results['optimal']) {
-        console.log("\n" + "=".repeat(80));
-        console.log("📊 COMPARISON");
-        console.log("-".repeat(80));
-        const ratioDiff = results['optimal'].ratio - results['greedy'].ratio;
-        if (ratioDiff < 0) {
-            console.log(`✅ Optimal is ${Math.abs(ratioDiff * 100).toFixed(2)}% better (smaller ratio)`);
+    catch (error) {
+        if (error instanceof api_client_1.RateLimitError) {
+            console.error(`Rate limit exceeded: ${error.message}`);
         }
-        else if (ratioDiff > 0) {
-            console.log(`✅ Greedy is ${(ratioDiff * 100).toFixed(2)}% better (smaller ratio)`);
+        else if (error instanceof api_client_1.APIRequestError) {
+            console.error(`API error: ${error.message}`);
         }
         else {
-            console.log("✅ Both produce identical compression ratios");
-        }
-        console.log(`\nGreedy ratio: ${(results['greedy'].ratio * 100).toFixed(2)}%`);
-        console.log(`Optimal ratio: ${(results['optimal'].ratio * 100).toFixed(2)}%`);
-        console.log(`Difference: ${(ratioDiff * 100).toFixed(2)}%`);
-        const greedyDictSize = Object.keys(results['greedy'].dict).length;
-        const optimalDictSize = Object.keys(results['optimal'].dict).length;
-        if (greedyDictSize !== optimalDictSize) {
-            console.log(`\nDictionary size: Greedy=${greedyDictSize}, Optimal=${optimalDictSize}`);
+            throw error;
         }
     }
 }

package/dist/core.d.ts

@@ -19,10 +19,11 @@ export interface CompleteOptions {
     messages: Message[];
     model?: string;
     provider?: 'openai' | 'anthropic' | 'google';
+    desiredHle?: number;
     compress?: boolean;
     compressionConfig?: CompressionConfig;
     compressOutput?: boolean;
-    useOptimal?: boolean;
+    mode?: 'async' | 'sync';
     hleTargetPercent?: number;
     minHleScore?: number;
     autoSelectByHle?: boolean;
@@ -36,13 +37,11 @@ export declare class LightReach {
     private apiClient;
     private defaultModel;
     private defaultProvider;
-    private useOptimal;
     constructor(options?: {
         apiKey?: string;
         apiUrl?: string;
         defaultModel?: string;
         defaultProvider?: 'openai' | 'anthropic' | 'google';
-        useOptimal?: boolean;
     });
     complete(options: CompleteOptions): Promise<CompleteResponse>;
     /**
@@ -50,7 +49,6 @@ export declare class LightReach {
      */
     compress(text: string, options?: {
         model?: string;
-        algorithm?: 'greedy' | 'optimal';
         tags?: Record<string, string>;
     }): Promise<CompressResponse>;
 }

package/dist/core.js

@@ -13,11 +13,9 @@ class LightReach {
     constructor(options = {}) {
         this.defaultModel = options.defaultModel ?? 'gpt-4';
         this.defaultProvider = options.defaultProvider ?? 'openai';
-        this.useOptimal = options.useOptimal ?? false;
         this.apiClient = new api_client_1.PcompresslrAPIClient(options.apiKey, options.apiUrl);
     }
     async complete(options) {
-        const algorithm = (options.useOptimal ?? this.useOptimal) ? 'optimal' : 'greedy';
         const cfg = options.compressionConfig
             ? {
                 compress_system: options.compressionConfig.compressSystem ?? false,
@@ -27,14 +25,13 @@ class LightReach {
             }
             : undefined;
         try {
-            const resp = await this.apiClient.complete({
+            const req = {
                 messages: options.messages,
-                model: options.model ?? this.defaultModel,
                 llm_provider: options.provider ?? this.defaultProvider,
+                desired_hle: options.desiredHle,
                 compress: options.compress ?? true,
                 compression_config: cfg,
                 compress_output: options.compressOutput ?? false,
-                algorithm,
                 hle_target_percent: options.hleTargetPercent,
                 min_hle_score: options.minHleScore,
                 auto_select_by_hle: options.autoSelectByHle,
@@ -43,7 +40,13 @@ class LightReach {
                 max_tokens: options.maxTokens,
                 tags: options.tags,
                 max_history_messages: options.maxHistoryMessages,
-            });
+            };
+            // Only include deprecated `model` if explicitly provided to avoid noisy warnings.
+            if (options.model !== undefined)
+                req.model = options.model;
+            const resp = (options.mode ?? 'async') === 'sync'
+                ? await this.apiClient.completeSync(req)
+                : await this.apiClient.complete(req);
             // Add helpful aliases to better match the Feature 0.6 spec without changing backend response.
             // We do NOT fabricate cost estimates here since the API response does not include pricing data.
             return {
@@ -79,7 +82,7 @@ class LightReach {
      * Compress text without making an LLM call (POST /api/v1/compress).
      */
     async compress(text, options) {
-        return await this.apiClient.compress(text, options?.model ?? this.defaultModel, options?.algorithm ?? 'greedy', options?.tags);
+        return await this.apiClient.compress(text, options?.model ?? this.defaultModel, options?.tags);
     }
 }
 exports.LightReach = LightReach;

package/dist/version.d.ts

@@ -1,4 +1,4 @@
 /**
  * Version information for compress-lightreach package.
  */
-export declare const __version__ = "1.0.0";
+export declare const __version__ = "1.0.1";

package/dist/version.js

@@ -4,4 +4,4 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__version__ = void 0;
-exports.__version__ = "1.0.0";
+exports.__version__ = "1.0.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "compress-lightreach",
-  "version": "1.0.3",
+  "version": "1.0.6",
   "description": "AI cost management SDK with intelligent model routing, prompt compression, and real-time token tracking",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",