clarity-ai 6.5.0 → 6.5.2

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ---
 
+## 6.5.2 (2026-06-06)
+
+### CoT + MoE Space Architecture
+- Dataset repos now hold LoRA weights (flash pushed to `Universal-618/Clarity-flash-weights` dataset)
+- Space app downloads weights from dataset repo on startup, loads base model + LoRA in 4-bit, serves `/v1/chat/completions`
+- CLI routes by model: Flash 14B → Clarity-2 (CoT), Heavy 20B → Clarity-3 (MoE)
+- Multiple fallback Spaces for each model
+- All 6 Spaces connected via shared bucket to Clarity-main
+
+## 6.5.1 (2026-06-06)
+
+### 6-Space Fallback
+- All 6 Spaces tried in sequence for redundancy
+- Lowercase HF Space URL fix
+
 ## 6.5.0 (2026-06-06)
 
 ### Closed Source + Space Proxy

package/README.md

@@ -103,16 +103,10 @@ clarity /bash ls -la
 | Gemini 2.0 Flash | Google | 32K (fast) |
 | DeepSeek R1 Free | OpenRouter | 128K |
 
-## Provider Comparison
+## Architecture
 
-| Provider | Free Tier | Streaming | Priority |
-|---|---|---|---|
-| Groq | ✓ | ✓ | 1 (fastest) |
-| Google Gemini | ✓ | ✓ | 2 |
-| HuggingFace (Clarity Flash) | Needs HF_TOKEN | ✓ | 3 |
-| DeepSeek | Cheap | ✓ | 4 |
-| OpenRouter | ✓ | ✓ | 5 |
+Clarity Flash 14B is served via `Clarity-main` HF Space — a streaming inference proxy at `*.hf.space/v1/chat/completions`. No API keys needed.
 
 ## License
 
-MIT
+Proprietary — all rights reserved. See [LICENSE](LICENSE).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-ai",
-  "version": "6.5.0",
+  "version": "6.5.2",
   "description": "CLARITY — terminal AI agent with Clarity Flash 14B",
   "type": "module",
   "bin": {

package/requirements.txt

@@ -1,4 +1,9 @@
-gradio>=4
-requests>=2
-uvicorn>=0.20
 fastapi>=0.100
+uvicorn>=0.20
+transformers>=4.38
+torch>=2.1
+accelerate>=0.27
+bitsandbytes>=0.42
+peft>=0.8
+huggingface-hub>=0.20
+sentencepiece>=0.1.99

package/space_app.py

@@ -1,28 +1,69 @@
-import os, json, requests
-import gradio as gr
+import os, json, time, asyncio
+from threading import Thread
 from fastapi import FastAPI, Request
 from fastapi.responses import StreamingResponse, JSONResponse
-import uvicorn
+from contextlib import asynccontextmanager
 
 HF_TOKEN = os.environ.get('HF_TOKEN', '')
-MODEL = 'Universal-618/Clarity-flash-weights'
-API = f'https://api-inference.huggingface.co/models/{MODEL}/v1/chat/completions'
-HEADERS = {'Authorization': f'Bearer {HF_TOKEN}', 'Content-Type': 'application/json'}
+MODEL_NAME = os.environ.get('HF_MODEL', 'Clarity-flash-weights')
+BASE_MODEL = os.environ.get('BASE_MODEL_ID', '')
+DS = f'Universal-618/{MODEL_NAME}'
+
+print(f'[startup] model={MODEL_NAME} base={BASE_MODEL}', flush=True)
+
+model = None
+tokenizer = None
+
+def load_model():
+    global model, tokenizer
+    print('[startup] downloading weights...', flush=True)
+    from huggingface_hub import snapshot_download
+    path = snapshot_download(repo_id=DS, repo_type='dataset', token=HF_TOKEN)
+    print(f'[startup] weights at {path}', flush=True)
+    from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig, TextIteratorStreamer
+    from peft import PeftModel
+    bnb = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype='float16', bnb_4bit_use_double_quant=True)
+    print('[startup] loading base model...', flush=True)
+    base = AutoModelForCausalLM.from_pretrained(
+        BASE_MODEL, quantization_config=bnb, device_map='auto',
+        trust_remote_code=True, low_cpu_mem_usage=True, token=HF_TOKEN)
+    print('[startup] loading LoRA...', flush=True)
+    model = PeftModel.from_pretrained(base, path, token=HF_TOKEN)
+    tokenizer = AutoTokenizer.from_pretrained(path, token=HF_TOKEN)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    print('[startup] ready', flush=True)
+
+load_model()
 
 app = FastAPI()
 
 @app.post('/v1/chat/completions')
-async def chat_completions(request: Request):
+async def generate(request: Request):
     body = await request.json()
-    body['model'] = MODEL
+    prompt = tokenizer.apply_chat_template(body['messages'], tokenize=False, add_generation_prompt=True)
+    inputs = tokenizer(prompt, return_tensors='pt')
     stream = body.get('stream', True)
-    body['stream'] = stream
-    resp = requests.post(API, headers=HEADERS, json=body, stream=True)
-    if resp.status_code != 200:
-        return JSONResponse({'error': resp.text}, status_code=resp.status_code)
+    max_tokens = body.get('max_tokens', 4096)
+    gen_kwargs = dict(input_ids=inputs.input_ids, attention_mask=inputs.attention_mask,
+                      max_new_tokens=max_tokens, temperature=body.get('temperature', 0.7),
+                      do_sample=True, pad_token_id=tokenizer.pad_token_id)
     if stream:
-        return StreamingResponse(resp.iter_lines(), media_type='text/event-stream', headers={'Cache-Control': 'no-cache', 'Connection': 'keep-alive', 'X-Accel-Buffering': 'no'})
-    return resp.json()
+        from transformers import TextIteratorStreamer
+        streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+        t = Thread(target=model.generate, kwargs={**gen_kwargs, 'streamer': streamer})
+        t.start()
+        async def gen():
+            yield 'data: {"choices":[{"delta":{"role":"assistant"},"index":0}]}\n\n'
+            for text in streamer:
+                if text:
+                    yield f'data: {json.dumps({"choices":[{"delta":{"content":text},"index":0}]})}\n\n'
+            yield 'data: [DONE]\n\n'
+        return StreamingResponse(gen(), media_type='text/event-stream', headers={
+            'Cache-Control': 'no-cache', 'Connection': 'keep-alive', 'X-Accel-Buffering': 'no'})
+    out = model.generate(**gen_kwargs)
+    text = tokenizer.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
+    return {'choices': [{'message': {'role': 'assistant', 'content': text}, 'index': 0}]}
 
 @app.get('/main-data/{path:path}')
 async def main_data(path: str):
@@ -33,20 +74,10 @@ async def main_data(path: str):
     with open(fp) as f:
         return JSONResponse(json.load(f))
 
-def chat_ui(message, history):
-    history = history or []
-    msgs = [{'role': 'user' if i % 2 == 0 else 'assistant', 'content': m} for i, m in enumerate(history + [message])]
-    body = {'model': MODEL, 'messages': msgs, 'stream': False, 'max_tokens': 4096}
-    resp = requests.post(API, headers=HEADERS, json=body)
-    if resp.status_code == 200:
-        return resp.json()['choices'][0]['message']['content']
-    return f'Error: {resp.status_code}'
-
-with gr.Blocks(title='CLARITY Flash', css='footer{display:none!important}') as ui:
-    gr.Markdown('# CLARITY Flash 14B')
-    gr.ChatInterface(chat_ui, title='Chat')
-
-app = gr.mount_gradio_app(app, ui, path='/')
+@app.get('/')
+async def root():
+    return {'status': 'ok', 'model': MODEL_NAME}
 
 if __name__ == '__main__':
+    import uvicorn
     uvicorn.run(app, host='0.0.0.0', port=7860)

package/src/config/models.js

@@ -1,5 +1,6 @@
 export const ALL_MODELS = [
   { id: 'huggingface/Universal-618/Clarity-flash-weights', provider: 'huggingface', label: 'Clarity Flash 14B', badge: '128K' },
+  { id: 'huggingface/Universal-618/Clarity-heavy-weights', provider: 'huggingface', label: 'Clarity Heavy 20B', badge: 'MoE' },
   { id: 'groq/llama-3.3-70b-versatile', provider: 'groq', label: 'Llama 3.3 70B Versatile', badge: null },
   { id: 'groq/llama-3.1-8b-instant', provider: 'groq', label: 'Llama 3.1 8B Instant', badge: 'Fast' },
   { id: 'groq/llama-4-scout-17b-16e-instruct', provider: 'groq', label: 'Llama 4 Scout 17B', badge: null },

package/src/providers/index.js

@@ -1,26 +1,25 @@
 import { getKey } from '../config/keys.js';
 import { streamResponse } from './streaming.js';
-import { parseErrorResponse } from './errors.js';
-
-const PROVIDERS = {
-  huggingface: {
-    endpoint: 'https://Universal-618-Clarity-main.hf.space/v1/chat/completions',
-    name: 'huggingface',
-  },
-  groq: {
-    endpoint: 'https://api.groq.com/openai/v1/chat/completions',
-    name: 'groq',
-  },
-  openrouter: {
-    endpoint: 'https://openrouter.ai/api/v1/chat/completions',
-    name: 'openrouter',
-  },
+
+const MODEL_ROUTES = {
+  'Universal-618/Clarity-flash-weights': [
+    'https://universal-618-clarity-2.hf.space/v1/chat/completions',
+    'https://universal-618-clarity-4.hf.space/v1/chat/completions',
+    'https://universal-618-clarity-5.hf.space/v1/chat/completions',
+  ],
+  'Universal-618/Clarity-heavy-weights': [
+    'https://universal-618-clarity-3.hf.space/v1/chat/completions',
+    'https://universal-618-clarity-5.hf.space/v1/chat/completions',
+    'https://universal-618-clarity-6.hf.space/v1/chat/completions',
+  ],
 };
 
-export async function* callAI(providerName, model, messages, options = {}) {
-  const provider = PROVIDERS[providerName];
-  if (!provider) throw { type: 'config_error', message: 'Unknown provider: ' + providerName };
+const STATIC_ENDPOINTS = {
+  groq: ['https://api.groq.com/openai/v1/chat/completions'],
+  openrouter: ['https://openrouter.ai/api/v1/chat/completions'],
+};
 
+export async function* callAI(providerName, model, messages, options = {}) {
   const key = getKey(providerName);
   if (!key && providerName !== 'huggingface') {
     throw { type: 'auth_error', provider: providerName, message: 'No API key set for ' + providerName, hint: '/keys ' + providerName + ' <your-key>' };
@@ -40,17 +39,31 @@ export async function* callAI(providerName, model, messages, options = {}) {
     body.tool_choice = 'auto';
   }
 
-  let endpoint = provider.endpoint;
   const extraHeaders = {};
   if (providerName === 'openrouter') {
     extraHeaders['HTTP-Referer'] = 'https://clarity-ai.local';
     extraHeaders['X-Title'] = 'CLARITY AI';
   }
 
-  const stream = streamResponse(endpoint, body, key || 'none', extraHeaders, options.signal);
-  for await (const event of stream) {
-    yield event;
+  const endpoints = MODEL_ROUTES[modelName] || STATIC_ENDPOINTS[providerName] || [];
+  if (!endpoints.length) {
+    throw { type: 'config_error', message: 'No endpoints for ' + providerName + '/' + modelName };
+  }
+
+  let lastErr;
+  for (const endpoint of endpoints) {
+    try {
+      const stream = streamResponse(endpoint, body, key || 'none', extraHeaders, options.signal);
+      for await (const event of stream) {
+        yield event;
+      }
+      return;
+    } catch (err) {
+      lastErr = err;
+      continue;
+    }
   }
+  throw lastErr;
 }
 
 export async function callAISync(providerName, model, messages, options = {}) {