Thun Murex API

Overview

Thun Murex is a gateway running on thun-latitude-7280. Apps send it one kind of request, and it answers from any of seven providers: three cloud APIs, and four coding CLIs (command-line AI tools) running on the machine itself.

Requests and responses are JSON in the OpenAI chat format, so most OpenAI-style code works once you change the address and the key. The gateway can only be reached from devices on your Tailscale network.

Leave provider out and the request goes to SEA-LION. To see every model you can choose, call GET /api/models.

Authentication

Every request needs a key in the Authorization header:

Authorization: Bearer <your key>

There are two kinds of key:

• Owner key (APP_API_KEY): can call every endpoint and sign in to the console. Keep it to yourself.
• Access tokens (sk-ai-thun-…): created on the console’s API keys page, one per app or person, or by people with an account on their own account page. They can only send requests to providers and read their own balance at /api/me. Each one has limits, an expiry date and providers: its own, or for an account’s keys, the account’s plan, which they all share.

A missing or wrong key gets 401 with {"error": "Unauthorized"}. Keys are secrets: call the gateway from your own server or scripts, not from code that runs in someone’s web browser.

• Wrong keys lock you out for a while. After 10 wrong keys in 10 minutes from one address, every request from there gets 429 for 15 minutes, with a Retry-After header, even with the right key.
• The console sends your owner key once, to sign in. The browser then keeps a sign-in cookie for 7 days, which the page’s scripts can’t read, never the key itself. A new APP_API_KEY signs everyone out.

Quickstart

1. Put the gateway’s address and your key in two variables. The examples on this page use them.

export AI_THUN_URL="https://your-ai-thun-host"
export AI_THUN_KEY="sk-ai-thun-…"   # an access token, or your APP_API_KEY

2. Send a message:

curl "$AI_THUN_URL/api/chat" \
  -H "Authorization: Bearer $AI_THUN_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": "groq",
    "messages": [{"role": "user", "content": "Write a haiku about Phnom Penh"}]
  }'

3. The answer is in choices[0].message.content:

{
  "id": "chatcmpl-…",
  "object": "chat.completion",
  "model": "openai/gpt-oss-120b",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "River light at dawn…" },
      "finish_reason": "stop"
    }
  ],
  "usage": { "prompt_tokens": 82, "completion_tokens": 141, "total_tokens": 223 }
}

Chat

Sends a message or a whole conversation to any provider and returns the complete answer as one JSON response. For text that appears while it’s being written, use /api/chat/stream with the same body.

Request body

Response

Cloud APIs answer in their own OpenAI format, passed on unchanged (see the Quickstart). Local CLI answers are converted to the same shape, with session_id and duration_ms added. usage is null for Codex and Gemini CLI, which don’t report tokens.

{
  "id": "local-7352154e-6436-4025-b807-eea57954a1ff",
  "object": "chat.completion",
  "provider": "claude",
  "model": "claude-sonnet-5-5",
  "session_id": "7352154e-6436-4025-b807-eea57954a1ff",
  "duration_ms": 8106,
  "choices": [
    {
      "index": 0,
      "finish_reason": "stop",
      "message": { "role": "assistant", "content": "It's an AI gateway that…" }
    }
  ],
  "usage": { "prompt_tokens": 21480, "completion_tokens": 312, "total_tokens": 21792 }
}

Streaming

Takes the same body as /api/chat, and sends the answer as Server-Sent Events while it’s being written. Every provider sends the same events:

event: start
data: {"provider":"groq"}

event: thinking
data: {"text":"Just list the numbers."}

event: delta
data: {"text":"1, 2, 3"}

event: delta
data: {"text":", 4, 5"}

event: done
data: {"provider":"groq","model":"openai/gpt-oss-120b","result":"1, 2, 3, 4, 5","finish_reason":"stop","usage":{"prompt_tokens":79,"completion_tokens":38,"total_tokens":117},"duration_ms":412}

curl -N "$AI_THUN_URL/api/chat/stream" \
  -H "Authorization: Bearer $AI_THUN_KEY" \
  -H "Content-Type: application/json" \
  -d '{"provider": "groq", "prompt": "Count from 1 to 5"}'

• While nothing new comes for 20 seconds (a CLI at work), the stream sends a comment line, : keep-alive, so nothing between you and the gateway closes it. Skip lines that start with :, as SSE readers do.
• A problem found before the stream starts (a wrong key, an unknown provider, a paused provider, a provider’s own error such as 402) comes back as an ordinary JSON error response, not as a stream.
• Closing the connection stops the work: a cloud request is cancelled, and a local CLI is stopped.
• finish_reason: "length" means max_tokens ran out. Thinking models can use it all on reasoning and leave result empty: raise max_tokens, or for SEA-LION turn thinking off.

Models

Lists every provider’s models, with its default and whether it’s paused.

curl "$AI_THUN_URL/api/models" -H "Authorization: Bearer $AI_THUN_KEY"

{
  "providers": {
    "groq": {
      "kind": "cloud",
      "default": "openai/gpt-oss-120b",
      "models": [{ "id": "openai/gpt-oss-120b", "name": "openai/gpt-oss-120b" }, …],
      "note": null,
      "error": null,
      "paused": false
    },
    "claude": {
      "kind": "local",
      "default": null,
      "models": [{ "id": "sonnet", "name": "Claude Sonnet (latest)" }, …],
      "note": "aliases for the latest model of each family …",
      "error": null,
      "paused": false
    },
    …
  }
}

Cloud lists come live from each provider, keep only chat models, and are cached for 10 minutes. Gemini CLI can’t list its models, so its list is empty and any model name is passed through. A paused cloud provider lists only its default model.

Image generation

Codex draws one image with its built-in image tool, using its ChatGPT sign-in (no API key). One image takes about 75 seconds.

curl "$AI_THUN_URL/api/image" \
  -H "Authorization: Bearer $AI_THUN_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "A lotus flower, flat vector illustration"}' \
  | jq -r .image_base64 | base64 -d > lotus.png

{
  "provider": "codex",
  "model": null,
  "image_base64": "iVBORw0KGgoAAAANSUhEUgAA…",
  "mime_type": "image/png",
  "message": "Created the lotus on a plain background.",
  "session_id": "01a11183-…",
  "duration_ms": 76000
}

Speech to text

Turns audio into text with Groq’s Whisper, using the Groq keys. It takes the same form as OpenAI’s /audio/transcriptions, so OpenAI-compatible clients only need the address and key changed. Send multipart/form-data:

curl "$AI_THUN_URL/api/transcribe" \
  -H "Authorization: Bearer $AI_THUN_KEY" \
  -F file=@meeting.m4a \
  -F language=en

{ "text": " Let's start with the budget.", "x_groq": { "id": "req_…" } }

With provider=mimo the file goes to MiMo Studio’s speech recognition page through chatgpt-web-gateway instead (noisy audio, several speakers, dialects; up to 10 MB and 90 seconds), and the answer is {"provider": "mimo", "model": "mimo-v2.5-asr", "text": "…"}. Its other fields are ignored, and pausing MiMo pauses it.

Groq allows 20 transcriptions a minute and 2,000 a day per key. A key that’s at its limit is skipped for the next one; if every key is, the answer is 429 with a Retry-After header. Pausing Groq pauses this endpoint too.

Text to speech

Speaks text through MiMo Studio’s speech pages, via chatgpt-web-gateway. It takes JSON like OpenAI’s /audio/speech and answers with the audio file (WAV, 24 kHz mono). GET /api/speech lists the models and voices.

curl "$AI_THUN_URL/api/speech" \
  -H "Authorization: Bearer $AI_THUN_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input": "Good evening!", "voice": "Dean", "instructions": "Calm, like a radio host."}' \
  -o evening.wav

The file’s response carries X-Model, X-Voice (URL-encoded) and X-Duration-Ms headers. Each takes about 5–15 seconds, and speech, MiMo transcription and MiMo chat take turns on one MiMo tab. Every one is saved to the MiMo account’s history; pausing MiMo pauses this endpoint.

Your key

The access token you call with: its status (active, disabled, expired or limited), its limits, what it has used and has left this period, when the period starts over, and when the key expires. It answers even for a key that’s turned off, expired or used up, so you can see why requests are refused. With the owner key it answers {"owner": true}.

curl "$AI_THUN_URL/api/me" -H "Authorization: Bearer $AI_THUN_KEY"

{
  "name": "Dara",
  "hint": "sk-ai-thun-3f9a…9c1e",
  "status": "active",
  "expiresAt": "2026-11-30T23:59:59.999Z",
  "limits": { "period": "month", "tokens": 1000000, "requests": 1000, "perMinute": 20 },
  "providers": ["groq", "cerebras"],
  "used": { "requests": 212, "errors": 3, "tokens": 412880, "estimatedTokens": 0 },
  "remaining": { "tokens": 587120, "requests": 791 },
  "resetsAt": "2026-11-01T00:00:00.000Z",
  "total": { "requests": 212, "errors": 3, "tokens": 412880, "estimatedTokens": 0 },
  …
}

• period is day or month (UTC), or total for a prepaid amount that doesn’t start over. null means no limit, and providers: null means every provider.
• Failed requests (errors) don’t count against the limit. Tokens are what the provider reported; where it doesn’t say (the web chats, Codex, Gemini CLI), they’re estimated from the prompt’s and answer’s length, about 4 characters a token, and counted in estimatedTokens too. Speech, transcription and images count as requests only.

Usage

One month’s usage across every provider: totals, every model with its requests and tokens (most tokens first), and a total for each day. month defaults to the current one. This is what the console’s Monthly usage panel shows.

curl "$AI_THUN_URL/api/usage?month=2026-10" -H "Authorization: Bearer $APP_API_KEY"

{
  "month": "2026-10",
  "months": ["2026-10", "2026-09"],
  "totals": {
    "requests": 31,
    "errors": 0,
    "promptTokens": 122819,
    "completionTokens": 12995,
    "totalTokens": 135814
  },
  "models": [
    {
      "provider": "claude",
      "model": "claude-haiku-5-5",
      "requests": 9,
      "errors": 0,
      "promptTokens": 54753,
      "completionTokens": 404,
      "totalTokens": 55157,
      "tokensReported": true,
      "avgDurationMs": 3900,
      "timed": 9,
      "lastUsedAt": "2026-10-15T15:03:13.000Z"
    },
    …
  ],
  "days": [
    { "day": "2026-10-01", "requests": 0, "totalTokens": 0 },
    …
  ],
  "generatedAt": "2026-10-16T02:30:00.000Z"
}

• Days are UTC days. months lists the months that have usage.
• tokensReported: false means none of that model’s requests said how many tokens they used (Codex, Gemini CLI, Whisper), so its zeros mean “unknown”.
• Usage is saved on the server, so restarts and updates don’t reset it. It’s kept for about 13 months.

Quotas

Today’s usage in detail: every cloud API key with its last-minute and daily numbers next to the provider’s published limits, every local CLI and model used today, and the paused providers. This is what the console’s Analytics page shows.

curl "$AI_THUN_URL/api/quotas" -H "Authorization: Bearer $APP_API_KEY"

{
  "keys": [
    {
      "provider": "groq",
      "keyName": "GROQ_API_KEY3",
      "model": "openai/gpt-oss-120b",
      "requestsLast60s": 1,
      "tokensLast60s": 127,
      "requestsToday": 12,
      "tokensToday": 48210,
      "limits": { "tokensPerDay": 500000 }
    },
    …
  ],
  "local": [
    {
      "provider": "claude",
      "model": "claude-sonnet-5-5",
      "requestsToday": 4,
      "errorsToday": 0,
      "promptTokensToday": 86020,
      "completionTokensToday": 1210,
      "tokensToday": 87230,
      "tokensReported": true,
      "avgDurationMs": 8100,
      "finishedToday": 4,
      "lastUsedAt": "2026-10-16T02:11:40.000Z"
    }
  ],
  "paused": ["cerebras", "codex"],
  "generatedAt": "2026-10-16T02:30:00.000Z"
}

Keys are shown by the name of the setting that holds them, never by their value. The last-minute numbers start again from zero when the server restarts; the daily ones don’t.

Pause & resume

A paused provider turns every request away with 503, from the console and from access tokens alike, until you resume it. Its keys and CLI sign-in stay as they are. Pausing Groq also pauses speech to text, and pausing Codex pauses image generation. You can also do this on the console’s Manage page.

A provider that isn’t set up is held the same way, and can’t be resumed: a cloud API with no API key, a CLI that isn’t installed, or one the gateway says isn’t signed in. Resuming it answers 409 with the reason. Once it’s set up, it goes by your own pause switch again. If the gateway can’t be reached to ask, nothing is held.

Being set up isn’t being able to answer, so each provider is also tested with a real, tiny chat (“Reply with exactly: ok”) when the server starts: a few tokens on a cloud API, a small run on a CLI’s plan. The websites (ChatGPT, Grok, MiMo) aren’t tested at start, because they share one Chrome window and MiMo saves every chat to its history. A provider that fails is held like one that isn’t set up, with the reason, and tried again after 30 seconds, a minute and two minutes in case the gateway was only starting. A real request that fails because of the provider (a refused key, a server error) starts a test too. After that, a held provider waits for you to test it again. A provider at its rate or usage limit still counts as answering. Test chats aren’t counted as traffic and cost no one’s credit.

Only an answer is a verdict. If the gateway (or a cloud API) can’t be reached at all, the test says nothing about the provider: it isn’t held, and the Manage page says what couldn’t be reached. To keep a provider out of the automatic tests and out of the holds, for one that’s used with a model the test chat doesn’t use, list it in PROVIDER_CHECK_SKIP (for example antigravity,groq). Pressing Test on it still shows how the test went.

POST /api/providers tests one provider now, which is what the Manage page’s Test button does, and is the way to test a website. It answers 202 at once (checks[provider].testing stays true until it’s over; GET shows when), or with "wait": true after the test, which can take a minute or more. Resuming a provider you paused starts a test the same way. Not for a provider that isn’t set up: 409. Set PROVIDER_CHECKS=off to turn the test at start off.

curl -X POST "$AI_THUN_URL/api/providers" \
  -H "Authorization: Bearer $APP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"provider": "groq", "wait": true}'

curl -X PATCH "$AI_THUN_URL/api/providers" \
  -H "Authorization: Bearer $APP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"provider": "cerebras", "paused": true}'

# → {"paused": ["cerebras"]}

These calls return the providers that turn requests away now, as {"paused": [...], "manual": [...], "setup": {...}, "checks": {...}}: paused has every one that does, manual the ones you paused. Each provider’s setup is {"status": "ready" | "no-key" | "not-installed" | "signed-out" | "failing" | "unknown", "reason": "…" | null}, failing being a failed test chat. Each checks entry is {"status": "ok" | "failing" | "unverified", "checkedAt", "source": "test" | "traffic", "reason", "limited", "testing"}.

Access tokens

Make, change and delete the keys other apps and people use instead of your owner key, and read what each one has used. Changes take effect on the next request. The console’s API keys page does the same. Only a hash of each key is stored, so a lost key can’t be shown again: give it a new secret instead.

# Create one: 1M tokens and 1,000 requests a month, 20 a minute, until the end
# of Nov 30 (UTC), Groq and Cerebras only. The key is shown only in this response.
curl -X POST "$AI_THUN_URL/api/tokens" \
  -H "Authorization: Bearer $APP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "Dara", "note": "paid 5 USD on Oct 26",
       "limits": {"period": "month", "tokens": 1000000, "requests": 1000, "perMinute": 20},
       "expiresAt": "2026-11-30", "providers": ["groq", "cerebras"]}'
# → {"id": "9f2c41d07ab35e18", "token": "sk-ai-thun-3f9a…", "name": "Dara", "status": "active", …}

# List them, with each one's status and use this period
curl "$AI_THUN_URL/api/tokens" -H "Authorization: Bearer $APP_API_KEY"

# One key's use in a month, by day and model
curl "$AI_THUN_URL/api/tokens?id=9f2c41d07ab35e18&month=2026-10" -H "Authorization: Bearer $APP_API_KEY"

# Top it up, give it 30 more days, turn it off, or make it a new secret
curl -X PATCH "$AI_THUN_URL/api/tokens?id=9f2c41d07ab35e18" \
  -H "Authorization: Bearer $APP_API_KEY" -H "Content-Type: application/json" \
  -d '{"addTokens": 500000, "extendDays": 30}'
#    -d '{"disabled": true}'   or   -d '{"rotate": true}'   (the new key comes back in "token")

# Delete one
curl -X DELETE "$AI_THUN_URL/api/tokens?id=9f2c41d07ab35e18" \
  -H "Authorization: Bearer $APP_API_KEY"
# → {"revoked": "9f2c41d07ab35e18"}

Users

The people who signed up at /account (with Supabase), each with their account: its plan, how many keys it has, and what it has used. A new account is pending and its keys don’t work until you activate it. GET /api/users?id=…&month=2026-10 adds the user’s keys and that month’s use by day and model. The console’s Users page does the same.

Redeem codes

Codes people redeem on their account page. A plan code activates an account with its plan, or replaces and renews it (its days count from the end of the current plan); a topup code adds to an active plan. Each account can use a code once. GET lists every code with its status, what it gives and who used it; PATCH takes disabled and note. The console’s Redeem codes page does the same.

Shop

Prepaid token packs people buy on their account page with PayPal. GET returns the packs with their pricing, the market prices, every order and whether payments are set up. A pack’s price can be at most a tenth of its tokens at the market price of the cheapest provider it covers. PATCH /api/shop with {"market": {"groq": {"input": 0.15, "output": 0.6}}} changes market prices (US dollars per million tokens). The console’s Shop page does the same.

CLI health

Which coding CLIs are installed on the machine, their versions, and what each one supports. Installed doesn’t mean signed in: each CLI needs its own sign-in on the machine.

{
  "status": "ok",
  "providers": {
    "claude": {
      "installed": true,
      "path": "/home/thun/.nvm/versions/node/v24.22.0/bin/claude",
      "version": "2.1.300 (Claude Code)",
      "supports_resume": true,
      "supports_images": false,
      "supports_no_tools": true
    },
    …
  }
}

CLI plan limits

How much of each CLI subscription’s usage limits is left, and when each one is fully available again, as the CLI itself reports it. Checking uses none of it. Only CLIs that can say are filled in (Claude Code and Antigravity); the others have supported: false. The limits belong to the account, so use outside Thun Murex counts too. They refill in rolling windows (5h, weekly), not daily. Claude Code’s 5-hour session has no resets_at until it starts; Antigravity keeps separate limits for its Gemini models and for its Claude and GPT models. Answers are cached for a few minutes; a signed-out CLI comes back with error set.

{
  "providers": {
    "antigravity": {
      "installed": true,
      "supported": true,
      "checked_at": "2026-10-24T10:24:36Z",
      "error": null,
      "limits": [
        {
          "id": "gemini-5h",
          "window": "5h",
          "remaining_fraction": 0.92,
          "resets_at": "2026-10-24T14:08:32Z",
          "name": "Five Hour Limit Remaining",
          "group": "Gemini Models",
          "models": "Gemini Flash, Gemini Pro"
        },
        …
      ]
    },
    "claude": {
      "installed": true,
      "supported": true,
      "limits": [
        {
          "id": "five_hour",
          "window": "5h",
          "remaining_fraction": 0.93,
          "resets_at": "2026-10-24T23:50:00+07:00",
          "name": "Current session",
          "group": null,
          "models": null
        },
        { "id": "seven_day", "window": "weekly", "remaining_fraction": 0.16, … }
      ],
      …
    },
    "codex": { "installed": true, "supported": false, "limits": [], … },
    …
  }
}

Conversations

Cloud APIs don’t remember anything between requests. To carry on a conversation, send all of it in messages every time, including the earlier answers:

curl "$AI_THUN_URL/api/chat" \
  -H "Authorization: Bearer $AI_THUN_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": "sea-lion",
    "messages": [
      {"role": "system", "content": "Answer in one short sentence."},
      {"role": "user", "content": "What is the capital of Cambodia?"},
      {"role": "assistant", "content": "Phnom Penh is the capital of Cambodia."},
      {"role": "user", "content": "How many people live there?"}
    ]
  }'

Local CLIs keep their own history. Every answer has a session_id; send it back with the next message, and the same workdir, to carry on. If you send messages to a CLI, only the last user message is used.

# The first answer includes a session_id …
curl "$AI_THUN_URL/api/chat" \
  -H "Authorization: Bearer $AI_THUN_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": "claude",
    "model": "sonnet",
    "prompt": "What does this project do?",
    "workdir": "/home/thun/Desktop/documents/Project/ai-thun"
  }'

# … send it back, with the same workdir, to carry on the conversation
curl "$AI_THUN_URL/api/chat" \
  -H "Authorization: Bearer $AI_THUN_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": "claude",
    "session_id": "7352154e-6436-4025-b807-eea57954a1ff",
    "prompt": "How is it deployed?",
    "workdir": "/home/thun/Desktop/documents/Project/ai-thun"
  }'

Cloud providers

Each cloud provider has several API keys. Requests take turns across all of them, so together they handle many more requests than one key could. A key that answers 429 (rate limited) is skipped for the next one; if every key is, the request fails with 429, and its Retry-After header says how many seconds until the first key can be used again, when the provider said.

Local agent CLIs

claude, codex, gemini and antigravity are real AI coding tools running on the machine, started for each request by local-agent-gateway. They work in the workdir folder: by default they can read the files there, but not change them or run commands.

• Each CLI runs at most 2 requests at a time. Others wait up to 30 seconds, then get 429.
• A request that takes longer than 5 minutes is stopped, with 504.
• When a CLI reaches its plan’s usage limit (Claude Code’s 5-hour or weekly limit, Codex’s, Gemini’s or Antigravity’s quota), the answer is 429, with retry_after when the CLI said when the limit resets.
• Antigravity stops if it needs a permission nobody can grant while it runs on its own, such as running a command. The answer is 502, with the permissions in denied and the conversation in session_id: allow them in agy’s settings.json, then send that session_id to carry on.
• Token counts are for that request alone, even in a long session, and input includes cached tokens, which are most of a Claude Code request.
• Each CLI has to be signed in on the machine before it can answer.

Errors

Errors come back with an HTTP error status and a JSON body. Read its error field; errors from a local CLI use detail instead, and a cloud provider’s own errors are passed on in the provider’s format.

{ "error": "Provider \"cerebras\" is paused. Resume it on the Manage page of the Thun Murex console." }

Some errors carry more fields, so a program can recover on its own:

HTTP/1.1 429 Too Many Requests
Retry-After: 7140

{
  "detail": "claude exited with status 1: You've hit your limit · resets 3pm (Asia/Bangkok)",
  "retry_after": 7140
}

VS Code & phone

The Thun Murex extension for VS Code (duchpanhathun.ai-thun) is a chat panel for this gateway: every provider and model, CLI sessions that carry on, teams of models that split up a task, approval of the CLI’s actions, and scheduled tasks and workflows.

• Set the gateway’s address in the aiThun.baseUrl setting, and the key with the command Thun Murex: Set API Key. VS Code keeps the key in its secret storage.
• It uses the error fields above: a team stopped by a usage limit carries on by itself once retry_after has passed, and an Antigravity run stopped for a permission picks up the same session_id.
• Phone app: run Thun Murex: Connect a Phone and scan the code. From the phone you can chat, approve the agent’s actions from a notification, change models, and run schedules and workflows. The phone only talks to VS Code, over Tailscale; VS Code sends the requests here with its own key.