clarity-ai 6.3.3 → 6.4.1

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ---
 
+## 6.4.1 (2026-06-06)
+
+### Clarity Flash 14B Model
+- Added `Clarity Flash 14B` to `/model` picker — 128K context, HuggingFace Inference API
+- New `huggingface` provider: calls `https://api-inference.huggingface.co/models/{model}/v1/chat/completions`
+- `getKey()` falls back to `HF_TOKEN` env var for seamless auth
+- Model weights at `Universal-618/Clarity-flash-weights` on HF Hub
+
+### Fixed-Height Engine (v6.3.x carried forward)
+- Fixed-height viewport with `sliceToViewport()` + `buildLineArray()`
+- Line-by-line streaming via `LineRenderer` (14 line types)
+- Composer: multiline input with auto-grow (max 3 rows), Shift+Enter newline
+
+### Training Notebooks
+- `clarity_flash_14b.ipynb`: Colab T4 — DeepSeek-R1-Distill-Qwen-14B, 4-bit QLoRA, 500 steps, 20 datasets
+- `clarity_heavy_20b_moe.ipynb`: Kaggle T4 — GPT-OSS-20B MoE, MXFP4 native, LoRA, 20 datasets
+
+---
+
 ## 3.1.0 (2026-06-05)
 
 ### UI Rewrite — OpenCode Style

package/README.md

@@ -92,16 +92,26 @@ clarity /bash ls -la
 | `/help [command]` | Command help |
 | `/exit` | Exit CLARITY |
 
+## Available Models
+
+| Model | Provider | Context |
+|---|---|---|
+| **Clarity Flash 14B** | HuggingFace Inference | 128K |
+| Llama 3.3 70B Versatile | Groq | 32K |
+| Llama 3.1 8B Instant | Groq | 8K (fast) |
+| DeepSeek R1 Distill 70B | Groq | 32K (reasoning) |
+| Gemini 2.0 Flash | Google | 32K (fast) |
+| DeepSeek R1 Free | OpenRouter | 128K |
+
 ## Provider Comparison
 
 | Provider | Free Tier | Streaming | Priority |
 |---|---|---|---|
 | Groq | ✓ | ✓ | 1 (fastest) |
 | Google Gemini | ✓ | ✓ | 2 |
-| DeepSeek | Cheap | ✓ | 3 |
-| OpenRouter | ✓ | ✓ | 4 |
-| OpenAI | Paid | ✓ | 5 |
-| Anthropic | Paid | ✓ | 6 |
+| HuggingFace (Clarity Flash) | Needs HF_TOKEN | ✓ | 3 |
+| DeepSeek | Cheap | ✓ | 4 |
+| OpenRouter | ✓ | ✓ | 5 |
 
 ## License
 

package/clarity_flash_14b.ipynb

@@ -2,232 +2,213 @@
   "cells": [
     {
       "cell_type": "markdown",
-      "metadata": {},
       "source": [
-        "# CLARITY Flash 14B — TPU Fine-Tuning\n",
-        "Trains a 14B parameter model on agent CoT + tool-calling data.\n",
-        "Target: Google Colab TPU v2-8 (free tier)\n",
-        "HF token: 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"
-      ]
+        "# CLARITY Flash 14B — Trained! Push to Universal-618/Clarity-flash-weights\n",
+        "Model: deepseek-ai/DeepSeek-R1-Distill-Qwen-14B\n",
+        "4-bit QLoRA + grad ckpt + max_len=256\n",
+        "Weights pushed to HF dataset repo for inference on 6 Clarity Spaces\n"
+      ],
+      "metadata": {}
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === Install ===\n",
-        "!pip install -q torch torch-xla torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu\n",
-        "!pip install -q transformers datasets accelerate peft bitsandbytes sentencepiece huggingface_hub"
+        "import os,gc,torch\n",
+        "from huggingface_hub import create_repo\n",
+        "from google.colab import userdata\n",
+        "HF_TOKEN = os.environ.get('HF_TOKEN') or userdata.get('HF_TOKEN')\n",
+        "assert HF_TOKEN and len(HF_TOKEN)>10, 'Set HF_TOKEN in Colab secrets'\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === HF Auth ===\n",
-        "from huggingface_hub import login, HfApi, create_repo\n",
-        "HF_TOKEN = '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'\n",
-        "login(token=HF_TOKEN, add_to_git_credential=True)\n",
-        "api = HfApi(token=HF_TOKEN)"
+        "!pip install -q transformers datasets accelerate peft bitsandbytes sentencepiece huggingface_hub\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === TPU Setup ===\n",
-        "import torch\n",
-        "import torch_xla\n",
-        "import torch_xla.core.xla_model as xm\n",
-        "device = xm.xla_device()\n",
-        "print('Device:', device)\n",
-        "print('TPU cores:', torch_xla._XLAC._xla_get_num_devices())"
+        "assert torch.cuda.is_available()\n",
+        "print('GPU:', torch.cuda.get_device_name(0))\n",
+        "gc.collect(); torch.cuda.empty_cache()\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === Data Loading ===\n",
-        "import requests\n",
-        "import json\n",
-        "from datasets import Dataset\n",
-        "\n",
-        "DATA_URLS = [\n",
-        "  'https://huggingface.co/spaces/Universal-618/Clarity-main/main-data',\n",
-        "  'https://huggingface.co/spaces/Universal-618/Clarity-2/main-data',\n",
-        "  'https://huggingface.co/spaces/Universal-618/Clarity-3/main-data',\n",
-        "]\n",
+        "import requests,sys\n",
+        "from datasets import Dataset, load_dataset\n",
+        "import random\n",
         "\n",
         "all_samples = []\n",
-        "for url in DATA_URLS:\n",
-        "  try:\n",
-        "    r = requests.get(url, headers={'Authorization': f'Bearer {HF_TOKEN}'}, timeout=60)\n",
-        "    if r.status_code == 200:\n",
-        "      data = r.json()\n",
-        "      samples = data if isinstance(data, list) else data.get('data', [])\n",
-        "      all_samples.extend(samples)\n",
-        "      print(f'Loaded {len(samples)} from {url}')\n",
-        "  except Exception as e:\n",
-        "    print(f'Skipped {url}: {e}')\n",
-        "\n",
-        "# Fallback: synthetic CoT samples if no data\n",
-        "if len(all_samples) < 10:\n",
-        "  print('No remote data found — using synthetic samples')\n",
-        "  all_samples = [\n",
-        "    {'instruction': 'List files in current directory', 'response': 'I will run the ls command.\\n<tool>bash</tool><cmd>ls -la</cmd>', 'tools': 'bash'},\n",
-        "    {'instruction': 'Read the file config.json', 'response': 'Let me read that file.\\n<tool>read_file</tool><path>config.json</path>', 'tools': 'read_file'},\n",
-        "    {'instruction': 'Write hello world script', 'response': 'I will create the file.\\n<tool>write_file</tool><path>hello.py</path><content>print(\"hello\")</content>', 'tools': 'write_file'},\n",
-        "  ]\n",
-        "\n",
-        "print(f'Total training samples: {len(all_samples)}')"
+        "def add(i,r): all_samples.append(dict(instruction=str(i or ''), response=str(r or '')))\n",
+        "\n",
+        "def load_std(n,s,f,l,**kw):\n",
+        "    try:\n",
+        "        for i,row in enumerate(load_dataset(n,split=s,streaming=True,token=HF_TOKEN,**kw)):\n",
+        "            if i>=l: break\n",
+        "            add(row.get(f['instruction'],''),row.get(f['response'],''))\n",
+        "    except Exception as e: print(f'  skip {n}: {e}', file=sys.stderr)\n",
+        "\n",
+        "def load_msgs(n,s,l,**kw):\n",
+        "    try:\n",
+        "        for i,row in enumerate(load_dataset(n,split=s,streaming=True,token=HF_TOKEN,**kw)):\n",
+        "            if i>=l: break\n",
+        "            msgs=row.get('messages',[])\n",
+        "            if len(msgs)>=2: add(msgs[0].get('content',''),msgs[-1].get('content',''))\n",
+        "    except Exception as e: print(f'  skip {n}: {e}', file=sys.stderr)\n",
+        "\n",
+        "for sfx in ['main','2','3','4','5','6']:\n",
+        "    try:\n",
+        "        r=requests.get(f'https://huggingface.co/spaces/Universal-618/Clarity-{sfx}/main-data',headers={'Authorization':f'Bearer {HF_TOKEN}'},timeout=30)\n",
+        "        if r.status_code==200:\n",
+        "            d=r.json()\n",
+        "            for x in (d if isinstance(d,list) else d.get('data',[])):\n",
+        "                add(x.get('instruction',x.get('prompt',x.get('problem',''))),x.get('response',x.get('completion',x.get('output',x.get('solution','')))))\n",
+        "    except: pass\n",
+        "\n",
+        "load_std('Open-Orca/OpenOrca','train',dict(instruction='question',response='response'),800)\n",
+        "load_msgs('HuggingFaceH4/no_robots','train',500)\n",
+        "load_msgs('HuggingFaceH4/ultrachat_200k','train_sft',500)\n",
+        "load_std('tatsu-lab/alpaca','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('TIGER-Lab/MathInstruct','train',dict(instruction='instruction',response='output'),800)\n",
+        "load_std('AI-MO/NuminaMath-CoT','train',dict(instruction='problem',response='solution'),600)\n",
+        "load_std('meta-math/MetaMathQA','train',dict(instruction='query',response='response'),600)\n",
+        "load_std('microsoft/orca-math-word-problems-200k','train',dict(instruction='question',response='answer'),500)\n",
+        "load_std('GAIR/Reasoning-Intensive','train',dict(instruction='question',response='answer'),500)\n",
+        "load_std('BAAI/AgentInstruct','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('bigcode/commitpackft','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('sahil2801/CodeAlpaca-20k','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('jondurbin/airoboros-3.2','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('cognitivecomputations/dolphin','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('databricks/databricks-dolly-15k','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('WizardLM/WizardLM_evol_instruct_V2_196k','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('Intel/orca_dpo_pairs','train',dict(instruction='question',response='chosen'),500)\n",
+        "load_std('nvidia/HelpSteer','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('Dahoas/full-hh-rlhf','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('BAAI/Infinity-Instruct','0625',dict(instruction='instruction',response='output'),500)\n",
+        "\n",
+        "print(f'Total: {len(all_samples)}')\n",
+        "random.shuffle(all_samples); gc.collect()\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === Format for Training ===\n",
-        "def format_chat(sample):\n",
-        "  inst = sample.get('instruction', sample.get('prompt', sample.get('input', '')))\n",
-        "  resp = sample.get('response', sample.get('completion', sample.get('output', '')))\n",
-        "  return {\n",
-        "    'text': f'<|im_start|>user\\n{inst}<|im_end|>\\n<|im_start|>assistant\\n{resp}<|im_end|>'\n",
-        "  }\n",
+        "from transformers import AutoTokenizer\n",
+        "\n",
+        "MODEL_ID='deepseek-ai/DeepSeek-R1-Distill-Qwen-14B'\n",
+        "tokz=AutoTokenizer.from_pretrained(MODEL_ID,token=HF_TOKEN,trust_remote_code=True,use_fast=True)\n",
+        "tokz.pad_token=tokz.eos_token\n",
         "\n",
-        "dataset = Dataset.from_list([format_chat(s) for s in all_samples])\n",
-        "dataset = dataset.train_test_split(test_size=0.05, seed=42)\n",
-        "print(f'Train: {len(dataset[\"train\"])}, Test: {len(dataset[\"test\"])}')"
+        "def fmt(s): return tokz.apply_chat_template([{'role':'user','content':s.get('instruction','')},{'role':'assistant','content':s.get('response','')}],tokenize=False)\n",
+        "\n",
+        "ds=Dataset.from_list([{'text':fmt(s)} for s in all_samples])\n",
+        "sp=ds.train_test_split(test_size=0.01,seed=42)\n",
+        "del all_samples,ds; gc.collect()\n",
+        "print(f'Train: {len(sp[\"train\"])}  Test: {len(sp[\"test\"])}')\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === Load Model ===\n",
-        "from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig\n",
-        "import torch\n",
+        "from transformers import AutoModelForCausalLM,BitsAndBytesConfig\n",
+        "gc.collect(); torch.cuda.empty_cache()\n",
         "\n",
-        "MODEL_ID = 'Qwen/Qwen2.5-14B-Instruct'\n",
+        "bnb=BitsAndBytesConfig(load_in_4bit=True,bnb_4bit_use_double_quant=True,bnb_4bit_quant_type='nf4',bnb_4bit_compute_dtype=torch.float16)\n",
         "\n",
-        "bnb = BitsAndBytesConfig(\n",
-        "  load_in_4bit=True,\n",
-        "  bnb_4bit_use_double_quant=True,\n",
-        "  bnb_4bit_quant_type='nf4',\n",
-        "  bnb_4bit_compute_dtype=torch.bfloat16,\n",
-        ")\n",
-        "\n",
-        "tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, token=HF_TOKEN, trust_remote_code=True)\n",
-        "tokenizer.pad_token = tokenizer.eos_token\n",
-        "\n",
-        "model = AutoModelForCausalLM.from_pretrained(\n",
-        "  MODEL_ID,\n",
-        "  quantization_config=bnb,\n",
-        "  device_map='auto',\n",
-        "  torch_dtype=torch.bfloat16,\n",
-        "  token=HF_TOKEN,\n",
-        "  trust_remote_code=True,\n",
-        ")\n",
-        "print(f'Model loaded: {MODEL_ID}')"
+        "model=AutoModelForCausalLM.from_pretrained(MODEL_ID,quantization_config=bnb,device_map='auto',dtype=torch.float16,token=HF_TOKEN,trust_remote_code=True,low_cpu_mem_usage=True)\n",
+        "model.gradient_checkpointing_enable()\n",
+        "model.config.use_cache=False\n",
+        "gc.collect(); torch.cuda.empty_cache()\n",
+        "print('Model:',round(model.num_parameters()/1e9,1),'B  trainable:',round(model.num_parameters(only_trainable=True)/1e6,1),'M')\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === LoRA Config ===\n",
-        "from peft import LoraConfig, get_peft_model, TaskType\n",
-        "\n",
-        "lora_config = LoraConfig(\n",
-        "  task_type=TaskType.CAUSAL_LM,\n",
-        "  r=16,\n",
-        "  lora_alpha=32,\n",
-        "  lora_dropout=0.05,\n",
-        "  target_modules=['q_proj', 'k_proj', 'v_proj', 'o_proj', 'gate_proj', 'up_proj', 'down_proj'],\n",
-        "  bias='none',\n",
-        ")\n",
-        "model = get_peft_model(model, lora_config)\n",
-        "model.print_trainable_parameters()"
+        "from peft import LoraConfig,get_peft_model,TaskType\n",
+        "lora=LoraConfig(task_type=TaskType.CAUSAL_LM,r=4,lora_alpha=8,lora_dropout=0.05,target_modules=['q_proj','k_proj','v_proj','o_proj','gate_proj','up_proj','down_proj'],bias='none')\n",
+        "model=get_peft_model(model,lora)\n",
+        "model.print_trainable_parameters()\n",
+        "gc.collect(); torch.cuda.empty_cache()\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === Training ===\n",
-        "from transformers import TrainingArguments, Trainer, DataCollatorForSeq2Seq\n",
-        "import numpy as np\n",
-        "\n",
-        "def tokenize_fn(examples):\n",
-        "  tok = tokenizer(examples['text'], truncation=True, max_length=2048, padding=False)\n",
-        "  tok['labels'] = tok['input_ids'].copy()\n",
-        "  return tok\n",
-        "\n",
-        "tokenized = dataset.map(tokenize_fn, remove_columns=['text'], batched=True)\n",
-        "\n",
-        "args = TrainingArguments(\n",
-        "  output_dir='./clarity-flash-14b',\n",
-        "  per_device_train_batch_size=1,\n",
-        "  gradient_accumulation_steps=16,\n",
-        "  num_train_epochs=3,\n",
-        "  learning_rate=2e-4,\n",
-        "  bf16=True,\n",
-        "  logging_steps=10,\n",
-        "  save_steps=200,\n",
-        "  save_total_limit=2,\n",
-        "  optim='adamw_8bit',\n",
-        "  report_to='none',\n",
-        "  dataloader_drop_last=False,\n",
-        ")\n",
-        "\n",
-        "trainer = Trainer(\n",
-        "  model=model,\n",
-        "  args=args,\n",
-        "  train_dataset=tokenized['train'],\n",
-        "  eval_dataset=tokenized['test'],\n",
-        "  data_collator=DataCollatorForSeq2Seq(tokenizer, padding=True),\n",
+        "from transformers import TrainingArguments,Trainer,DataCollatorForSeq2Seq\n",
+        "\n",
+        "def tok_fn(ex):\n",
+        "    t=tokz(ex['text'],truncation=True,max_length=256,padding=False)\n",
+        "    t['labels']=t['input_ids'].copy()\n",
+        "    return t\n",
+        "\n",
+        "tok=sp.map(tok_fn,remove_columns=['text'],batched=True,num_proc=2)\n",
+        "del sp; gc.collect()\n",
+        "\n",
+        "args=TrainingArguments(\n",
+        "    output_dir='./clarity-flash',\n",
+        "    per_device_train_batch_size=1,\n",
+        "    gradient_accumulation_steps=4,\n",
+        "    max_steps=500,\n",
+        "    learning_rate=3e-4,\n",
+        "    fp16=True,\n",
+        "    logging_steps=10,\n",
+        "    save_strategy='no',\n",
+        "    optim='adamw_8bit',\n",
+        "    report_to='none',\n",
+        "    dataloader_num_workers=0,\n",
+        "    lr_scheduler_type='cosine',\n",
+        "    warmup_steps=25,\n",
         ")\n",
         "\n",
-        "trainer.train()"
+        "trainer=Trainer(model=model,args=args,train_dataset=tok['train'],data_collator=DataCollatorForSeq2Seq(tokz,padding=True,pad_to_multiple_of=8))\n",
+        "gc.collect(); torch.cuda.empty_cache()\n",
+        "trainer.train()\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === Push Weights to HF ===\n",
-        "WEIGHTS_REPO = 'Universal-618/Clarity-flash-weights'\n",
-        "try:\n",
-        "  create_repo(WEIGHTS_REPO, repo_type='dataset', exist_ok=True, token=HF_TOKEN)\n",
-        "  print(f'Repo {WEIGHTS_REPO} ready')\n",
-        "except Exception as e:\n",
-        "  print(f'Repo exists or error: {e}')\n",
-        "\n",
-        "model.push_to_hub(WEIGHTS_REPO, token=HF_TOKEN, use_temp_dir=True)\n",
-        "tokenizer.push_to_hub(WEIGHTS_REPO, token=HF_TOKEN)\n",
-        "print(f'Weights pushed to {WEIGHTS_REPO}')"
+        "WEIGHTS_REPO='Universal-618/Clarity-flash-weights'\n",
+        "create_repo(WEIGHTS_REPO,repo_type='model',exist_ok=True,token=HF_TOKEN)\n",
+        "model.push_to_hub(WEIGHTS_REPO,token=HF_TOKEN,use_temp_dir=True)\n",
+        "tokz.push_to_hub(WEIGHTS_REPO,token=HF_TOKEN)\n",
+        "import sys; print('done',file=sys.stderr)\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     }
   ],
   "metadata": {
-    "accelerator": "TPU",
+    "accelerator": "GPU",
     "colab": {
       "provenance": []
     },
@@ -242,4 +223,4 @@
   },
   "nbformat": 4,
   "nbformat_minor": 4
-}
+}

package/clarity_heavy_20b_moe.ipynb

@@ -2,249 +2,211 @@
   "cells": [
     {
       "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# CLARITY Heavy 20B MoE — Multi-GPU Fine-Tuning\n",
-        "Trains a 20B Mixture-of-Experts model on deep CoT + recursive tool execution data.\n",
-        "Target: Kaggle dual T4 (2x 16GB) with 4-bit quantization + FSDP.\n",
-        "HF token: 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"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === Install ===\n",
-        "!pip install -q torch transformers datasets accelerate peft bitsandbytes\n",
-        "!pip install -q deepspeed sentencepiece huggingface_hub"
+        "# CLARITY Heavy 20B MoE — Kaggle Single T4\n",
+        "Model: openai/gpt-oss-20b (21B MoE, 3.6B active, native MXFP4)\n",
+        "LoRA + grad ckpt + max_len=256 + no eval + no checkpoints\n"
       ],
-      "execution_count": null,
-      "outputs": []
+      "metadata": {}
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === Check GPUs ===\n",
-        "import torch\n",
-        "n_gpus = torch.cuda.device_count()\n",
-        "for i in range(n_gpus):\n",
-        "  print(f'GPU {i}: {torch.cuda.get_device_name(i)} — {torch.cuda.get_device_properties(i).total_memory / 1e9:.1f} GB')\n",
-        "assert n_gpus >= 2, 'Need at least 2 GPUs'"
+        "import os,gc,torch\n",
+        "from huggingface_hub import create_repo\n",
+        "HF_TOKEN=os.environ.get('HF_TOKEN')\n",
+        "if not HF_TOKEN:\n",
+        "    from kaggle_secrets import UserSecretsClient\n",
+        "    HF_TOKEN=UserSecretsClient().get_secret('HF_TOKEN')\n",
+        "assert HF_TOKEN and len(HF_TOKEN)>10, 'Set HF_TOKEN as Kaggle secret'\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === HF Auth ===\n",
-        "from huggingface_hub import login, HfApi, create_repo\n",
-        "HF_TOKEN = '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'\n",
-        "login(token=HF_TOKEN, add_to_git_credential=True)\n",
-        "api = HfApi(token=HF_TOKEN)"
+        "!pip install -q transformers datasets accelerate peft bitsandbytes sentencepiece huggingface_hub\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === Data Loading ===\n",
-        "import requests\n",
-        "import json\n",
-        "from datasets import Dataset, concatenate_datasets\n",
-        "\n",
-        "DATA_URLS = [\n",
-        "  'https://huggingface.co/spaces/Universal-618/Clarity-4/main-data',\n",
-        "  'https://huggingface.co/spaces/Universal-618/Clarity-5/main-data',\n",
-        "  'https://huggingface.co/spaces/Universal-618/Clarity-6/main-data',\n",
-        "  'https://huggingface.co/spaces/Universal-618/Clarity-main/main-data',\n",
-        "]\n",
-        "\n",
-        "all_samples = []\n",
-        "for url in DATA_URLS:\n",
-        "  try:\n",
-        "    r = requests.get(url, headers={'Authorization': f'Bearer {HF_TOKEN}'}, timeout=120)\n",
-        "    if r.status_code == 200:\n",
-        "      data = r.json()\n",
-        "      samples = data if isinstance(data, list) else data.get('data', [])\n",
-        "      all_samples.extend(samples)\n",
-        "      print(f'Loaded {len(samples)} from {url}')\n",
-        "  except Exception as e:\n",
-        "    print(f'Skipped {url}: {e}')\n",
-        "\n",
-        "if len(all_samples) < 10:\n",
-        "  print('No remote data — generating synthetic deep CoT samples')\n",
-        "  import random\n",
-        "  code_snippets = [\n",
-        "    'def fib(n): return n if n < 2 else fib(n-1) + fib(n-2)',\n",
-        "    'for i in range(10): print(i**2)',\n",
-        "    'with open(\"data.txt\") as f: content = f.read()',\n",
-        "  ]\n",
-        "  for _ in range(50):\n",
-        "    cs = random.choice(code_snippets)\n",
-        "    all_samples.append({\n",
-        "      'instruction': f'Write and test a function',\n",
-        "      'thinking': f'I need to think step by step. First, I will analyze what the user wants. Then I will write the code. Let me reason through this carefully.',\n",
-        "      'response': f'I will write the code now.\\n<tool>bash</tool><cmd>cat > /tmp/test.py << \\'EOF\\'\\n{cs}\\nEOF\\npython3 /tmp/test.py</cmd>',\n",
-        "      'tools': 'bash,write_file',\n",
-        "    })\n",
-        "\n",
-        "print(f'Total training samples: {len(all_samples)}')"
+        "assert torch.cuda.is_available()\n",
+        "print('GPU:',torch.cuda.get_device_name(0))\n",
+        "gc.collect(); torch.cuda.empty_cache()\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === Format ===\n",
-        "def format_deep_cot(sample):\n",
-        "  inst = sample.get('instruction', sample.get('prompt', ''))\n",
-        "  thinking = sample.get('thinking', '')\n",
-        "  resp = sample.get('response', sample.get('completion', ''))\n",
-        "  thinking_block = f'<|thinking_start|>{thinking}<|thinking_end|>' if thinking else ''\n",
-        "  return {\n",
-        "    'text': f'<|im_start|>user\\n{inst}<|im_end|>\\n<|im_start|>assistant\\n{thinking_block}{resp}<|im_end|>'\n",
-        "  }\n",
-        "\n",
-        "dataset = Dataset.from_list([format_deep_cot(s) for s in all_samples])\n",
-        "split = dataset.train_test_split(test_size=0.05, seed=42)\n",
-        "print(f'Train: {len(split[\"train\"])}, Test: {len(split[\"test\"])}')"
+        "import requests,sys\n",
+        "from datasets import Dataset, load_dataset\n",
+        "import random\n",
+        "\n",
+        "all_samples=[]\n",
+        "def add(i,r): all_samples.append(dict(instruction=str(i or ''), response=str(r or '')))\n",
+        "\n",
+        "def load_std(n,s,f,l,**kw):\n",
+        "    try:\n",
+        "        for i,row in enumerate(load_dataset(n,split=s,streaming=True,token=HF_TOKEN,**kw)):\n",
+        "            if i>=l: break\n",
+        "            add(row.get(f['instruction'],''),row.get(f['response'],''))\n",
+        "    except Exception as e: print(f'  skip {n}: {e}', file=sys.stderr)\n",
+        "\n",
+        "def load_msgs(n,s,l,**kw):\n",
+        "    try:\n",
+        "        for i,row in enumerate(load_dataset(n,split=s,streaming=True,token=HF_TOKEN,**kw)):\n",
+        "            if i>=l: break\n",
+        "            msgs=row.get('messages',[])\n",
+        "            if len(msgs)>=2: add(msgs[0].get('content',''),msgs[-1].get('content',''))\n",
+        "    except Exception as e: print(f'  skip {n}: {e}', file=sys.stderr)\n",
+        "\n",
+        "for sfx in ['main','2','3','4','5','6']:\n",
+        "    try:\n",
+        "        r=requests.get(f'https://huggingface.co/spaces/Universal-618/Clarity-{sfx}/main-data',headers={'Authorization':f'Bearer {HF_TOKEN}'},timeout=30)\n",
+        "        if r.status_code==200:\n",
+        "            d=r.json()\n",
+        "            for x in (d if isinstance(d,list) else d.get('data',[])):\n",
+        "                add(x.get('instruction',x.get('prompt',x.get('problem',''))),x.get('response',x.get('completion',x.get('output',x.get('solution','')))))\n",
+        "    except: pass\n",
+        "\n",
+        "load_std('Open-Orca/OpenOrca','train',dict(instruction='question',response='response'),800)\n",
+        "load_msgs('HuggingFaceH4/no_robots','train',500)\n",
+        "load_msgs('HuggingFaceH4/ultrachat_200k','train_sft',500)\n",
+        "load_std('tatsu-lab/alpaca','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('TIGER-Lab/MathInstruct','train',dict(instruction='instruction',response='output'),800)\n",
+        "load_std('AI-MO/NuminaMath-CoT','train',dict(instruction='problem',response='solution'),600)\n",
+        "load_std('meta-math/MetaMathQA','train',dict(instruction='query',response='response'),600)\n",
+        "load_std('microsoft/orca-math-word-problems-200k','train',dict(instruction='question',response='answer'),500)\n",
+        "load_std('GAIR/Reasoning-Intensive','train',dict(instruction='question',response='answer'),500)\n",
+        "load_std('BAAI/AgentInstruct','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('bigcode/commitpackft','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('sahil2801/CodeAlpaca-20k','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('jondurbin/airoboros-3.2','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('cognitivecomputations/dolphin','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('databricks/databricks-dolly-15k','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('WizardLM/WizardLM_evol_instruct_V2_196k','train',dict(instruction='instruction',response='output'),500)\n",
+        "load_std('Intel/orca_dpo_pairs','train',dict(instruction='question',response='chosen'),500)\n",
+        "load_std('nvidia/HelpSteer','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('Dahoas/full-hh-rlhf','train',dict(instruction='instruction',response='response'),500)\n",
+        "load_std('BAAI/Infinity-Instruct','0625',dict(instruction='instruction',response='output'),500)\n",
+        "\n",
+        "print(f'Total: {len(all_samples)}')\n",
+        "random.shuffle(all_samples); gc.collect()\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === Load MoE Model (4-bit) ===\n",
-        "from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig\n",
-        "\n",
-        "MODEL_ID = 'deepseek-ai/DeepSeek-MoE-16B-Chat'\n",
+        "from transformers import AutoTokenizer\n",
         "\n",
-        "bnb = BitsAndBytesConfig(\n",
-        "  load_in_4bit=True,\n",
-        "  bnb_4bit_use_double_quant=True,\n",
-        "  bnb_4bit_quant_type='nf4',\n",
-        "  bnb_4bit_compute_dtype=torch.bfloat16,\n",
-        ")\n",
+        "MODEL_ID='openai/gpt-oss-20b'\n",
+        "tokz=AutoTokenizer.from_pretrained(MODEL_ID,token=HF_TOKEN,trust_remote_code=True)\n",
+        "tokz.pad_token=tokz.eos_token\n",
         "\n",
-        "tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, token=HF_TOKEN, trust_remote_code=True)\n",
-        "tokenizer.pad_token = tokenizer.eos_token\n",
+        "def fmt(s): return tokz.apply_chat_template([{'role':'system','content':'Reasoning: high'},{'role':'user','content':s.get('instruction','')},{'role':'assistant','content':s.get('response','')}],tokenize=False)\n",
         "\n",
-        "model = AutoModelForCausalLM.from_pretrained(\n",
-        "  MODEL_ID,\n",
-        "  quantization_config=bnb,\n",
-        "  device_map='auto',\n",
-        "  torch_dtype=torch.bfloat16,\n",
-        "  token=HF_TOKEN,\n",
-        "  trust_remote_code=True,\n",
-        ")\n",
-        "print(f'MoE model loaded: {MODEL_ID}')\n",
-        "print(f'Params: {model.num_parameters():,.0f}')"
+        "ds=Dataset.from_list([{'text':fmt(s)} for s in all_samples])\n",
+        "sp=ds.train_test_split(test_size=0.01,seed=42)\n",
+        "del all_samples,ds; gc.collect()\n",
+        "print(f'Train: {len(sp[\"train\"])}  Test: {len(sp[\"test\"])}')\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === LoRA for MoE ===\n",
-        "from peft import LoraConfig, get_peft_model, TaskType\n",
-        "\n",
-        "lora_config = LoraConfig(\n",
-        "  task_type=TaskType.CAUSAL_LM,\n",
-        "  r=8,\n",
-        "  lora_alpha=16,\n",
-        "  lora_dropout=0.1,\n",
-        "  target_modules=['q_proj', 'k_proj', 'v_proj', 'o_proj', 'gate_proj', 'up_proj', 'down_proj', 'gate'],\n",
-        "  bias='none',\n",
-        ")\n",
-        "model = get_peft_model(model, lora_config)\n",
-        "model.print_trainable_parameters()"
+        "from transformers import AutoModelForCausalLM\n",
+        "import requests as req\n",
+        "gc.collect(); torch.cuda.empty_cache()\n",
+        "\n",
+        "r=req.get(f'https://huggingface.co/{MODEL_ID}/raw/main/config.json',headers={'Authorization':f'Bearer {HF_TOKEN}'})\n",
+        "cd=r.json()\n",
+        "cd.pop('_attn_implementation',None); cd.pop('attn_implementation',None)\n",
+        "\n",
+        "model=AutoModelForCausalLM.from_pretrained(MODEL_ID,config=cd,device_map='auto',token=HF_TOKEN,trust_remote_code=True,low_cpu_mem_usage=True)\n",
+        "model.gradient_checkpointing_enable()\n",
+        "model.config.use_cache=False\n",
+        "gc.collect(); torch.cuda.empty_cache()\n",
+        "print('Model:',round(model.num_parameters()/1e9,1),'B')\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === Gradient Checkpointing (prevents OOM) ===\n",
-        "model.gradient_checkpointing_enable(gradient_checkpointing_kwargs={'use_reentrant': False})\n",
-        "model.config.use_cache = False\n",
-        "print('Gradient checkpointing enabled')"
+        "from peft import LoraConfig,get_peft_model,TaskType\n",
+        "lora=LoraConfig(task_type=TaskType.CAUSAL_LM,r=4,lora_alpha=8,lora_dropout=0.1,target_modules=['q_proj','k_proj','v_proj','o_proj','gate_proj','up_proj','down_proj'],bias='none')\n",
+        "model=get_peft_model(model,lora)\n",
+        "model.print_trainable_parameters()\n",
+        "gc.collect(); torch.cuda.empty_cache()\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === Training ===\n",
-        "from transformers import TrainingArguments, Trainer, DataCollatorForSeq2Seq\n",
-        "\n",
-        "def tokenize_fn(examples):\n",
-        "  tok = tokenizer(examples['text'], truncation=True, max_length=2048, padding=False)\n",
-        "  tok['labels'] = tok['input_ids'].copy()\n",
-        "  return tok\n",
-        "\n",
-        "tokenized = split.map(tokenize_fn, remove_columns=['text'], batched=True)\n",
-        "\n",
-        "args = TrainingArguments(\n",
-        "  output_dir='./clarity-heavy-20b-moe',\n",
-        "  per_device_train_batch_size=1,\n",
-        "  per_device_eval_batch_size=1,\n",
-        "  gradient_accumulation_steps=8,\n",
-        "  num_train_epochs=3,\n",
-        "  learning_rate=1e-4,\n",
-        "  bf16=True,\n",
-        "  logging_steps=10,\n",
-        "  save_steps=200,\n",
-        "  save_total_limit=2,\n",
-        "  optim='adamw_8bit',\n",
-        "  gradient_checkpointing=True,\n",
-        "  report_to='none',\n",
-        "  ddp_find_unused_parameters=False,\n",
-        ")\n",
-        "\n",
-        "trainer = Trainer(\n",
-        "  model=model,\n",
-        "  args=args,\n",
-        "  train_dataset=tokenized['train'],\n",
-        "  eval_dataset=tokenized['test'],\n",
-        "  data_collator=DataCollatorForSeq2Seq(tokenizer, padding=True, pad_to_multiple_of=8),\n",
+        "from transformers import TrainingArguments,Trainer,DataCollatorForSeq2Seq\n",
+        "\n",
+        "def tok_fn(ex):\n",
+        "    t=tokz(ex['text'],truncation=True,max_length=256,padding=False)\n",
+        "    t['labels']=t['input_ids'].copy()\n",
+        "    return t\n",
+        "\n",
+        "tok=sp.map(tok_fn,remove_columns=['text'],batched=True,num_proc=2)\n",
+        "del sp; gc.collect()\n",
+        "\n",
+        "args=TrainingArguments(\n",
+        "    output_dir='./clarity-heavy',\n",
+        "    per_device_train_batch_size=1,\n",
+        "    gradient_accumulation_steps=16,\n",
+        "    num_train_epochs=1,\n",
+        "    learning_rate=2e-4,\n",
+        "    fp16=True,\n",
+        "    logging_steps=10,\n",
+        "    save_strategy='no',\n",
+        "    optim='adamw_8bit',\n",
+        "    report_to='none',\n",
+        "    dataloader_num_workers=0,\n",
+        "    lr_scheduler_type='cosine',\n",
+        "    warmup_steps=25,\n",
         ")\n",
         "\n",
-        "trainer.train()"
+        "trainer=Trainer(model=model,args=args,train_dataset=tok['train'],data_collator=DataCollatorForSeq2Seq(tokz,padding=True,pad_to_multiple_of=8))\n",
+        "gc.collect(); torch.cuda.empty_cache()\n",
+        "trainer.train()\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     },
     {
       "cell_type": "code",
-      "metadata": {},
       "source": [
-        "# === Push to HF ===\n",
-        "WEIGHTS_REPO = 'Universal-618/Clarity-heavy-weights'\n",
-        "try:\n",
-        "  create_repo(WEIGHTS_REPO, repo_type='dataset', exist_ok=True, token=HF_TOKEN)\n",
-        "  print(f'Repo {WEIGHTS_REPO} ready')\n",
-        "except Exception as e:\n",
-        "  print(f'Repo notice: {e}')\n",
-        "\n",
-        "model.push_to_hub(WEIGHTS_REPO, token=HF_TOKEN, use_temp_dir=True)\n",
-        "tokenizer.push_to_hub(WEIGHTS_REPO, token=HF_TOKEN)\n",
-        "print(f'Weights pushed to https://huggingface.co/datasets/{WEIGHTS_REPO}')"
+        "WEIGHTS_REPO='Universal-618/Clarity-heavy-weights'\n",
+        "create_repo(WEIGHTS_REPO,repo_type='model',exist_ok=True,token=HF_TOKEN)\n",
+        "model.push_to_hub(WEIGHTS_REPO,token=HF_TOKEN,use_temp_dir=True)\n",
+        "tokz.push_to_hub(WEIGHTS_REPO,token=HF_TOKEN)\n",
+        "import sys; print('done',file=sys.stderr)\n"
       ],
+      "metadata": {},
       "execution_count": null,
       "outputs": []
     }
@@ -267,4 +229,4 @@
   },
   "nbformat": 4,
   "nbformat_minor": 4
-}
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "clarity-ai",
-  "version": "6.3.3",
-  "description": "Premium terminal AI agent — fixed-height viewport, box-drawing UI, TrueColor theme, streaming with abort",
+  "version": "6.4.1",
+  "description": "Premium terminal AI agent — Clarity Flash 14B model, HF Inference API, fixed-height viewport, TrueColor theme",
   "type": "module",
   "bin": {
     "clarity": "bin/clarity.js"

package/src/components/CodeBlock.js

@@ -1,6 +1,6 @@
 import React, { useMemo } from 'react';
 import { Box, Text } from 'ink';
-import { hex, usym } from '../config/theme.js';
+import { hex, sym } from '../config/theme.js';
 import { getLayout } from '../config/layout.js';
 const { createElement: h } = React;
 
@@ -40,7 +40,7 @@ export function CodeBlock({ code, language }) {
       ),
       lines.length > maxLines
         ? h(Text, { color: hex.textMuted, backgroundColor: hex.codeBg },
-            '  ' + usym.ellipsis + ' ' + (lines.length - maxLines) + ' more lines')
+            '  ' + sym.ellipsis + ' ' + (lines.length - maxLines) + ' more lines')
         : null
     )
   );

package/src/components/ThinkingBlock.js

@@ -1,6 +1,6 @@
 import React, { useState } from 'react';
 import { Box, Text } from 'ink';
-import { hex, usym, u } from '../config/theme.js';
+import { hex, sym } from '../config/theme.js';
 import { getLayout } from '../config/layout.js';
 const { createElement: h } = React;
 
@@ -12,7 +12,7 @@ export function ThinkingBlock({ toolResults, duration }) {
     ? (duration < 1000 ? duration + 'ms' : (duration / 1000).toFixed(1) + 's')
     : '';
 
-  const headerText = usym.triR2 + ' ' + (collapsed ? usym.triR2 : usym.triD2) + ' Thought' + (durStr ? ' (' + durStr + ')' : '');
+  const headerText = sym.triR + ' ' + (collapsed ? sym.triR : sym.triD) + ' Thought' + (durStr ? ' (' + durStr + ')' : '');
 
   const rows = 1;
   const totalRows = collapsed ? 1 : 1 + items.length;
@@ -26,9 +26,9 @@ export function ThinkingBlock({ toolResults, duration }) {
       : h(Box, { flexDirection: 'column', backgroundColor: hex.surfaceAlt },
           items.map((tr, i) => {
             const isLast = i === items.length - 1;
-            const prefix = isLast ? usym.treeTip + u.h : usym.treeFork + u.h;
-            const conn = isLast ? ' ' : usym.treeCon;
-            const icon = tr.status === 'failed' ? usym.cross : usym.circle;
+            const prefix = isLast ? sym.treeTip + sym.u.h : sym.treeFork + sym.u.h;
+            const conn = isLast ? ' ' : sym.treeCon;
+            const icon = tr.status === 'failed' ? sym.cross : sym.circle;
             const col = tr.status === 'failed' ? hex.red : hex.green;
             const td = tr.duration ? ' ' + tr.duration + 'ms' : '';
             const line = '  ' + prefix + ' ' + icon + ' ' + tr.name + td;

package/src/config/keys.js

@@ -23,9 +23,9 @@ export function setKey(provider, key) {
 export function getKey(provider) {
   try {
     const keys = JSON.parse(readFileSync(KEYS_PATH, 'utf-8'));
-    return keys[provider] || process.env[provider.toUpperCase() + '_API_KEY'] || null;
+    return keys[provider] || process.env[provider.toUpperCase() + '_API_KEY'] || process.env.HF_TOKEN || null;
   } catch {
-    return process.env[provider.toUpperCase() + '_API_KEY'] || null;
+    return process.env[provider.toUpperCase() + '_API_KEY'] || process.env.HF_TOKEN || null;
   }
 }
 

package/src/config/models.js

@@ -1,4 +1,5 @@
 export const ALL_MODELS = [
+  { id: 'huggingface/Universal-618/Clarity-flash-weights', provider: 'huggingface', label: 'Clarity Flash 14B', badge: '128K' },
   { 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/config/theme.js

@@ -67,6 +67,9 @@ export const sym = {
   treeJ: '\u2514',
   treeT: '\u251C',
   treeCon: '\u2502',
+  triR2: '\u25B8',
+  triD2: '\u25BE',
+  u: { h: '\u2500' },
   treeTip: '\u2570',
   treeFork: '\u256D',
   star: '\u2726',

package/src/providers/index.js

@@ -3,6 +3,10 @@ import { streamResponse } from './streaming.js';
 import { parseErrorResponse } from './errors.js';
 
 const PROVIDERS = {
+  huggingface: {
+    endpoint: 'https://api-inference.huggingface.co/models',
+    name: 'huggingface',
+  },
   groq: {
     endpoint: 'https://api.groq.com/openai/v1/chat/completions',
     name: 'groq',
@@ -18,7 +22,9 @@ export async function* callAI(providerName, model, messages, options = {}) {
   if (!provider) throw { type: 'config_error', message: 'Unknown provider: ' + providerName };
 
   const key = getKey(providerName);
-  if (!key) throw { type: 'auth_error', provider: providerName, message: 'No API key set for ' + providerName, hint: '/keys ' + providerName + ' <your-key>' };
+  if (!key && providerName !== 'huggingface') {
+    throw { type: 'auth_error', provider: providerName, message: 'No API key set for ' + providerName, hint: '/keys ' + providerName + ' <your-key>' };
+  }
 
   const modelName = model.replace(/^[^/]+\//, '');
 
@@ -34,10 +40,17 @@ export async function* callAI(providerName, model, messages, options = {}) {
     body.tool_choice = 'auto';
   }
 
-  const endpoint = provider.endpoint;
-  const extraHeaders = providerName === 'openrouter' ? { 'HTTP-Referer': 'https://clarity-ai.local', 'X-Title': 'CLARITY AI' } : {};
+  let endpoint = provider.endpoint;
+  const extraHeaders = {};
+  if (providerName === 'huggingface') {
+    endpoint = provider.endpoint + '/' + modelName + '/v1/chat/completions';
+    if (key) extraHeaders['Authorization'] = 'Bearer ' + key;
+  } else if (providerName === 'openrouter') {
+    extraHeaders['HTTP-Referer'] = 'https://clarity-ai.local';
+    extraHeaders['X-Title'] = 'CLARITY AI';
+  }
 
-  const stream = streamResponse(endpoint, body, key, extraHeaders, options.signal);
+  const stream = streamResponse(endpoint, body, key || 'none', extraHeaders, options.signal);
   for await (const event of stream) {
     yield event;
   }