Ten models. One endpoint. Yours.

$ zyraxon

  ZYRAXON  ·  chat
  model zyraxon-codex   ·   tools off
  /help for commands, /exit to leave

you> explain what this repo does in three bullets
zyraxon> 1. It is a marketing and tooling site for the ZYRAXON desktop agent.
         2. Provider routes live under src/routes/api/public/zyraxon/v1.
         3. The docs are data files under src/lib/docs.

you> /agent on
tools on
you> make hello.py that prints hi, then run it
  -> write_file
write hello.py (24 bytes)? [y/N] y
  -> run_shell
run: python3 hello.py ? [y/N] y
Done — it printed: hi

you> /model 2
model is now zyraxon-apex

you> /exit
bye

Commands inside the chat box
  /help            show this list
  /models          list every model the provider serves
  /model <n|id>    switch model — by number from /models, or by id
  /agent [on|off]  toggle tool calling (read, write, run) for the session
  /new             forget the conversation and start fresh
  /history         how many messages are in the conversation
  /save <file>     write the conversation to a file as JSON
  /exit            leave (also /quit)

Anything else you type is sent to the model.

One-shot, from the shell
  zyraxon "explain this repo"            stream one answer and exit
  zyraxon -a "make hello.py and run it"  one agent turn with tools, then exit
  zyraxon -m zyraxon-apex "..."          pick a model for one turn
  echo "what is 2+2?" | zyraxon          read the prompt from stdin
  zyraxon --models                       list the models

Any model works. The model list is read live, so every id the provider serves
today is selectable with /model — there is no fixed list in the client.

# One command. Installs deps, writes ~/.zyraxon/env, installs the client.
curl -fsSL https://zyraxonai.lovable.app/integrations/termux-setup.sh | bash

# Then, from any directory:
zyraxon                                  # open the chat box
zyraxon "summarise the changes in this repo"
zyraxon -a "create a hello world python file and run it"
echo "what is 2+2?" | zyraxon

pkg update && pkg upgrade -y
pkg install -y curl jq python

export ZYRAXON_BASE="https://zyraxonai.lovable.app/api/public/zyraxon/v1"
export ZYRAXON_MODEL="zyraxon-apex"
export ZYRAXON_KEY="zyraxon"

# The client on its own, without the installer:
curl -fsSL https://zyraxonai.lovable.app/integrations/zyraxon-chat.sh -o ~/.local/bin/zyraxon
chmod +x ~/.local/bin/zyraxon

curl -s "${ZYRAXON_BASE}/models" | jq -r '.data[].id'

curl -sN "${ZYRAXON_BASE}/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${ZYRAXON_KEY}" \
  -d "{\"model\":\"${ZYRAXON_MODEL}\",\"stream\":true,
       \"messages\":[{\"role\":\"user\",\"content\":\"$1\"}]}" \
| sed -n 's/^data: //p' \
| grep -v '^\[DONE\]$' \
| jq -rj '.choices[0].delta.content // empty'
echo

# Kali Linux / any Debian-family distro, including Kali NetHunter on a phone.
sudo apt update && sudo apt install -y curl jq

export ZYRAXON_BASE="https://zyraxonai.lovable.app/api/public/zyraxon/v1"
export ZYRAXON_MODEL="zyraxon-apex"
export ZYRAXON_KEY="zyraxon"

# Keep it for new shells.
cat >> ~/.bashrc <<'EOF'
export ZYRAXON_BASE="https://zyraxonai.lovable.app/api/public/zyraxon/v1"
export ZYRAXON_MODEL="zyraxon-apex"
export ZYRAXON_KEY="zyraxon"
EOF

curl -s "${ZYRAXON_BASE}/models" | jq -r '.data[].id'

#!/usr/bin/env bash
# zyraxon-ask — stream one turn from the ZYRAXON line on Kali / any Linux shell.
# Usage: zyraxon-ask "why does nmap show port 22 open?"
set -euo pipefail
: "${ZYRAXON_BASE:?set ZYRAXON_BASE first}"
: "${ZYRAXON_KEY:?set ZYRAXON_KEY first}"
PROMPT="${*:-$(cat)}"

curl -sN "${ZYRAXON_BASE}/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${ZYRAXON_KEY}" \
  -d "$(jq -nc --arg m "${ZYRAXON_MODEL}" --arg p "${PROMPT}" \
        '{model:$m, stream:true, messages:[{role:"user",content:$p}]}')" \
| sed -n 's/^data: //p' \
| grep -v '^\[DONE\]$' \
| jq -rj '.choices[0].delta.content // empty'
echo

# Kali NetHunter: run the same client inside the Kali chroot on an Android phone.
# (Termux side: install the NetHunter app, then start the chroot.)
nethunter
apt update && apt install -y curl jq

export ZYRAXON_BASE="https://zyraxonai.lovable.app/api/public/zyraxon/v1"
export ZYRAXON_MODEL="zyraxon-apex"
export ZYRAXON_KEY="zyraxon"

curl -s "${ZYRAXON_BASE}/chat/completions" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${ZYRAXON_KEY}" \
  -d "{\"model\":\"${ZYRAXON_MODEL}\",\"messages\":[{\"role\":\"user\",\"content\":\"list my open ports\"}]}" \
| jq -r '.choices[0].message.content'

# Give the model real evidence instead of a description of it.
nmap -sV -T4 192.168.1.1 -oN - | zyraxon-ask "summarise these findings for a report"
ss -tulpn | zyraxon-ask "which of these services is most exposed, and why?"
journalctl -p err -n 50 | zyraxon-ask "what broke here?"

// React Native / Expo / any mobile JS runtime. No SDK needed.
const res = await fetch("https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json", Authorization: "Bearer zyraxon" },
  body: JSON.stringify({
    model: "zyraxon-apex",
    messages: [{ role: "user", content: "Plan my day." }],
    stream: false,
  }),
});

const data = await res.json();
console.log(data.choices[0].message.content);

import 'dart:convert';
import 'package:http/http.dart' as http;

final res = await http.post(
  Uri.parse('https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions'),
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer zyraxon',
  },
  body: jsonEncode({
    'model': 'zyraxon-apex',
    'messages': [
      {'role': 'user', 'content': 'Plan my day.'},
    ],
  }),
);

final content = jsonDecode(res.body)['choices'][0]['message']['content'];

// Plain HTTP, so it works from an Android app with no OpenAI SDK at all.
val client = OkHttpClient()
val json = """
  {"model":"zyraxon-apex","messages":[{"role":"user","content":"Plan my day."}]}
""".trimIndent()

val request = Request.Builder()
    .url("https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions")
    .addHeader("Content-Type", "application/json")
    .addHeader("Authorization", "Bearer zyraxon")
    .post(json.toRequestBody("application/json".toMediaType()))
    .build()

client.newCall(request).execute().use { response ->
    println(response.body?.string())
}

// URLSession, no SDK. Works on iOS, iPadOS and watchOS.
var request = URLRequest(url: URL(string: "https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions")!)
request.httpMethod = "POST"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.setValue("Bearer zyraxon", forHTTPHeaderField: "Authorization")
request.httpBody = try JSONSerialization.data(withJSONObject: [
    "model": "zyraxon-apex",
    "messages": [["role": "user", "content": "Plan my day."]],
])

let (data, _) = try await URLSession.shared.data(for: request)
print(String(data: data, encoding: .utf8) ?? "")

Name (Optional)   zyraxon
Custom Model      openai/zyraxon-apex
Base URL          https://zyraxonai.lovable.app/api/public/zyraxon/v1
API Key           zyraxon

OpenHands has two modes, and the Base URL only works in one of them.

  Simple form:  there is a "Provider connection" dropdown, no Base URL box
                -> OpenHands sends the turn to OpenAI itself
                -> "401 Incorrect API key provided: zyraxon"

  Advanced:     a Base URL box appears
                -> OpenHands sends the turn to whatever that box says

Turn "Advanced" on at the top of the LLM settings page before you fill
anything in. The Base URL box appears once it is on.

  Error code: 401 - Incorrect API key provided: zyraxon.
  You can find your API key at https://platform.openai.com/account/api-keys

That message comes from OpenAI, not from us — the request never reached the
ZYRAXON endpoint. It means OpenHands used its default OpenAI URL instead of
your Base URL, almost always because Advanced mode is off.

Fix: turn Advanced on, then set Base URL to
  https://zyraxonai.lovable.app/api/public/zyraxon/v1

You can confirm it reaches us, and not OpenAI, in one call:

  curl -s https://zyraxonai.lovable.app/api/public/zyraxon/v1/models | jq -r '.data[].id'
  # prints the ZYRAXON model ids -> the URL is right

If OpenHands reports:

  litellm.BadRequestError: LLM Provider NOT provided.
  You passed model=zyraxon-apex

the Custom Model field is missing its provider prefix. OpenHands routes the
model through LiteLLM, which reads the text before the first "/" to choose a
handler and refuses a bare id — it never reaches us. Add the prefix:

  Custom Model:  openai/zyraxon-apex

The endpoint accepts both spellings, so this works with no other change:

  zyraxon-apex   openai/zyraxon-apex   zyraxon/zyraxon-apex   zyraxon/codex

If your version reads the model from the environment instead of the form:

  export LLM_MODEL="openai/zyraxon-apex"
  export LLM_BASE_URL="https://zyraxonai.lovable.app/api/public/zyraxon/v1"
  export LLM_API_KEY="zyraxon"

# The model list is what the form needs to resolve the model id.
curl -s https://zyraxonai.lovable.app/api/public/zyraxon/v1/models | jq -r '.data[].id'

# A one-shot turn proves the URL and key are right. Both spellings work here.
curl -s https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer zyraxon" \
  -d '{"model":"openai/zyraxon-apex","messages":[{"role":"user","content":"ping"}]}' \
| jq -r '.choices[0].message.content'

{
  "models": [
    {
      "title": "ZYRAXON",
      "provider": "openai",
      "model": "zyraxon-apex",
      "apiBase": "https://zyraxonai.lovable.app/api/public/zyraxon/v1",
      "apiKey": "zyraxon"
    }
  ]
}

export OPENAI_API_BASE="https://zyraxonai.lovable.app/api/public/zyraxon/v1"
export OPENAI_API_KEY="zyraxon"
aider --model openai/zyraxon-apex

# Many CLIs read these directly.
export OPENAI_BASE_URL="https://zyraxonai.lovable.app/api/public/zyraxon/v1"
export OPENAI_API_BASE="https://zyraxonai.lovable.app/api/public/zyraxon/v1"
export OPENAI_API_KEY="zyraxon"

// Cline / Roo Code / Kilo Code (VS Code settings.json)
// These extensions expose an "OpenAI Compatible" provider.
{
  "cline.apiProvider": "openai",
  "cline.openAiBaseUrl": "https://zyraxonai.lovable.app/api/public/zyraxon/v1",
  "cline.openAiApiKey": "zyraxon",
  "cline.openAiModelId": "zyraxon-apex"
}

// Roo Code — Settings → Providers → OpenAI Compatible
//   Base URL:  https://zyraxonai.lovable.app/api/public/zyraxon/v1
//   API Key:   zyraxon
//   Model ID:  zyraxon-apex
// Or, from the CLI, by environment:
export OPENAI_BASE_URL="https://zyraxonai.lovable.app/api/public/zyraxon/v1"
export OPENAI_API_KEY="zyraxon"

// VS Code + GitHub Copilot Chat, "Bring your own model" style providers,
// or any extension that reads the OpenAI base URL from the environment.
export OPENAI_BASE_URL="https://zyraxonai.lovable.app/api/public/zyraxon/v1"
export OPENAI_API_BASE="https://zyraxonai.lovable.app/api/public/zyraxon/v1"
export OPENAI_API_KEY="zyraxon"
# Then start VS Code from that shell so it inherits the variables.
code .

// Zed — settings.json
{
  "language_models": {
    "openai": {
      "api_url": "https://zyraxonai.lovable.app/api/public/zyraxon/v1",
      "available_models": [
        { "name": "zyraxon-apex", "max_tokens": 16000 }
      ]
    }
  }
}

# Any client that speaks "Ollama" or "LocalAI" over an OpenAI-compatible
# /v1 base works too — point it at us instead of localhost.
export OLLAMA_HOST="https://zyraxonai.lovable.app/api/public/zyraxon/v1"
export OPENAI_BASE_URL="https://zyraxonai.lovable.app/api/public/zyraxon/v1"
export OPENAI_API_KEY="zyraxon"

# Verify the same way any OpenAI client would:
curl -s "https://zyraxonai.lovable.app/api/public/zyraxon/v1/models" | jq -r '.data[].id'

// An MCP server, or any agent tool host, can call ZYRAXON as its model.
// The tool definitions travel in the request; the model returns real calls.
{
  "model": "zyraxon-apex",
  "messages": [{ "role": "user", "content": "Read package.json and summarise it." }],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "read_file",
        "description": "Read a file from the working directory.",
        "parameters": {
          "type": "object",
          "properties": { "path": { "type": "string" } },
          "required": ["path"]
        }
      }
    }
  ]
}

curl https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "zyraxon-apex",
    "messages": [{ "role": "user", "content": "Hello" }],
    "stream": true
  }'

curl -s https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "zyraxon-apex",
    "messages": [{ "role": "user", "content": "Hello" }]
  }' | jq -r '.choices[0].message.content'

curl -s https://zyraxonai.lovable.app/api/public/zyraxon/v1/models      | jq -r '.data[] | "\(.id)  \(.context_window)"'
curl -s https://zyraxonai.lovable.app/api/public/zyraxon/v1/provider    | jq '{modalities, concurrency, fleet}'

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://zyraxonai.lovable.app/api/public/zyraxon/v1",
  apiKey: "zyraxon",
});

const stream = await client.chat.completions.create({
  model: "zyraxon-apex",
  messages: [{ role: "user", content: "Build a landing page" }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

from openai import OpenAI

client = OpenAI(base_url="https://zyraxonai.lovable.app/api/public/zyraxon/v1", api_key="zyraxon")

stream = client.chat.completions.create(
    model="zyraxon-apex",
    messages=[{"role": "user", "content": "Build a landing page"}],
    stream=True,
)

for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="", flush=True)

from openai import OpenAI

client = OpenAI(base_url="https://zyraxonai.lovable.app/api/public/zyraxon/v1", api_key="zyraxon")

stream = client.chat.completions.create(
    model="zyraxon-apex",
    messages=[{"role": "user", "content": "Write a haiku about the sea."}],
    stream=True,
)

for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="", flush=True)

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://zyraxonai.lovable.app/api/public/zyraxon/v1", apiKey: "zyraxon" });

const tools = [
  {
    type: "function" as const,
    function: {
      name: "write_file",
      description: "Write text to a file on disk.",
      parameters: {
        type: "object",
        properties: { path: { type: "string" }, content: { type: "string" } },
        required: ["path", "content"],
      },
    },
  },
];

// You run the tools. The provider only returns the call.
async function runTool(name: string, args: any) {
  if (name === "write_file") {
    const { writeFile } = await import("node:fs/promises");
    await writeFile(args.path, args.content, "utf8");
    return `wrote ${args.path}`;
  }
  return `unknown tool ${name}`;
}

const messages: any[] = [{ role: "user", content: "Save a hello world file." }];

for (let turn = 0; turn < 8; turn++) {
  const res = await client.chat.completions.create({
    model: "zyraxon-apex",
    messages,
    tools,
  });
  const choice = res.choices[0];
  messages.push(choice.message);

  if (choice.finish_reason !== "tool_calls") break;

  for (const call of choice.message.tool_calls ?? []) {
    const result = await runTool(call.function.name, JSON.parse(call.function.arguments));
    messages.push({ role: "tool", tool_call_id: call.id, content: result });
  }
}

from openai import OpenAI
import json, pathlib

client = OpenAI(base_url="https://zyraxonai.lovable.app/api/public/zyraxon/v1", api_key="zyraxon")

tools = [{
    "type": "function",
    "function": {
        "name": "write_file",
        "description": "Write text to a file on disk.",
        "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}, "content": {"type": "string"}},
            "required": ["path", "content"],
        },
    },
}]

def run_tool(name, args):
    if name == "write_file":
        pathlib.Path(args["path"]).write_text(args["content"], encoding="utf-8")
        return f"wrote {args['path']}"
    return f"unknown tool {name}"

messages = [{"role": "user", "content": "Save a hello world file."}]

for _ in range(8):
    res = client.chat.completions.create(model="zyraxon-apex", messages=messages, tools=tools)
    choice = res.choices[0]
    messages.append(choice.message)

    if choice.finish_reason != "tool_calls":
        break

    for call in choice.message.tool_calls or []:
        result = run_tool(call.function.name, json.loads(call.function.arguments))
        messages.append({"role": "tool", "tool_call_id": call.id, "content": result})

import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { streamText } from "ai";

const zyraxon = createOpenAICompatible({
  name: "zyraxon",
  baseURL: "https://zyraxonai.lovable.app/api/public/zyraxon/v1",
  apiKey: "zyraxon",
});

const result = streamText({
  model: zyraxon("zyraxon-apex"),
  messages: [{ role: "user", content: "Explain a monad in one paragraph." }],
});

for await (const delta of result.textStream) process.stdout.write(delta);

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="zyraxon-apex",
    base_url="https://zyraxonai.lovable.app/api/public/zyraxon/v1",
    api_key="zyraxon",
)

print(llm.invoke("Summarise this repo layout in three bullets.").content)

import { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({
  model: "zyraxon-apex",
  configuration: { baseURL: "https://zyraxonai.lovable.app/api/public/zyraxon/v1", apiKey: "zyraxon" },
});

console.log((await llm.invoke("Summarise this repo layout in three bullets.")).content);

from litellm import completion

response = completion(
    # The provider prefix is required: LiteLLM reads it to pick a handler, and
    # without it you get "LLM Provider NOT provided". The endpoint strips it.
    model="openai/zyraxon-apex",
    api_base="https://zyraxonai.lovable.app/api/public/zyraxon/v1",
    api_key="zyraxon",
    messages=[{"role": "user", "content": "Explain what a reverse proxy does."}],
)

print(response.choices[0].message.content)

# litellm-config.yaml — a LiteLLM proxy that fronts ZYRAXON.
#
# Start it with:  litellm --config litellm-config.yaml --port 4000
# Then any client pointed at http://localhost:4000/v1 gets the ZYRAXON models,
# with LiteLLM's own routing, budgets, logging and key management on top.
model_list:
  - model_name: zyraxon-apex
    litellm_params:
      model: openai/zyraxon-apex
      api_base: https://zyraxonai.lovable.app/api/public/zyraxon/v1
      api_key: zyraxon
  - model_name: zyraxon-codex
    litellm_params:
      model: openai/zyraxon-codex
      api_base: https://zyraxonai.lovable.app/api/public/zyraxon/v1
      api_key: zyraxon
  - model_name: zyraxon-cyber
    litellm_params:
      model: openai/zyraxon-cyber
      api_base: https://zyraxonai.lovable.app/api/public/zyraxon/v1
      api_key: zyraxon

litellm_settings:
  drop_params: true

# Point LiteLLM at ZYRAXON with plain environment variables, no config file.
# The openai/ prefix in the model string is required by LiteLLM.
export OPENAI_API_BASE="https://zyraxonai.lovable.app/api/public/zyraxon/v1"
export OPENAI_API_KEY="zyraxon"

python - <<'PY'
from litellm import completion
r = completion(model="openai/zyraxon-apex",
               messages=[{"role": "user", "content": "hello"}])
print(r.choices[0].message.content)
PY

# Same thing through the LiteLLM CLI:
litellm --model openai/zyraxon-apex --api_base https://zyraxonai.lovable.app/api/public/zyraxon/v1 --api_key zyraxon

# Why the model string needs a provider prefix, and what this endpoint accepts.
#
# LiteLLM reads the text before the first "/" to choose a handler. A bare id
# like "zyraxon-codex" has no "/", so LiteLLM stops with:
#     BadRequestError: LLM Provider NOT provided
# Write "openai/zyraxon-codex" and it uses the generic OpenAI-compatible path.
#
# This endpoint is tolerant: all of these resolve to the same ZYRAXON model.
#   zyraxon-codex
#   openai/zyraxon-codex
#   zyraxon/zyraxon-codex
#   zyraxon/codex
#   openai/zyraxon/codex

# Fetch it
curl -fsSL https://zyraxonai.lovable.app/integrations/zyraxon.py -o zyraxon.py

# In any Python shell, REPL or notebook
>>> from zyraxon import Zyraxon
>>> ai = Zyraxon()                      # any model; models() lists them live
>>> ai.ask("explain what a race condition is")
>>> for piece in ai.stream("write a haiku about the sea"):
...     print(piece, end="")
>>> ai.ask("and in Go?")                # the conversation is remembered
>>> Zyraxon(model="zyraxon-apex").ask("reason about this carefully")

# As a command, for scripts and pipes
python zyraxon.py "summarise this repo"
python zyraxon.py -a "create hello.py and run it"     # tool-calling loop
python zyraxon.py --models
echo "what is 2+2?" | python zyraxon.py

# A job that runs for hours, and is never lost.
#
# A single HTTP request cannot live for hours — a dropped network, a restart or
# a deploy ends it. So the run is kept in ~/.zyraxon/sessions/<name>.json,
# rewritten after every step, and resumes from there after any interruption.
# Stop it, kill it, reboot the machine: start it again with the same session
# name and it continues from the last step instead of starting over.

from zyraxon import Zyraxon, local_tools

ai = Zyraxon(model="zyraxon-apex")
tools, run = local_tools(confirm=False)

result = ai.long_task(
    "Rewrite every file under src/lib, one file per step, keeping the tests green.",
    tools,
    run,
    session="refactor",          # same name resumes this run
    hours=0,                     # 0 = keep going until the task is done
    on_step=lambda s: print(f"step {s['step']}"),   # progress as it goes
)
print(result)

# From a shell, the same thing:
#   python zyraxon.py --long --session refactor "rewrite each file in src"
#   python zyraxon.py --sessions          # see saved runs and their step

from zyraxon import Zyraxon, local_tools

ai = Zyraxon()
tools, run = local_tools(confirm=True)   # read_file, write_file, run_shell
print(ai.agent("create hello.py that prints hi, then run it", tools, run))

from zyraxon import Zyraxon

ai = Zyraxon(model="zyraxon-pulse")     # the fast one
for piece in ai.stream("summarise the changes in src/lib"):
    print(piece, end="", flush=True)

# Fetch it
Invoke-WebRequest https://zyraxonai.lovable.app/integrations/zyraxon.ps1 -OutFile zyraxon.ps1

# Dot-source it, then use the functions
. .\zyraxon.ps1

Get-ZyraxonModels                                   # any model, live
Invoke-Zyraxon "explain what a race condition is"
Invoke-Zyraxon "write a haiku about the sea" -Stream
Invoke-Zyraxon "reason about this" -Model zyraxon-apex
Invoke-ZyraxonAgent "create hello.py that prints hi, then run it" -Confirm

# Or a one-shot run
.\zyraxon.ps1 "summarise this repo" -Stream

# Point it somewhere else
Set-ZyraxonConfig -Model zyraxon-pulse

Get-Content .\error.log -Raw | ForEach-Object {
    Invoke-Zyraxon "what went wrong in this log?"
}

# Fetch it, then source it in the current shell
curl -fsSL https://zyraxonai.lovable.app/integrations/zyraxon.sh -o zyraxon.sh
. ./zyraxon.sh

zyraxon_models                                    # any model, live
zyraxon_ask "explain what a race condition is"
zyraxon_stream "write a haiku about the sea"
zyraxon_ask -m zyraxon-apex "reason about this"
zyraxon_agent "create hello.py that prints hi, then run it"

# Work that may take hours, and survives anything
zyraxon_long -s refactor "rewrite each file in src, one at a time"
zyraxon_sessions                                  # inspect or resume a run

# Works in bash and zsh, and composes with a pipe
cat error.log | zyraxon_ask "what went wrong here?"

git diff HEAD~1 | zyraxon_ask "review this change and flag anything risky"
journalctl -p err -n 50 | zyraxon_ask "what broke here?"

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func main() {
	body, _ := json.Marshal(map[string]any{
		"model": "zyraxon-apex",
		"messages": []map[string]string{
			{"role": "user", "content": "Plan my day."},
		},
	})

	req, _ := http.NewRequest("POST", "https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions", bytes.NewReader(body))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Authorization", "Bearer zyraxon")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}

// reqwest + serde_json. No OpenAI crate needed.
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let body = serde_json::json!({
        "model": "zyraxon-apex",
        "messages": [{ "role": "user", "content": "Plan my day." }]
    });

    let res = reqwest::Client::new()
        .post("https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions")
        .header("Content-Type", "application/json")
        .header("Authorization", "Bearer zyraxon")
        .json(&body)
        .send()
        .await?
        .text()
        .await?;

    println!("{}", res);
    Ok(())
}

<?php
// Plain cURL, so it works from any PHP app, Laravel job or WordPress plugin.
$payload = json_encode([
    "model" => "zyraxon-apex",
    "messages" => [["role" => "user", "content" => "Plan my day."]],
]);

$ch = curl_init("https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        "Content-Type: application/json",
        "Authorization: Bearer zyraxon",
    ],
    CURLOPT_POSTFIELDS => $payload,
    CURLOPT_RETURNTRANSFER => true,
]);
echo curl_exec($ch);
curl_close($ch);

// Java 11+ HttpClient. Works from Spring Boot, Android or a CLI tool.
var payload = """
  {"model":"zyraxon-apex","messages":[{"role":"user","content":"Plan my day."}]}
  """;

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions"))
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer zyraxon")
    .POST(HttpRequest.BodyPublishers.ofString(payload))
    .build();

var response = HttpClient.newHttpClient()
    .send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

// C# / .NET. The Azure OpenAI client and the OpenAI .NET SDK both take a custom endpoint.
using var http = new HttpClient();
http.DefaultRequestHeaders.Add("Authorization", "Bearer zyraxon");

var json = """
  {"model":"zyraxon-apex","messages":[{"role":"user","content":"Plan my day."}]}
  """;

var res = await http.PostAsync(
    "https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions",
    new StringContent(json, System.Text.Encoding.UTF8, "application/json"));

Console.WriteLine(await res.Content.ReadAsStringAsync());

// A Discord bot, a Slack app or any chat integration: it is one HTTP call.
import { Client, GatewayIntentBits } from "discord.js";

const client = new Client({ intents: [GatewayIntentBits.MessageContent, GatewayIntentBits.Guilds] });

client.on("messageCreate", async (msg) => {
  if (msg.author.bot) return;

  const res = await fetch("https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions", {
    method: "POST",
    headers: { "Content-Type": "application/json", Authorization: "Bearer zyraxon" },
    body: JSON.stringify({
      model: "zyraxon-apex",
      messages: [{ role: "user", content: msg.content }],
    }),
  });

  const data = await res.json();
  await msg.reply(data.choices[0].message.content);
});

client.login(process.env.DISCORD_TOKEN);

# Home Assistant, Node-RED and similar automation hosts: use a REST command
# or an HTTP request node. In configuration.yaml:

rest_command:
  zyraxon_ask:
    url: "https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions"
    method: POST
    headers:
      Content-Type: application/json
      Authorization: "Bearer zyraxon"
    payload: >
      {"model": "zyraxon-apex",
       "messages": [{"role": "user", "content": "{{ prompt }}"}]}

// n8n: HTTP Request node (or the OpenAI node with a custom base URL)
// Method: POST
// URL:    https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions
// Header: Content-Type: application/json
// Header: Authorization: Bearer zyraxon
{
  "model": "zyraxon-apex",
  "messages": [{ "role": "user", "content": "{{ $json.prompt }}" }],
  "stream": false
}

POST https://zyraxonai.lovable.app/api/public/zyraxon/v1/chat/completions
Content-Type: application/json
Authorization: Bearer zyraxon

{
  "model": "zyraxon-apex",
  "messages": [{ "role": "user", "content": "Hello" }]
}

# Anything that can read a JSON model list can configure itself.
curl -s https://zyraxonai.lovable.app/api/public/zyraxon/v1/models | jq -r '.data[] | "\(.id)\t\(.context_window)\t\(.input_modalities | join(","))"'

# Provider health, capacity and overload policy:
curl -s https://zyraxonai.lovable.app/api/public/zyraxon/v1/provider | jq '{count, modalities, concurrency, overload}'

# The machine-readable integration catalogue (this whole page):
curl -s https://zyraxonai.lovable.app/api/public/zyraxon/v1/integrations | jq '.integrations[] | {id, name, category}'

# The answer is spoken in the language you name, and the MP3 starts
# arriving before the sentence finishes being synthesised.
curl -s https://zyraxonai.lovable.app/api/public/tts \
  -H "Content-Type: application/json" \
  -d '{"text":"Hello from ZYRAXON.","locale":"en"}' \
  -o answer.mp3

# Play it
ffplay -nodisp -autoexit answer.mp3   # or: afplay / aplay / start

# Bengali answer, Bengali voice — the endpoint picks it from the locale.
curl -s https://zyraxonai.lovable.app/api/public/tts \
  -H "Content-Type: application/json" \
  -d '{"text":"আমি একটি ZYRAXON মডেল।","locale":"bn"}' \
  -o bengali.mp3

# Or name the voice exactly
curl -s https://zyraxonai.lovable.app/api/public/tts \
  -H "Content-Type: application/json" \
  -d '{"text":"नमस्ते","voice":"hi-IN-SwaraNeural"}' -o hindi.mp3

curl -s https://zyraxonai.lovable.app/api/public/tts/voices | jq '{count, languages: (.languages|length)}'
curl -s https://zyraxonai.lovable.app/api/public/tts/voices | jq -r '.locales[]' | grep '^bn'

// The endpoint streams MP3, so the browser can start playing before the
// whole sentence has been synthesised.
const res = await fetch("https://zyraxonai.lovable.app/api/public/tts", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ text: answer, locale: "en" }),
});
new Audio(URL.createObjectURL(await res.blob())).play();

curl -s https://zyraxonai.lovable.app/api/public/stt \
  -F "file=@recording.mp3" \
  -F "language=en" | jq -r '.text'