initial commit

.dockerignore

@@ -0,0 +1,7 @@
+.git
+.gitignore
+*.md
+deploy.sh
+onyx2api.service
+onyx2api
+onyx2api-linux-amd64

Dockerfile

@@ -0,0 +1,17 @@
+FROM golang:1.23-alpine AS builder
+WORKDIR /src
+
+COPY go.mod ./
+COPY main.go ./
+
+RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/onyx2api .
+
+FROM gcr.io/distroless/static-debian12:nonroot
+WORKDIR /
+
+COPY --from=builder /out/onyx2api /onyx2api
+
+ENV PORT=7860
+EXPOSE 7860
+
+ENTRYPOINT ["/onyx2api"]

README.md

@@ -0,0 +1,213 @@
+---
+title: ONYX
+emoji: "🚀"
+colorFrom: blue
+colorTo: green
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# onyx2api
+
+把 [Onyx Cloud](https://cloud.onyx.app) 包装成标准的 OpenAI / Anthropic API，Go 写的，单文件，零依赖，编译出来就一个二进制。
+
+说白了：你有 Onyx 的 Key，这东西帮你把它变成任何支持 OpenAI 或 Anthropic 协议的客户端都能直接用的接口。ChatGPT-Next-Web、LobeChat、Cursor、随便什么客户端，填个地址就能连。
+
+> [!NOTE]
+> 仅供学习和技术研究，请遵守 Onyx 使用条款及当地法律法规。
+
+## 跑起来
+
+三种方式，挑一个适合自己的。
+
+### 直接编译运行
+
+```bash
+git clone https://github.com/smysle/onyx2api-go.git
+cd onyx2api-go
+go build -o onyx2api .
+
+ONYX_KEYS="on_tenant_xxx" CLIENT_API_KEY="sk-456789" ./onyx2api
+```
+
+默认监听 `0.0.0.0:9898`，想换端口就加个 `PORT=7860`。
+
+### Docker
+
+```bash
+docker build -t onyx2api:latest .
+docker run --rm -p 7860:7860 \
+  -e PORT=7860 \
+  -e ONYX_KEYS=on_tenant_xxx \
+  -e CLIENT_API_KEY=sk-456789 \
+  onyx2api:latest
+```
+
+镜像用的 distroless，编译产物就几 MB，启动秒开。
+
+### 丢到 Hugging Face Spaces
+
+最省事的部署方式，白嫖 HF 的容器，不用自己搞服务器。
+
+参考实例：`https://huggingface.co/spaces/smyslenny/ONYX`（可以直接 Duplicate）
+
+**步骤：**
+
+1. 把代码推到你自己的 Space：
+
+```bash
+git clone https://github.com/smysle/onyx2api-go.git
+cd onyx2api-go
+git remote add hf https://huggingface.co/spaces/<你的用户名>/ONYX
+git push hf main
+```
+
+如果要求输密码，Username 填 HF 用户名，Password 填 Access Token（要有 write 权限）。
+
+2. 去 Space 的 **Settings → Variables and secrets** 里加两个 Secret：
+
+   - `ONYX_KEYS` = 你的 Onyx Key（多个用逗号隔开）
+   - `CLIENT_API_KEY` = 自己定一个密钥，给客户端用的
+
+3. 等它 Build 完，接口地址就是 `https://<你的用户名>-onyx.hf.space/v1`
+
+> [!TIP]
+> 别人 Duplicate 你的 Space 也能用，但 Secret 不会跟过去，得自己配。
+
+## 它能干什么
+
+**双协议兼容** — 同时暴露 OpenAI 和 Anthropic 两套接口，一个服务顶两个用：
+
+- `POST /v1/chat/completions` — OpenAI 格式，`Authorization: Bearer xxx` 鉴权
+- `POST /v1/messages` — Anthropic 格式，`x-api-key: xxx` 鉴权
+
+两个接口都支持流式（SSE）和非流式响应。
+
+**多 Key 轮询** — `ONYX_KEYS` 里填多个 Key（逗号分隔），请求会自动轮着用，原子操作无锁，不会有并发问题。
+
+**自动重试** — 遇到 502 / 503 / 504 / 429 会自动重试，最多 3 次，间隔 2s → 5s → 10s 递增。重试时还会自动换 Key（如果有多个的话）。
+
+**Reasoning 透传** — Onyx 返回的推理过程（thinking）会被正确翻译。OpenAI 格式走 `reasoning_content` 字段，Anthropic 格式走 `thinking` content block，下游客户端能正常展示思考链。
+
+**工具调用可视化** — Onyx 的搜索、网页抓取、代码执行、图片生成、深度研究等工具事件，都会被转成可读的文本块插入回复里，不会丢失上下文。
+
+## 接口一览
+
+| 方法 | 路径 | 用途 |
+|------|------|------|
+| `GET` | `/` | 服务信息，返回版本号和接口列表 |
+| `GET` | `/health` | 健康检查，顺便告诉你加载了几个 Key |
+| `GET` | `/v1/models` | 模型列表（OpenAI 格式） |
+| `POST` | `/v1/chat/completions` | OpenAI 兼容接口 |
+| `POST` | `/v1/messages` | Anthropic 兼容接口 |
+
+### 用 curl 试一下
+
+健康检查：
+
+```bash
+curl http://127.0.0.1:9898/health
+# {"status":"ok","version":"0.5.0","keys":1}
+```
+
+OpenAI 格式：
+
+```bash
+curl http://127.0.0.1:9898/v1/chat/completions \
+  -H "Authorization: Bearer sk-456789" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gpt-4o",
+    "messages": [{"role":"user","content":"你好"}],
+    "stream": false
+  }'
+```
+
+Anthropic 格式：
+
+```bash
+curl http://127.0.0.1:9898/v1/messages \
+  -H "x-api-key: sk-456789" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "claude-sonnet-4-6",
+    "messages": [{"role":"user","content":"你好"}],
+    "stream": false
+  }'
+```
+
+## 客户端接入
+
+大多数支持自定义 API 地址的客户端都能用。配置方法：
+
+| 配置项 | 本地部署 | HF Spaces |
+|--------|---------|-----------|
+| Base URL | `http://localhost:9898/v1` | `https://<用户名>-onyx.hf.space/v1` |
+| API Key | 你设的 `CLIENT_API_KEY` 值 | 同左 |
+
+Python 里用 `openai` 库的话：
+
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="http://localhost:9898/v1",
+    api_key="sk-456789",
+)
+
+resp = client.chat.completions.create(
+    model="claude-sonnet-4-6",
+    messages=[{"role": "user", "content": "你好"}],
+)
+print(resp.choices[0].message.content)
+```
+
+## 支持的模型
+
+内置了主流模型的映射，直接用模��名就行：
+
+**Anthropic**
+`claude-opus-4-6` · `claude-opus-4-5` · `claude-sonnet-4-6` · `claude-sonnet-4-5` · `claude-sonnet-4` · `claude-3-5-sonnet` · `claude-3-5-haiku` · `claude-3-opus` · `claude-haiku-4-5`
+
+**OpenAI**
+`gpt-4o` · `gpt-4o-mini` · `gpt-4-turbo` · `gpt-4` · `o1` · `o1-mini` · `o3-mini`
+
+**Google**
+`gemini-2.0-flash` · `gemini-2.5-pro`
+
+不在列表里的模型也能用，传 Onyx 的原始格式 `Provider__api__model_version` 就行，比如 `OpenAI__api__gpt-4o`。找不到映射的模型名会默认当 Anthropic 处理。
+
+## 环境变量
+
+| 变量 | 说明 | 默认 |
+|------|------|------|
+| `ONYX_KEYS` | Onyx API Key，多个逗号分隔 | **必填** |
+| `CLIENT_API_KEY` | 客户端鉴权密钥 | 空（不鉴权） |
+| `CLIENT_API_KEYS` | 多个客户端密钥，逗号分隔，设了这个会忽略上面那个 | 空 |
+| `PORT` | 监听端口 | `9898` |
+| `LISTEN_ADDR` | 完整监听地址，比如 `0.0.0.0:8080`，设了会忽略 `PORT` | 空 |
+
+请求体里还可以传一个 `persona_id`（整数），对应 Onyx 的 Persona，默认 `1`。
+
+## 常见问题
+
+**Q: Duplicate / Fork 了别人的项目，跑起来没反应？**
+
+Secret 不会跟着代码走。你得自己去 Space Settings 里把 `ONYX_KEYS` 和 `CLIENT_API_KEY` 填上。
+
+**Q: `/health` 返回的 `keys` 是 0？**
+
+说明没读到 `ONYX_KEYS`。本地跑检查一下环境变量有没有传对，HF 上检查 Space Secrets 配了没。
+
+**Q: 不设 `CLIENT_API_KEY` 行不行？**
+
+能跑，但公网部署别这么干。没有鉴权谁都能调，你的 Onyx 配额会被白嫖光。
+
+**Q: 流式响应断了 / 超时了？**
+
+默认请求超时 5 分钟。如果模型响应特别长（比如深度研究），可能会超。另外检查一下中间有没有反向代理在限制连接时长。
+
+**Q: 模型名写错了会怎样？**
+
+不会报错，会被当成 Anthropic 模型透传给 Onyx。Onyx 那边认不认就看它了。

go.mod

@@ -0,0 +1,3 @@
+module onyx2api
+
+go 1.23.6

main.go

@@ -0,0 +1,1361 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"strings"
+	"sync/atomic"
+	"time"
+)
+
+const (
+	onyxBase       = "https://cloud.onyx.app"
+	defaultPersona = 1
+	maxRetries     = 3
+	ver            = "0.5.0"
+)
+
+var (
+	retryBackoff = [3]time.Duration{2 * time.Second, 5 * time.Second, 10 * time.Second}
+	retryStatus  = map[int]bool{502: true, 503: true, 504: true, 429: true}
+	httpClient   = &http.Client{
+		Timeout: 5 * time.Minute,
+		Transport: &http.Transport{
+			Proxy: http.ProxyFromEnvironment,
+			DialContext: (&net.Dialer{
+				Timeout:   30 * time.Second,
+				KeepAlive: 30 * time.Second,
+			}).DialContext,
+			ForceAttemptHTTP2:     true,
+			MaxIdleConns:          200,
+			MaxIdleConnsPerHost:   100,
+			IdleConnTimeout:       90 * time.Second,
+			TLSHandshakeTimeout:   10 * time.Second,
+			ExpectContinueTimeout: 1 * time.Second,
+		},
+	}
+	keys       []string
+	clientKeys map[string]struct{}
+	keyIdx     uint64
+)
+
+// ── Key rotation ────────────────────────────────────────────────────────
+
+func nextKey() string {
+	n := len(keys)
+	if n == 0 {
+		return ""
+	}
+	return keys[atomic.AddUint64(&keyIdx, 1)%uint64(n)]
+}
+
+func extractToken(s string) string {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return ""
+	}
+	if strings.HasPrefix(strings.ToLower(s), "bearer ") {
+		return strings.TrimSpace(s[7:])
+	}
+	return s
+}
+
+func resolveAuth(headers ...string) string {
+	if len(keys) > 0 {
+		return nextKey()
+	}
+	for _, h := range headers {
+		if h != "" {
+			return extractToken(h)
+		}
+	}
+	return ""
+}
+
+func checkClientAuth(r *http.Request) bool {
+	if len(clientKeys) == 0 {
+		return true
+	}
+	token := strings.TrimSpace(r.Header.Get("x-api-key"))
+	if token == "" {
+		token = extractToken(r.Header.Get("Authorization"))
+	}
+	if token == "" {
+		return false
+	}
+	_, ok := clientKeys[token]
+	return ok
+}
+
+// ── Model mapping ───────────────────────────────────────────────────────
+
+type pm struct{ provider, version string }
+
+var modelMap = map[string]pm{
+	"claude-opus-4-6":   {"Anthropic", "claude-opus-4-6"},
+	"claude-opus-4-5":   {"Anthropic", "claude-opus-4-5"},
+	"claude-sonnet-4-6": {"Anthropic", "claude-sonnet-4-6"},
+	"claude-sonnet-4-5": {"Anthropic", "claude-sonnet-4-5"},
+	"claude-sonnet-4":   {"Anthropic", "claude-sonnet-4-20250514"},
+	"claude-3-5-sonnet": {"Anthropic", "claude-3-5-sonnet-20241022"},
+	"claude-3-5-haiku":  {"Anthropic", "claude-3-5-haiku-20241022"},
+	"claude-3-opus":     {"Anthropic", "claude-3-opus-20240229"},
+	"claude-haiku-4-5":  {"Anthropic", "claude-haiku-4-5"},
+	"gpt-4o":            {"OpenAI", "gpt-4o"},
+	"gpt-4o-mini":       {"OpenAI", "gpt-4o-mini"},
+	"gpt-4-turbo":       {"OpenAI", "gpt-4-turbo"},
+	"gpt-4":             {"OpenAI", "gpt-4"},
+	"o1":                {"OpenAI", "o1"},
+	"o1-mini":           {"OpenAI", "o1-mini"},
+	"o3-mini":           {"OpenAI", "o3-mini"},
+	"gemini-2.0-flash":  {"Google", "gemini-2.0-flash"},
+	"gemini-2.5-pro":    {"Google", "gemini-2.5-pro-preview-05-06"},
+}
+
+func buildLLMOverride(model string, temp float64) map[string]any {
+	m, ok := modelMap[model]
+	if !ok {
+		parts := strings.SplitN(model, "__", 3)
+		if len(parts) == 3 {
+			m = pm{parts[0], parts[2]}
+		} else {
+			m = pm{"Anthropic", model}
+		}
+	}
+	return map[string]any{"model_provider": m.provider, "model_version": m.version, "temperature": temp}
+}
+
+// ── Message conversion ──────────────────────────────────────────────────
+
+func textContent(raw any) string {
+	switch v := raw.(type) {
+	case string:
+		return v
+	case []any:
+		var parts []string
+		for _, item := range v {
+			if m, ok := item.(map[string]any); ok && m["type"] == "text" {
+				if s, ok := m["text"].(string); ok {
+					parts = append(parts, s)
+				}
+			}
+		}
+		return strings.Join(parts, "\n")
+	default:
+		return fmt.Sprint(v)
+	}
+}
+
+type chatMsg struct {
+	Role       string `json:"role"`
+	Content    any    `json:"content"`
+	ToolCallID string `json:"tool_call_id,omitempty"`
+}
+
+func messagesToOnyx(system string, msgs []chatMsg) string {
+	var conv []string
+	var lastUser string
+
+	for _, m := range msgs {
+		c := textContent(m.Content)
+		switch m.Role {
+		case "system":
+			if system == "" {
+				system = c
+			} else {
+				system += "\n" + c
+			}
+		case "user":
+			lastUser = c
+			conv = append(conv, "User: "+c)
+		case "assistant":
+			conv = append(conv, "Assistant: "+c)
+		case "tool":
+			tid := m.ToolCallID
+			if tid == "" {
+				tid = "unknown"
+			}
+			conv = append(conv, fmt.Sprintf("Tool result (%s): %s", tid, c))
+		}
+	}
+
+	if system == "" && len(conv) == 1 && len(msgs) == 1 && msgs[0].Role == "user" {
+		return lastUser
+	}
+	if system != "" && len(conv) == 1 && len(msgs) >= 1 {
+		return "[System: " + system + "]\n\n" + lastUser
+	}
+
+	var b strings.Builder
+	if system != "" {
+		b.WriteString("[System: " + system + "]\n\n")
+	}
+	b.WriteString(strings.Join(conv, "\n"))
+	return b.String()
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────
+
+func genID(prefix string) string {
+	b := make([]byte, 15)
+	if _, err := rand.Read(b); err != nil {
+		return fmt.Sprintf("%s%d", prefix, time.Now().UnixNano())
+	}
+	return prefix + hex.EncodeToString(b)[:29]
+}
+
+func toStrSlice(v any) []string {
+	arr, ok := v.([]any)
+	if !ok {
+		return nil
+	}
+	var out []string
+	for _, item := range arr {
+		if s, ok := item.(string); ok {
+			out = append(out, s)
+		}
+	}
+	return out
+}
+
+func writeJSON(w http.ResponseWriter, status int, v any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	json.NewEncoder(w).Encode(v)
+}
+
+func sleepOrDone(ctx context.Context, d time.Duration) bool {
+	t := time.NewTimer(d)
+	defer t.Stop()
+	select {
+	case <-ctx.Done():
+		return false
+	case <-t.C:
+		return true
+	}
+}
+
+// ── Core: send to Onyx with retry ──────────────────────────────────────
+
+type onyxError struct {
+	Status int
+	Body   string
+}
+
+func (e *onyxError) Error() string {
+	return fmt.Sprintf("Onyx HTTP %d: %s", e.Status, e.Body)
+}
+
+func doOnyxRequest(ctx context.Context, token, model string, msgs []chatMsg, system string, temp float64, persona int) (*http.Response, error) {
+	bodyBytes, err := json.Marshal(map[string]any{
+		"message":           messagesToOnyx(system, msgs),
+		"chat_session_info": map[string]any{"persona_id": persona},
+		"llm_override":      buildLLMOverride(model, temp),
+		"stream":            true,
+		"file_descriptors":  []any{},
+		"deep_research":     false,
+		"origin":            "api",
+	})
+	if err != nil {
+		return nil, fmt.Errorf("marshal onyx request: %w", err)
+	}
+
+	var lastErr error
+	for attempt := range maxRetries + 1 {
+		if err := ctx.Err(); err != nil {
+			return nil, err
+		}
+		cur := token
+		if attempt > 0 && len(keys) > 0 {
+			cur = nextKey()
+			log.Printf("Retry %d/%d, switched key", attempt, maxRetries)
+		}
+
+		req, err := http.NewRequestWithContext(
+			ctx,
+			http.MethodPost,
+			onyxBase+"/api/chat/send-chat-message",
+			bytes.NewReader(bodyBytes),
+		)
+		if err != nil {
+			return nil, fmt.Errorf("create onyx request: %w", err)
+		}
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set("Authorization", "Bearer "+cur)
+
+		resp, err := httpClient.Do(req)
+		if err != nil {
+			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+				return nil, err
+			}
+			lastErr = err
+			if attempt < maxRetries {
+				wait := retryBackoff[min(attempt, len(retryBackoff)-1)]
+				log.Printf("Attempt %d failed (%v), retry in %v", attempt+1, err, wait)
+				if !sleepOrDone(ctx, wait) {
+					return nil, ctx.Err()
+				}
+				continue
+			}
+			break
+		}
+
+		if resp.StatusCode != 200 {
+			body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
+			resp.Body.Close()
+			log.Printf("Onyx HTTP %d for model=%s: %s", resp.StatusCode, model, string(body))
+			if retryStatus[resp.StatusCode] && attempt < maxRetries {
+				wait := retryBackoff[min(attempt, len(retryBackoff)-1)]
+				log.Printf("Attempt %d failed (HTTP %d), retry in %v", attempt+1, resp.StatusCode, wait)
+				if !sleepOrDone(ctx, wait) {
+					return nil, ctx.Err()
+				}
+				continue
+			}
+			return nil, &onyxError{Status: resp.StatusCode, Body: string(body)}
+		}
+		return resp, nil
+	}
+	return nil, fmt.Errorf("all retries failed: %v", lastErr)
+}
+
+// ── Onyx NDJSON scanner ────────────────────────────────────────────────
+
+type onyxScanner struct {
+	sc *bufio.Scanner
+}
+
+type onyxEvent struct {
+	Type string
+	Obj  map[string]any
+	Err  string
+}
+
+func newOnyxScanner(r io.Reader) *onyxScanner {
+	sc := bufio.NewScanner(r)
+	sc.Buffer(make([]byte, 0, 64*1024), 1024*1024)
+	return &onyxScanner{sc: sc}
+}
+
+func (s *onyxScanner) Next() (onyxEvent, bool) {
+	for s.sc.Scan() {
+		line := strings.TrimSpace(s.sc.Text())
+		if line == "" {
+			continue
+		}
+		var raw map[string]any
+		if json.Unmarshal([]byte(line), &raw) != nil {
+			continue
+		}
+		if raw["user_message_id"] != nil {
+			continue
+		}
+		if raw["error"] != nil && raw["obj"] == nil {
+			return onyxEvent{Type: "error", Err: fmt.Sprint(raw["error"])}, true
+		}
+		obj, _ := raw["obj"].(map[string]any)
+		if obj == nil {
+			continue
+		}
+		t, _ := obj["type"].(string)
+		return onyxEvent{Type: t, Obj: obj}, true
+	}
+	return onyxEvent{}, false
+}
+
+// ══════════════════════════════════════════════════════════════════════════
+// OpenAI FORMAT
+// ══════════════════════════════════════════════════════════════════════════
+
+func sse(v any) []byte {
+	b, _ := json.Marshal(v)
+	return append(append([]byte("data: "), b...), '\n', '\n')
+}
+
+var sseDone = []byte("data: [DONE]\n\n")
+
+func makeChunk(id string, created int64, model string, delta map[string]any, finish *string) map[string]any {
+	return map[string]any{
+		"id": id, "object": "chat.completion.chunk", "created": created, "model": model,
+		"choices": []any{map[string]any{"index": 0, "delta": delta, "finish_reason": finish}},
+	}
+}
+
+func streamOpenAI(w io.Writer, flush func(), body io.Reader, model, rid string) {
+	created := time.Now().Unix()
+	sentRole := false
+	toolActive := false
+	stop := "stop"
+	scan := newOnyxScanner(body)
+
+	emit := func(delta map[string]any, fin *string) {
+		w.Write(sse(makeChunk(rid, created, model, delta, fin)))
+		flush()
+	}
+	ensureRole := func(d map[string]any) {
+		if !sentRole {
+			d["role"] = "assistant"
+			sentRole = true
+		}
+	}
+
+	for {
+		ev, ok := scan.Next()
+		if !ok {
+			break
+		}
+		if ev.Err != "" {
+			emit(map[string]any{"content": "\n\n[Error: " + ev.Err + "]"}, &stop)
+			w.Write(sseDone)
+			flush()
+			return
+		}
+		obj := ev.Obj
+		switch ev.Type {
+		case "reasoning_start", "reasoning_done":
+		case "reasoning_delta":
+			if s, _ := obj["reasoning"].(string); s != "" {
+				emit(map[string]any{"reasoning_content": s}, nil)
+			}
+		case "message_start":
+			if !sentRole {
+				emit(map[string]any{"role": "assistant", "content": ""}, nil)
+				sentRole = true
+			}
+		case "message_delta":
+			if c, _ := obj["content"].(string); c != "" {
+				d := map[string]any{"content": c}
+				ensureRole(d)
+				emit(d, nil)
+			}
+		case "search_tool_start":
+			toolActive = true
+			label := "Internal Search"
+			if v, _ := obj["is_internet_search"].(bool); v {
+				label = "Web Search"
+			}
+			d := map[string]any{"content": "\n[" + label + "] "}
+			ensureRole(d)
+			emit(d, nil)
+		case "search_tool_queries_delta":
+			if qs := toStrSlice(obj["queries"]); len(qs) > 0 {
+				var q []string
+				for _, s := range qs {
+					q = append(q, "\u201c"+s+"\u201d")
+				}
+				emit(map[string]any{"content": "Searching: " + strings.Join(q, ", ") + "\n"}, nil)
+			}
+		case "search_tool_documents_delta":
+			if docs, ok := obj["documents"].([]any); ok && len(docs) > 0 {
+				emit(map[string]any{"content": fmt.Sprintf("Found %d results.\n", len(docs))}, nil)
+			}
+		case "open_url_start":
+			toolActive = true
+			d := map[string]any{"content": "\n[Opening URL] "}
+			ensureRole(d)
+			emit(d, nil)
+		case "open_url_urls":
+			if urls := toStrSlice(obj["urls"]); len(urls) > 0 {
+				emit(map[string]any{"content": strings.Join(urls, ", ") + "\n"}, nil)
+			}
+		case "open_url_documents":
+			if docs, ok := obj["documents"].([]any); ok && len(docs) > 0 {
+				emit(map[string]any{"content": fmt.Sprintf("Loaded %d pages.\n", len(docs))}, nil)
+			}
+		case "image_generation_start":
+			toolActive = true
+			d := map[string]any{"content": "\n[Generating Image...]\n"}
+			ensureRole(d)
+			emit(d, nil)
+		case "image_generation_heartbeat":
+		case "image_generation_final":
+			if images, ok := obj["images"].([]any); ok {
+				for _, img := range images {
+					if m, ok := img.(map[string]any); ok {
+						u, _ := m["url"].(string)
+						p, _ := m["revised_prompt"].(string)
+						if u != "" {
+							emit(map[string]any{"content": fmt.Sprintf("![%s](%s)\n", p, u)}, nil)
+						}
+					}
+				}
+			}
+		case "python_tool_start":
+			toolActive = true
+			code, _ := obj["code"].(string)
+			text := "\n[Code Interpreter]\n"
+			if code != "" {
+				text += "```python\n" + code + "\n```\n"
+			}
+			d := map[string]any{"content": text}
+			ensureRole(d)
+			emit(d, nil)
+		case "python_tool_delta":
+			var parts []string
+			if s, _ := obj["stdout"].(string); s != "" {
+				parts = append(parts, "Output: "+s)
+			}
+			if s, _ := obj["stderr"].(string); s != "" {
+				parts = append(parts, "Error: "+s)
+			}
+			if len(parts) > 0 {
+				emit(map[string]any{"content": strings.Join(parts, "\n") + "\n"}, nil)
+			}
+		case "custom_tool_start":
+			toolActive = true
+			tn, _ := obj["tool_name"].(string)
+			if tn == "" {
+				tn = "custom_tool"
+			}
+			d := map[string]any{"content": "\n[Tool: " + tn + "]\n"}
+			ensureRole(d)
+			emit(d, nil)
+		case "custom_tool_delta":
+			if td := obj["data"]; td != nil {
+				var text string
+				if m, ok := td.(map[string]any); ok {
+					b, _ := json.Marshal(m)
+					text = string(b)
+				} else {
+					text = fmt.Sprint(td)
+				}
+				if text != "" {
+					emit(map[string]any{"content": text + "\n"}, nil)
+				}
+			}
+		case "file_reader_start":
+			toolActive = true
+			d := map[string]any{"content": "\n[Reading File...]\n"}
+			ensureRole(d)
+			emit(d, nil)
+		case "file_reader_result":
+			if fn, _ := obj["file_name"].(string); fn != "" {
+				emit(map[string]any{"content": "Read: " + fn + "\n"}, nil)
+			}
+		case "deep_research_plan_start":
+			d := map[string]any{"content": "\n[Research Plan]\n"}
+			ensureRole(d)
+			emit(d, nil)
+		case "deep_research_plan_delta", "intermediate_report_start", "intermediate_report_delta":
+			if c, _ := obj["content"].(string); c != "" {
+				emit(map[string]any{"content": c}, nil)
+			}
+		case "research_agent_start":
+			task, _ := obj["research_task"].(string)
+			emit(map[string]any{"content": "\n[Researching: " + task + "]\n"}, nil)
+		case "memory_tool_start", "memory_tool_delta", "memory_tool_no_access",
+			"citation_info", "top_level_branching", "intermediate_report_cited_docs", "tool_call_debug":
+		case "section_end":
+			if toolActive {
+				emit(map[string]any{"content": "\n"}, nil)
+				toolActive = false
+			}
+		case "stop":
+			emit(map[string]any{}, &stop)
+			w.Write(sseDone)
+			flush()
+			return
+		case "error":
+			msg, _ := obj["error"].(string)
+			if msg == "" {
+				msg = "Unknown error"
+			}
+			emit(map[string]any{"content": "\n[Error: " + msg + "]"}, &stop)
+			w.Write(sseDone)
+			flush()
+			return
+		default:
+			if ev.Type != "" {
+				log.Printf("Unknown SSE event: %s", ev.Type)
+			}
+		}
+	}
+	w.Write(sseDone)
+	flush()
+}
+
+func collectOpenAI(body io.Reader) string {
+	var parts, toolCtx []string
+	scan := newOnyxScanner(body)
+	for {
+		ev, ok := scan.Next()
+		if !ok {
+			break
+		}
+		if ev.Err != "" {
+			parts = append(parts, "\n[Error: "+ev.Err+"]")
+			break
+		}
+		obj := ev.Obj
+		switch ev.Type {
+		case "message_delta":
+			if c, _ := obj["content"].(string); c != "" {
+				parts = append(parts, c)
+			}
+		case "search_tool_start":
+			label := "Internal Search"
+			if v, _ := obj["is_internet_search"].(bool); v {
+				label = "Web Search"
+			}
+			toolCtx = append(toolCtx, "["+label+"]")
+		case "search_tool_queries_delta":
+			if qs := toStrSlice(obj["queries"]); len(qs) > 0 {
+				toolCtx = append(toolCtx, "Searching: "+strings.Join(qs, ", "))
+			}
+		case "search_tool_documents_delta":
+			if docs, ok := obj["documents"].([]any); ok && len(docs) > 0 {
+				toolCtx = append(toolCtx, fmt.Sprintf("Found %d results.", len(docs)))
+			}
+		case "open_url_start":
+			toolCtx = append(toolCtx, "[Opening URL]")
+		case "open_url_urls":
+			if urls := toStrSlice(obj["urls"]); len(urls) > 0 {
+				toolCtx = append(toolCtx, strings.Join(urls, ", "))
+			}
+		case "python_tool_start":
+			code, _ := obj["code"].(string)
+			toolCtx = append(toolCtx, "[Code Interpreter]\n```python\n"+code+"\n```")
+		case "python_tool_delta":
+			if s, _ := obj["stdout"].(string); s != "" {
+				toolCtx = append(toolCtx, "Output: "+s)
+			}
+			if s, _ := obj["stderr"].(string); s != "" {
+				toolCtx = append(toolCtx, "Error: "+s)
+			}
+		case "image_generation_final":
+			if images, ok := obj["images"].([]any); ok {
+				for _, img := range images {
+					if m, ok := img.(map[string]any); ok {
+						u, _ := m["url"].(string)
+						p, _ := m["revised_prompt"].(string)
+						if u != "" {
+							toolCtx = append(toolCtx, fmt.Sprintf("![%s](%s)", p, u))
+						}
+					}
+				}
+			}
+		case "custom_tool_start":
+			tn, _ := obj["tool_name"].(string)
+			toolCtx = append(toolCtx, "[Tool: "+tn+"]")
+		case "custom_tool_delta":
+			if td := obj["data"]; td != nil {
+				toolCtx = append(toolCtx, fmt.Sprint(td))
+			}
+		case "error":
+			msg, _ := obj["error"].(string)
+			parts = append(parts, "\n[Error: "+msg+"]")
+		case "stop":
+			goto done
+		}
+	}
+done:
+	var b strings.Builder
+	if len(toolCtx) > 0 {
+		b.WriteString(strings.Join(toolCtx, "\n") + "\n\n")
+	}
+	for _, p := range parts {
+		b.WriteString(p)
+	}
+	return b.String()
+}
+
+// ══════════════════════════════════════════════════════════════════════════
+// Anthropic FORMAT
+// ══════════════════════════════════════════════════════════════════════════
+
+func anthropicSSE(event string, data any) []byte {
+	b, _ := json.Marshal(data)
+	return []byte("event: " + event + "\ndata: " + string(b) + "\n\n")
+}
+
+func streamAnthropic(w io.Writer, flush func(), body io.Reader, model, rid string) {
+	scan := newOnyxScanner(body)
+	blockIdx := 0
+	inThinking := false
+	inText := false
+
+	// message_start
+	w.Write(anthropicSSE("message_start", map[string]any{
+		"type": "message_start",
+		"message": map[string]any{
+			"id": rid, "type": "message", "role": "assistant", "model": model,
+			"content": []any{}, "stop_reason": nil,
+			"usage": map[string]any{"input_tokens": 0, "output_tokens": 0},
+		},
+	}))
+	flush()
+
+	startBlock := func(btype string) {
+		block := map[string]any{"type": btype}
+		if btype == "thinking" {
+			block["thinking"] = ""
+		} else {
+			block["text"] = ""
+		}
+		w.Write(anthropicSSE("content_block_start", map[string]any{
+			"type": "content_block_start", "index": blockIdx, "content_block": block,
+		}))
+		flush()
+	}
+	stopBlock := func() {
+		w.Write(anthropicSSE("content_block_stop", map[string]any{
+			"type": "content_block_stop", "index": blockIdx,
+		}))
+		flush()
+		blockIdx++
+	}
+	finishMsg := func(reason string) {
+		if inThinking {
+			stopBlock()
+			inThinking = false
+		}
+		if inText {
+			stopBlock()
+			inText = false
+		}
+		w.Write(anthropicSSE("message_delta", map[string]any{
+			"type":  "message_delta",
+			"delta": map[string]any{"stop_reason": reason},
+			"usage": map[string]any{"output_tokens": 0},
+		}))
+		w.Write(anthropicSSE("message_stop", map[string]any{"type": "message_stop"}))
+		flush()
+	}
+
+	for {
+		ev, ok := scan.Next()
+		if !ok {
+			break
+		}
+		if ev.Err != "" {
+			if !inText {
+				startBlock("text")
+				inText = true
+			}
+			w.Write(anthropicSSE("content_block_delta", map[string]any{
+				"type": "content_block_delta", "index": blockIdx,
+				"delta": map[string]any{"type": "text_delta", "text": "\n[Error: " + ev.Err + "]"},
+			}))
+			flush()
+			finishMsg("end_turn")
+			return
+		}
+		obj := ev.Obj
+		switch ev.Type {
+		case "reasoning_start":
+			if !inThinking {
+				startBlock("thinking")
+				inThinking = true
+			}
+		case "reasoning_delta":
+			if s, _ := obj["reasoning"].(string); s != "" {
+				if !inThinking {
+					startBlock("thinking")
+					inThinking = true
+				}
+				w.Write(anthropicSSE("content_block_delta", map[string]any{
+					"type": "content_block_delta", "index": blockIdx,
+					"delta": map[string]any{"type": "thinking_delta", "thinking": s},
+				}))
+				flush()
+			}
+		case "reasoning_done":
+			if inThinking {
+				stopBlock()
+				inThinking = false
+			}
+		case "message_start":
+			if !inText {
+				if inThinking {
+					stopBlock()
+					inThinking = false
+				}
+				startBlock("text")
+				inText = true
+			}
+		case "message_delta":
+			if c, _ := obj["content"].(string); c != "" {
+				if !inText {
+					if inThinking {
+						stopBlock()
+						inThinking = false
+					}
+					startBlock("text")
+					inText = true
+				}
+				w.Write(anthropicSSE("content_block_delta", map[string]any{
+					"type": "content_block_delta", "index": blockIdx,
+					"delta": map[string]any{"type": "text_delta", "text": c},
+				}))
+				flush()
+			}
+
+		// ── Tool events → text deltas ──
+		case "search_tool_start":
+			if !inText {
+				if inThinking {
+					stopBlock()
+					inThinking = false
+				}
+				startBlock("text")
+				inText = true
+			}
+			label := "Internal Search"
+			if v, _ := obj["is_internet_search"].(bool); v {
+				label = "Web Search"
+			}
+			w.Write(anthropicSSE("content_block_delta", map[string]any{
+				"type": "content_block_delta", "index": blockIdx,
+				"delta": map[string]any{"type": "text_delta", "text": "\n[" + label + "] "},
+			}))
+			flush()
+		case "search_tool_queries_delta":
+			if qs := toStrSlice(obj["queries"]); len(qs) > 0 {
+				var q []string
+				for _, s := range qs {
+					q = append(q, "\u201c"+s+"\u201d")
+				}
+				w.Write(anthropicSSE("content_block_delta", map[string]any{
+					"type": "content_block_delta", "index": blockIdx,
+					"delta": map[string]any{"type": "text_delta", "text": "Searching: " + strings.Join(q, ", ") + "\n"},
+				}))
+				flush()
+			}
+		case "search_tool_documents_delta":
+			if docs, ok := obj["documents"].([]any); ok && len(docs) > 0 {
+				w.Write(anthropicSSE("content_block_delta", map[string]any{
+					"type": "content_block_delta", "index": blockIdx,
+					"delta": map[string]any{"type": "text_delta", "text": fmt.Sprintf("Found %d results.\n", len(docs))},
+				}))
+				flush()
+			}
+		case "open_url_start", "python_tool_start", "custom_tool_start",
+			"image_generation_start", "file_reader_start", "deep_research_plan_start":
+			if !inText {
+				if inThinking {
+					stopBlock()
+					inThinking = false
+				}
+				startBlock("text")
+				inText = true
+			}
+			var label string
+			switch ev.Type {
+			case "open_url_start":
+				label = "[Opening URL] "
+			case "python_tool_start":
+				code, _ := obj["code"].(string)
+				label = "[Code Interpreter]\n"
+				if code != "" {
+					label += "```python\n" + code + "\n```\n"
+				}
+			case "custom_tool_start":
+				tn, _ := obj["tool_name"].(string)
+				if tn == "" {
+					tn = "custom_tool"
+				}
+				label = "[Tool: " + tn + "]\n"
+			case "image_generation_start":
+				label = "[Generating Image...]\n"
+			case "file_reader_start":
+				label = "[Reading File...]\n"
+			case "deep_research_plan_start":
+				label = "[Research Plan]\n"
+			}
+			w.Write(anthropicSSE("content_block_delta", map[string]any{
+				"type": "content_block_delta", "index": blockIdx,
+				"delta": map[string]any{"type": "text_delta", "text": "\n" + label},
+			}))
+			flush()
+		case "open_url_urls":
+			if urls := toStrSlice(obj["urls"]); len(urls) > 0 {
+				w.Write(anthropicSSE("content_block_delta", map[string]any{
+					"type": "content_block_delta", "index": blockIdx,
+					"delta": map[string]any{"type": "text_delta", "text": strings.Join(urls, ", ") + "\n"},
+				}))
+				flush()
+			}
+		case "open_url_documents":
+			if docs, ok := obj["documents"].([]any); ok && len(docs) > 0 {
+				w.Write(anthropicSSE("content_block_delta", map[string]any{
+					"type": "content_block_delta", "index": blockIdx,
+					"delta": map[string]any{"type": "text_delta", "text": fmt.Sprintf("Loaded %d pages.\n", len(docs))},
+				}))
+				flush()
+			}
+		case "python_tool_delta":
+			var parts []string
+			if s, _ := obj["stdout"].(string); s != "" {
+				parts = append(parts, "Output: "+s)
+			}
+			if s, _ := obj["stderr"].(string); s != "" {
+				parts = append(parts, "Error: "+s)
+			}
+			if len(parts) > 0 {
+				w.Write(anthropicSSE("content_block_delta", map[string]any{
+					"type": "content_block_delta", "index": blockIdx,
+					"delta": map[string]any{"type": "text_delta", "text": strings.Join(parts, "\n") + "\n"},
+				}))
+				flush()
+			}
+		case "custom_tool_delta":
+			if td := obj["data"]; td != nil {
+				var text string
+				if m, ok := td.(map[string]any); ok {
+					b, _ := json.Marshal(m)
+					text = string(b)
+				} else {
+					text = fmt.Sprint(td)
+				}
+				if text != "" {
+					w.Write(anthropicSSE("content_block_delta", map[string]any{
+						"type": "content_block_delta", "index": blockIdx,
+						"delta": map[string]any{"type": "text_delta", "text": text + "\n"},
+					}))
+					flush()
+				}
+			}
+		case "image_generation_final":
+			if images, ok := obj["images"].([]any); ok {
+				for _, img := range images {
+					if m, ok := img.(map[string]any); ok {
+						u, _ := m["url"].(string)
+						p, _ := m["revised_prompt"].(string)
+						if u != "" {
+							w.Write(anthropicSSE("content_block_delta", map[string]any{
+								"type": "content_block_delta", "index": blockIdx,
+								"delta": map[string]any{"type": "text_delta", "text": fmt.Sprintf("![%s](%s)\n", p, u)},
+							}))
+							flush()
+						}
+					}
+				}
+			}
+		case "file_reader_result":
+			if fn, _ := obj["file_name"].(string); fn != "" {
+				w.Write(anthropicSSE("content_block_delta", map[string]any{
+					"type": "content_block_delta", "index": blockIdx,
+					"delta": map[string]any{"type": "text_delta", "text": "Read: " + fn + "\n"},
+				}))
+				flush()
+			}
+		case "deep_research_plan_delta", "intermediate_report_start",
+			"intermediate_report_delta":
+			if c, _ := obj["content"].(string); c != "" {
+				w.Write(anthropicSSE("content_block_delta", map[string]any{
+					"type": "content_block_delta", "index": blockIdx,
+					"delta": map[string]any{"type": "text_delta", "text": c},
+				}))
+				flush()
+			}
+		case "research_agent_start":
+			task, _ := obj["research_task"].(string)
+			w.Write(anthropicSSE("content_block_delta", map[string]any{
+				"type": "content_block_delta", "index": blockIdx,
+				"delta": map[string]any{"type": "text_delta", "text": "\n[Researching: " + task + "]\n"},
+			}))
+			flush()
+		case "image_generation_heartbeat", "memory_tool_start", "memory_tool_delta",
+			"memory_tool_no_access", "citation_info", "top_level_branching",
+			"intermediate_report_cited_docs", "tool_call_debug":
+		case "section_end":
+			// skip
+		case "stop":
+			finishMsg("end_turn")
+			return
+		case "error":
+			msg, _ := obj["error"].(string)
+			if msg == "" {
+				msg = "Unknown error"
+			}
+			if !inText {
+				startBlock("text")
+				inText = true
+			}
+			w.Write(anthropicSSE("content_block_delta", map[string]any{
+				"type": "content_block_delta", "index": blockIdx,
+				"delta": map[string]any{"type": "text_delta", "text": "\n[Error: " + msg + "]"},
+			}))
+			flush()
+			finishMsg("end_turn")
+			return
+		default:
+			if ev.Type != "" {
+				log.Printf("Unknown SSE event: %s", ev.Type)
+			}
+		}
+	}
+	finishMsg("end_turn")
+}
+
+func collectAnthropic(body io.Reader) (text, thinking string) {
+	var textParts, thinkParts, toolCtx []string
+	scan := newOnyxScanner(body)
+	for {
+		ev, ok := scan.Next()
+		if !ok {
+			break
+		}
+		if ev.Err != "" {
+			textParts = append(textParts, "\n[Error: "+ev.Err+"]")
+			break
+		}
+		obj := ev.Obj
+		switch ev.Type {
+		case "reasoning_delta":
+			if s, _ := obj["reasoning"].(string); s != "" {
+				thinkParts = append(thinkParts, s)
+			}
+		case "message_delta":
+			if c, _ := obj["content"].(string); c != "" {
+				textParts = append(textParts, c)
+			}
+		case "search_tool_start":
+			label := "Internal Search"
+			if v, _ := obj["is_internet_search"].(bool); v {
+				label = "Web Search"
+			}
+			toolCtx = append(toolCtx, "["+label+"]")
+		case "search_tool_queries_delta":
+			if qs := toStrSlice(obj["queries"]); len(qs) > 0 {
+				toolCtx = append(toolCtx, "Searching: "+strings.Join(qs, ", "))
+			}
+		case "search_tool_documents_delta":
+			if docs, ok := obj["documents"].([]any); ok && len(docs) > 0 {
+				toolCtx = append(toolCtx, fmt.Sprintf("Found %d results.", len(docs)))
+			}
+		case "open_url_start":
+			toolCtx = append(toolCtx, "[Opening URL]")
+		case "open_url_urls":
+			if urls := toStrSlice(obj["urls"]); len(urls) > 0 {
+				toolCtx = append(toolCtx, strings.Join(urls, ", "))
+			}
+		case "python_tool_start":
+			code, _ := obj["code"].(string)
+			toolCtx = append(toolCtx, "[Code Interpreter]\n```python\n"+code+"\n```")
+		case "python_tool_delta":
+			if s, _ := obj["stdout"].(string); s != "" {
+				toolCtx = append(toolCtx, "Output: "+s)
+			}
+			if s, _ := obj["stderr"].(string); s != "" {
+				toolCtx = append(toolCtx, "Error: "+s)
+			}
+		case "image_generation_final":
+			if images, ok := obj["images"].([]any); ok {
+				for _, img := range images {
+					if m, ok := img.(map[string]any); ok {
+						u, _ := m["url"].(string)
+						p, _ := m["revised_prompt"].(string)
+						if u != "" {
+							toolCtx = append(toolCtx, fmt.Sprintf("![%s](%s)", p, u))
+						}
+					}
+				}
+			}
+		case "custom_tool_start":
+			tn, _ := obj["tool_name"].(string)
+			toolCtx = append(toolCtx, "[Tool: "+tn+"]")
+		case "custom_tool_delta":
+			if td := obj["data"]; td != nil {
+				toolCtx = append(toolCtx, fmt.Sprint(td))
+			}
+		case "error":
+			msg, _ := obj["error"].(string)
+			textParts = append(textParts, "\n[Error: "+msg+"]")
+		case "stop":
+			goto done
+		}
+	}
+done:
+	var tb strings.Builder
+	if len(toolCtx) > 0 {
+		tb.WriteString(strings.Join(toolCtx, "\n") + "\n\n")
+	}
+	for _, p := range textParts {
+		tb.WriteString(p)
+	}
+	return tb.String(), strings.Join(thinkParts, "")
+}
+
+// ══════════════════════════════════════════════════════════════════════════
+// HTTP HANDLERS
+// ══════════════════════════════════════════════════════════════════════════
+
+func handleModels(w http.ResponseWriter, r *http.Request) {
+	models := []string{
+		"claude-opus-4-6", "claude-opus-4-5",
+		"claude-sonnet-4-6", "claude-sonnet-4-5", "claude-sonnet-4",
+		"claude-3-5-sonnet", "claude-3-5-haiku", "claude-haiku-4-5",
+		"gpt-4o", "gpt-4o-mini", "o1", "o3-mini",
+		"gemini-2.0-flash", "gemini-2.5-pro",
+	}
+	data := make([]any, len(models))
+	for i, m := range models {
+		data[i] = map[string]any{"id": m, "object": "model", "created": 1700000000, "owned_by": "onyx"}
+	}
+	writeJSON(w, 200, map[string]any{"object": "list", "data": data})
+}
+
+func handleHealth(w http.ResponseWriter, r *http.Request) {
+	writeJSON(w, 200, map[string]any{"status": "ok", "version": ver, "keys": len(keys)})
+}
+
+func handleRoot(w http.ResponseWriter, r *http.Request) {
+	if r.URL.Path != "/" {
+		http.NotFound(w, r)
+		return
+	}
+	writeJSON(w, 200, map[string]any{
+		"name":      "onyx2api",
+		"version":   ver,
+		"endpoints": []string{"/v1/chat/completions", "/v1/messages", "/v1/models", "/health"},
+	})
+}
+
+// ── OpenAI: POST /v1/chat/completions ──
+
+type openaiReq struct {
+	Model       string    `json:"model"`
+	Messages    []chatMsg `json:"messages"`
+	Stream      bool      `json:"stream"`
+	Temperature *float64  `json:"temperature,omitempty"`
+	PersonaID   *int      `json:"persona_id,omitempty"`
+}
+
+func handleOpenAI(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		writeJSON(w, 405, map[string]any{"error": "method not allowed"})
+		return
+	}
+	if !checkClientAuth(r) {
+		writeJSON(w, 401, map[string]any{"error": "invalid api key"})
+		return
+	}
+	var req openaiReq
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSON(w, 400, map[string]any{"error": "invalid JSON"})
+		return
+	}
+	token := resolveAuth(r.Header.Get("Authorization"))
+	if token == "" {
+		writeJSON(w, 401, map[string]any{"error": "No auth. Set ONYX_KEYS env var."})
+		return
+	}
+	if len(req.Messages) == 0 {
+		writeJSON(w, 400, map[string]any{"error": "messages is required"})
+		return
+	}
+
+	model := req.Model
+	if model == "" {
+		model = "claude-opus-4-6"
+	}
+	temp := 0.5
+	if req.Temperature != nil {
+		temp = *req.Temperature
+	}
+	persona := defaultPersona
+	if req.PersonaID != nil {
+		persona = *req.PersonaID
+	}
+
+	rid := genID("chatcmpl-")
+	resp, err := doOnyxRequest(r.Context(), token, model, req.Messages, "", temp, persona)
+	if err != nil {
+		if oe, ok := err.(*onyxError); ok {
+			writeJSON(w, oe.Status, map[string]any{"error": oe.Error(), "detail": oe.Body})
+		} else {
+			writeJSON(w, 502, map[string]any{"error": err.Error()})
+		}
+		return
+	}
+	defer resp.Body.Close()
+
+	if req.Stream {
+		w.Header().Set("Content-Type", "text/event-stream")
+		w.Header().Set("Cache-Control", "no-cache")
+		w.Header().Set("Connection", "keep-alive")
+		w.Header().Set("X-Accel-Buffering", "no")
+		flusher, ok := w.(http.Flusher)
+		if !ok {
+			writeJSON(w, 500, map[string]any{"error": "streaming unsupported"})
+			return
+		}
+		streamOpenAI(w, flusher.Flush, resp.Body, model, rid)
+	} else {
+		content := collectOpenAI(resp.Body)
+		writeJSON(w, 200, map[string]any{
+			"id": rid, "object": "chat.completion", "created": time.Now().Unix(), "model": model,
+			"choices": []any{map[string]any{
+				"index": 0, "message": map[string]any{"role": "assistant", "content": content},
+				"finish_reason": "stop",
+			}},
+			"usage": map[string]any{"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
+		})
+	}
+}
+
+// ── Anthropic: POST /v1/messages ──
+
+type anthropicReq struct {
+	Model       string    `json:"model"`
+	Messages    []chatMsg `json:"messages"`
+	System      any       `json:"system,omitempty"` // string or []content_block
+	Stream      bool      `json:"stream"`
+	MaxTokens   int       `json:"max_tokens,omitempty"`
+	Temperature *float64  `json:"temperature,omitempty"`
+	PersonaID   *int      `json:"persona_id,omitempty"`
+}
+
+func handleAnthropic(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		writeJSON(w, 405, map[string]any{"error": map[string]any{"type": "invalid_request_error", "message": "method not allowed"}})
+		return
+	}
+	if !checkClientAuth(r) {
+		writeJSON(w, 401, map[string]any{"type": "error", "error": map[string]any{"type": "authentication_error", "message": "invalid api key"}})
+		return
+	}
+	var req anthropicReq
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSON(w, 400, map[string]any{"type": "error", "error": map[string]any{"type": "invalid_request_error", "message": "invalid JSON"}})
+		return
+	}
+	token := resolveAuth(r.Header.Get("x-api-key"), r.Header.Get("Authorization"))
+	if token == "" {
+		writeJSON(w, 401, map[string]any{"type": "error", "error": map[string]any{"type": "authentication_error", "message": "No auth. Set ONYX_KEYS env var."}})
+		return
+	}
+	if len(req.Messages) == 0 {
+		writeJSON(w, 400, map[string]any{"type": "error", "error": map[string]any{"type": "invalid_request_error", "message": "messages is required"}})
+		return
+	}
+
+	model := req.Model
+	if model == "" {
+		model = "claude-opus-4-6"
+	}
+	temp := 0.5
+	if req.Temperature != nil {
+		temp = *req.Temperature
+	}
+	persona := defaultPersona
+	if req.PersonaID != nil {
+		persona = *req.PersonaID
+	}
+
+	system := textContent(req.System)
+
+	rid := genID("msg_")
+	resp, err := doOnyxRequest(r.Context(), token, model, req.Messages, system, temp, persona)
+	if err != nil {
+		if oe, ok := err.(*onyxError); ok {
+			writeJSON(w, oe.Status, map[string]any{"type": "error", "error": map[string]any{"type": "api_error", "message": oe.Error()}})
+		} else {
+			writeJSON(w, 502, map[string]any{"type": "error", "error": map[string]any{"type": "api_error", "message": err.Error()}})
+		}
+		return
+	}
+	defer resp.Body.Close()
+
+	if req.Stream {
+		w.Header().Set("Content-Type", "text/event-stream")
+		w.Header().Set("Cache-Control", "no-cache")
+		w.Header().Set("Connection", "keep-alive")
+		w.Header().Set("X-Accel-Buffering", "no")
+		flusher, ok := w.(http.Flusher)
+		if !ok {
+			writeJSON(w, 500, map[string]any{"type": "error", "error": map[string]any{"type": "api_error", "message": "streaming unsupported"}})
+			return
+		}
+		streamAnthropic(w, flusher.Flush, resp.Body, model, rid)
+	} else {
+		text, thinking := collectAnthropic(resp.Body)
+		var content []any
+		if thinking != "" {
+			content = append(content, map[string]any{"type": "thinking", "thinking": thinking})
+		}
+		content = append(content, map[string]any{"type": "text", "text": text})
+		writeJSON(w, 200, map[string]any{
+			"id": rid, "type": "message", "role": "assistant", "model": model,
+			"content":     content,
+			"stop_reason": "end_turn",
+			"usage":       map[string]any{"input_tokens": 0, "output_tokens": 0},
+		})
+	}
+}
+
+// ── Main ────────────────────────────────────────────────────────────────
+
+func main() {
+	if env := os.Getenv("ONYX_KEYS"); env != "" {
+		for _, k := range strings.Split(env, ",") {
+			if k = strings.TrimSpace(k); k != "" {
+				keys = append(keys, k)
+			}
+		}
+	}
+	if env := firstNonEmpty(os.Getenv("CLIENT_API_KEYS"), os.Getenv("CLIENT_API_KEY")); env != "" {
+		clientKeys = map[string]struct{}{}
+		for _, k := range strings.Split(env, ",") {
+			if k = strings.TrimSpace(k); k != "" {
+				clientKeys[k] = struct{}{}
+			}
+		}
+	}
+	if len(clientKeys) > 0 && len(keys) == 0 {
+		log.Fatal("CLIENT_API_KEYS/CLIENT_API_KEY requires ONYX_KEYS to be set")
+	}
+	listenAddr := resolveListenAddr()
+
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", handleRoot)
+	mux.HandleFunc("/v1/chat/completions", handleOpenAI)
+	mux.HandleFunc("/v1/messages", handleAnthropic)
+	mux.HandleFunc("/v1/models", handleModels)
+	mux.HandleFunc("/health", handleHealth)
+
+	srv := &http.Server{
+		Addr:              listenAddr,
+		Handler:           mux,
+		ReadHeaderTimeout: 10 * time.Second,
+		ReadTimeout:       60 * time.Second,
+		IdleTimeout:       120 * time.Second,
+	}
+	log.Printf("onyx2api v%s | onyx_keys=%d | client_keys=%d | listen=%s", ver, len(keys), len(clientKeys), listenAddr)
+	log.Fatal(srv.ListenAndServe())
+}
+
+func firstNonEmpty(vals ...string) string {
+	for _, v := range vals {
+		if strings.TrimSpace(v) != "" {
+			return v
+		}
+	}
+	return ""
+}
+
+func resolveListenAddr() string {
+	if addr := strings.TrimSpace(os.Getenv("LISTEN_ADDR")); addr != "" {
+		return addr
+	}
+	port := strings.TrimSpace(os.Getenv("PORT"))
+	if port == "" {
+		port = "9898"
+	}
+	if strings.Contains(port, ":") {
+		return port
+	}
+	return ":" + port
+}