Build with intelligence

export VEX_API_KEY="ar_..."

pip install openai

npm install openai

pip install anthropic

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.arioron.com/v1",
    api_key=os.environ["VEX_API_KEY"],
)

response = client.responses.create(
    model="perceptix-vex-amber-2.0",
    input="Write a one-sentence bedtime story about a lighthouse.",
)
print(response.output_text)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.arioron.com/v1",
  apiKey: process.env.VEX_API_KEY,
});

const response = await client.responses.create({
  model: "perceptix-vex-amber-2.0",
  input: "Write a one-sentence bedtime story about a lighthouse.",
});
console.log(response.output_text);

import os
import anthropic

client = anthropic.Anthropic(
    base_url="https://api.arioron.com",
    api_key=os.environ["VEX_API_KEY"],
)

message = client.messages.create(
    model="perceptix-vex-amber-2.0",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Write a one-sentence bedtime story about a lighthouse."}],
)
print(message.content[0].text)

curl https://api.arioron.com/v1/responses \
  -H "Authorization: Bearer $VEX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "perceptix-vex-amber-2.0",
    "input": "Write a one-sentence bedtime story about a lighthouse."
  }'

Authorization: Bearer ar_...
# or
x-api-key: ar_...

response = client.responses.create(
    model="perceptix-vex-amber-2.0",
    instructions="You are a concise travel assistant.",
    input="Three things to do in Lisbon in one day.",
)
print(response.output_text)

# Continue the conversation without resending history
follow_up = client.responses.create(
    model="perceptix-vex-amber-2.0",
    previous_response_id=response.id,
    input="Which of those is best on a rainy day?",
)
print(follow_up.output_text)

const response = await client.responses.create({
  model: "perceptix-vex-amber-2.0",
  instructions: "You are a concise travel assistant.",
  input: "Three things to do in Lisbon in one day.",
});
console.log(response.output_text);

const followUp = await client.responses.create({
  model: "perceptix-vex-amber-2.0",
  previous_response_id: response.id,
  input: "Which of those is best on a rainy day?",
});
console.log(followUp.output_text);

curl https://api.arioron.com/v1/responses \
  -H "Authorization: Bearer $VEX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "perceptix-vex-amber-2.0",
    "instructions": "You are a concise travel assistant.",
    "input": "Three things to do in Lisbon in one day."
  }'

{
  "id": "resp_8f3c…",
  "object": "response",
  "created_at": 1759567200,
  "status": "completed",
  "model": "perceptix-vex-amber-2.0",
  "output": [
    {
      "type": "message",
      "id": "msg_2b1a…",
      "status": "completed",
      "role": "assistant",
      "content": [{ "type": "output_text", "text": "1. Ride Tram 28…", "annotations": [] }]
    }
  ],
  "usage": {
    "input_tokens": 24,
    "input_tokens_details": { "cached_tokens": 0 },
    "output_tokens": 162,
    "output_tokens_details": { "reasoning_tokens": 41 },
    "total_tokens": 186
  },
  "previous_response_id": null,
  "error": null,
  "incomplete_details": null
}

response = client.responses.create(
    model="perceptix-vex-amber-2.0",
    tools=[{"type": "web_search"}],
    input="What changed in the latest Python release?",
)
for item in response.output:
    if item.type == "web_search_call":
        print("searched:", item.action.query)
print(response.output_text)

completion = client.chat.completions.create(
    model="perceptix-vex-amber-2.0",
    messages=[
        {"role": "developer", "content": "You answer in one sentence."},
        {"role": "user", "content": "Why is the sky blue?"},
    ],
)
print(completion.choices[0].message.content)
print(completion.usage.prompt_tokens, completion.usage.completion_tokens)

const completion = await client.chat.completions.create({
  model: "perceptix-vex-amber-2.0",
  messages: [
    { role: "developer", content: "You answer in one sentence." },
    { role: "user", content: "Why is the sky blue?" },
  ],
});
console.log(completion.choices[0].message.content);

curl https://api.arioron.com/v1/chat/completions \
  -H "Authorization: Bearer $VEX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "perceptix-vex-amber-2.0",
    "messages": [{"role": "user", "content": "Why is the sky blue?"}]
  }'

import anthropic

client = anthropic.Anthropic(base_url="https://api.arioron.com", api_key=os.environ["VEX_API_KEY"])

message = client.messages.create(
    model="perceptix-vex-amber-2.0",
    max_tokens=1024,
    system="You only answer in French.",
    messages=[{"role": "user", "content": "Say hello."}],
)
print(message.content[0].text, message.usage.output_tokens)

count = client.messages.count_tokens(
    model="perceptix-vex-amber-2.0",
    messages=[{"role": "user", "content": "How many tokens is this?"}],
)
print(count.input_tokens)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({ baseURL: "https://api.arioron.com", apiKey: process.env.VEX_API_KEY });

const message = await client.messages.create({
  model: "perceptix-vex-amber-2.0",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Say hello." }],
});
console.log(message.content[0].text);

result = client.embeddings.create(
    model="vex-embed",
    input=["The quick brown fox", "A fast auburn fox"],
    dimensions=768,  # optional: smaller vectors, cheaper storage
)
vectors = [d.embedding for d in result.data]

curl https://api.arioron.com/v1/embeddings \
  -H "Authorization: Bearer $VEX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "vex-embed", "input": "The quick brown fox"}'

import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the status of a customer order",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]
messages = [{"role": "user", "content": "Where is order A-1001?"}]

first = client.chat.completions.create(model="perceptix-vex-amber-2.0", messages=messages, tools=tools)
call = first.choices[0].message.tool_calls[0]
args = json.loads(call.function.arguments)          # {"order_id": "A-1001"}

messages.append(first.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": call.id,
    "content": json.dumps({"status": "shipped", "eta": "Oct 9"}),  # your function's result
})
final = client.chat.completions.create(model="perceptix-vex-amber-2.0", messages=messages, tools=tools)
print(final.choices[0].message.content)

tools = [{
    "type": "function",
    "name": "get_order_status",
    "description": "Look up the status of a customer order",
    "parameters": {
        "type": "object",
        "properties": {"order_id": {"type": "string"}},
        "required": ["order_id"],
    },
}]

first = client.responses.create(model="perceptix-vex-amber-2.0", tools=tools, input="Where is order A-1001?")
call = next(item for item in first.output if item.type == "function_call")

final = client.responses.create(
    model="perceptix-vex-amber-2.0",
    tools=tools,
    previous_response_id=first.id,
    input=[{
        "type": "function_call_output",
        "call_id": call.call_id,
        "output": '{"status": "shipped", "eta": "Oct 9"}',
    }],
)
print(final.output_text)

from pydantic import BaseModel

class Weather(BaseModel):
    city: str
    temp_c: float

completion = client.chat.completions.create(
    model="perceptix-vex-amber-2.0",
    messages=[{"role": "user", "content": "Make up today's weather for Paris."}],
    response_format={
        "type": "json_schema",
        "json_schema": {"name": "weather", "schema": Weather.model_json_schema(), "strict": True},
    },
)
weather = Weather.model_validate_json(completion.choices[0].message.content)

response = client.responses.create(
    model="perceptix-vex-amber-2.0",
    input="Make up today's weather for Paris.",
    text={"format": {
        "type": "json_schema",
        "name": "weather",
        "schema": {
            "type": "object",
            "properties": {"city": {"type": "string"}, "temp_c": {"type": "number"}},
            "required": ["city", "temp_c"],
            "additionalProperties": False,
        },
    }},
)
print(response.output_text)   # {"city": "Paris", "temp_c": 15.5}

completion = client.chat.completions.create(
    model="perceptix-vex-amber-2.0",
    messages=[{"role": "user", "content": [
        {"type": "text", "text": "What's in this image?"},
        {"type": "image_url", "image_url": {"url": "https://example.com/photo.png"}},
    ]}],
)

# A PDF you uploaded earlier
response = client.responses.create(
    model="perceptix-vex-amber-2.0",
    input=[{"role": "user", "content": [
        {"type": "input_file", "file_id": "file_abc123"},
        {"type": "input_text", "text": "Summarize this contract in five bullets."},
    ]}],
)

# Responses: typed events
with client.responses.stream(model="perceptix-vex-amber-2.0", input="Write a haiku about rain.") as stream:
    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
    final = stream.get_final_response()

# Chat Completions: chunks, plus a usage chunk at the end
for chunk in client.chat.completions.create(
    model="perceptix-vex-amber-2.0",
    messages=[{"role": "user", "content": "Write a haiku about rain."}],
    stream=True,
    stream_options={"include_usage": True},
):
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

from openai import OpenAI

client = OpenAI(
    base_url="https://api.arioron.com/v1",          # was: https://api.openai.com/v1
    api_key=os.environ["VEX_API_KEY"],
)

client.chat.completions.create(model="perceptix-vex-amber-2.0", messages=[...])   # was: gpt-…
client.responses.create(model="perceptix-vex-amber-2.0", input="...")
client.embeddings.create(model="vex-embed", input="...")          # was: text-embedding-…

import anthropic

client = anthropic.Anthropic(
    base_url="https://api.arioron.com",       # was: https://api.anthropic.com
    api_key=os.environ["VEX_API_KEY"],
)
client.messages.create(model="perceptix-vex-amber-2.0", max_tokens=1024, messages=[...])

uploaded = client.files.create(file=open("contract.pdf", "rb"), purpose="assistants")
print(uploaded.id)   # file_…

content = client.files.content(uploaded.id).read()   # download bytes, e.g. batch results

# Create an agent that may only use web search
curl https://api.arioron.com/v1/agents -H "Authorization: Bearer $VEX_API_KEY" -H "Content-Type: application/json" -d '{
  "name": "Research assistant",
  "model": "perceptix-vex-amber-2.0",
  "instructions": "Research the question, then answer in five bullets with sources.",
  "tools": ["web_search"],
  "max_steps": 8
}'

# Run it in the background
curl https://api.arioron.com/v1/agents/agent_…/runs -H "Authorization: Bearer $VEX_API_KEY" -H "Content-Type: application/json" -d '{
  "input": "What were the biggest announcements at this year's PyCon?",
  "background": true
}'
# → 202 {"id": "run_…", "status": "queued", …}

# Poll for the result and the full step-by-step trace
curl https://api.arioron.com/v1/agents/agent_…/runs/run_… -H "Authorization: Bearer $VEX_API_KEY"

curl https://api.arioron.com/v1/conversations/conv_…/messages -H "Authorization: Bearer $VEX_API_KEY" -H "Content-Type: application/json" -d '{
  "role": "user",
  "content": "What is our refund window?",
  "generate_response": true,
  "model": "perceptix-vex-amber-2.0"
}'

curl https://api.arioron.com/v1/memories -H "Authorization: Bearer $VEX_API_KEY" -H "Content-Type: application/json" -d '{
  "content": "The customer prefers email over phone calls.",
  "scope": "agent",
  "owner_ref": "agent_…"
}'

{"custom_id": "q1", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "perceptix-vex-amber-2.0", "messages": [{"role": "user", "content": "Classify: 'love it'"}]}}
{"custom_id": "q2", "method": "POST", "url": "/v1/chat/completions", "body": {"model": "perceptix-vex-amber-2.0", "messages": [{"role": "user", "content": "Classify: 'never again'"}]}}

batch_file = client.files.create(file=open("requests.jsonl", "rb"), purpose="batch")
batch = client.batches.create(input_file_id=batch_file.id, endpoint="/v1/chat/completions",
                              completion_window="24h")

batch = client.batches.retrieve(batch.id)
if batch.status == "completed":   # failures: batch.request_counts.failed
    results = client.files.content(batch.output_file_id).text

import hashlib, hmac

def verify(raw_body: bytes, signature: str, secret: str) -> bool:
    expected = hmac.new(secret.encode(), raw_body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, signature)

# Flask example
@app.post("/hooks/vexapi")
def vexapi_hook():
    if not verify(request.get_data(), request.headers["X-VexAPI-Signature"], WEBHOOK_SECRET):
        abort(401)
    event = request.get_json()   # {"type": "batch.completed", "created": …, "data": {…}}
    return "", 204

import crypto from "node:crypto";

function verify(rawBody, signature, secret) {
  const expected = crypto.createHmac("sha256", secret).update(rawBody).digest("hex");
  return crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
}

curl https://api.arioron.com/v1/evals -H "Authorization: Bearer $VEX_API_KEY" -H "Content-Type: application/json" -d '{
  "name": "Capital cities",
  "grader_type": "contains",
  "cases": [
    {"input": "Capital of Australia?", "expected_output": "Canberra"},
    {"input": "Capital of Canada?", "expected_output": "Ottawa"}
  ]
}'
curl https://api.arioron.com/v1/evals/eval_…/runs -H "Authorization: Bearer $VEX_API_KEY" -H "Content-Type: application/json" \
  -d '{"model": "perceptix-vex-amber-2.0"}'

store = client.vector_stores.create(name="Handbook", file_ids=[handbook.id])

response = client.responses.create(
    model="perceptix-vex-amber-2.0",
    input="How many vacation days do new hires get?",
    tools=[{"type": "file_search", "vector_store_ids": [store.id]}],
    include=["file_search_call.results"],   # optional: return the matched passages
)
print(response.output_text)

curl https://api.arioron.com/v1/vector_stores/$STORE_ID/search -H "Authorization: Bearer $VEX_API_KEY" -H "Content-Type: application/json" \
  -d '{"query": "vacation policy", "max_num_results": 3}'

response = client.responses.create(
    model="perceptix-vex-amber-2.0",
    input="Using sales.csv, which region grew fastest from Jan to Feb? Save the growth table as growth.csv.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto", "file_ids": [sales_csv.id]}}],
    include=["code_interpreter_call.outputs"],
)
print(response.output_text)
# Download files the code wrote:
call = next(o for o in response.output if o.type == "code_interpreter_call")
data = client.containers.files.content.retrieve("growth.csv", container_id=call.container_id)

curl https://api.arioron.com/v1/containers/$CONTAINER_ID/execute -H "Authorization: Bearer $VEX_API_KEY" -H "Content-Type: application/json" \
  -d '{"code": "import statistics\nprint(statistics.median([3, 1, 4, 1, 5]))"}'
# {"status": "completed", "exit_code": 0, "stdout": "3\n", "stderr": "", "files": [], ...}

// Server-side (Node 22+). In a browser, use ?api_key= only with short-lived keys.
const ws = new WebSocket("wss://api.arioron.com/v1/realtime?model=vex-realtime",
  { headers: { Authorization: `Bearer ${process.env.VEX_API_KEY}` } });

ws.onopen = () => ws.send(JSON.stringify({
  type: "session.update",
  session: { instructions: "You are a friendly travel agent.", audio: { output: { voice: "bm_george" } } },
}));

// Send microphone audio (PCM16, 24 kHz) as it arrives:
function onMicChunk(pcm16) {
  ws.send(JSON.stringify({ type: "input_audio_buffer.append", audio: Buffer.from(pcm16).toString("base64") }));
}

ws.onmessage = ({ data }) => {
  const event = JSON.parse(data);
  if (event.type === "response.output_audio.delta") playPcm(Buffer.from(event.delta, "base64"));
  if (event.type === "response.output_audio_transcript.delta") process.stdout.write(event.delta);
  if (event.type === "input_audio_buffer.speech_started") stopPlayback();   // user interrupted
};

speech = client.audio.speech.create(
    model="vex-speech",
    voice="Kore",
    input="Your order has shipped and will arrive on Thursday.",
    instructions="Friendly and upbeat.",
)
speech.write_to_file("shipped.mp3")

curl https://api.arioron.com/v1/audio/speech -H "Authorization: Bearer $VEX_API_KEY" -H "Content-Type: application/json" \
  -d '{"model": "vex-speech", "voice": "Puck", "input": "Hello there!"}' --output hello.mp3

with open("meeting.m4a", "rb") as audio:
    transcript = client.audio.transcriptions.create(model="vex-transcribe", file=audio)
print(transcript.text)

curl https://api.arioron.com/v1/audio/transcriptions -H "Authorization: Bearer $VEX_API_KEY" \
  -F file=@meeting.m4a -F response_format=srt

import base64

result = client.images.generate(model="vex-image", prompt="A watercolor fox in a snowy forest", size="1792x1024")
with open("fox.png", "wb") as f:
    f.write(base64.b64decode(result.data[0].b64_json))

curl https://api.arioron.com/v1/moderations -H "Authorization: Bearer $VEX_API_KEY" -H "Content-Type: application/json" \
  -d '{"input": "Text to check"}'
# → {"results": [{"flagged": false, "categories": {"harassment": false, …}}]}

import os
import requests

API = "https://api.arioron.com/v1"
H = {"Authorization": f"Bearer {os.environ['VEX_API_KEY']}"}

session = requests.post(f"{API}/browser/sessions", headers=H, json={"url": "https://news.ycombinator.com"}).json()
act = lambda **a: requests.post(f"{API}/browser/sessions/{session['id']}/actions", headers=H, json=a).json()

elements = act(type="elements")["result"]["elements"]   # [{"ref": 0, "tag": "a", "label": "new", ...}, ...]
act(type="click", text="past")
page = act(type="extract", format="markdown")["result"]
print(page["title"], page["content"][:500])

requests.delete(f"{API}/browser/sessions/{session['id']}", headers=H)

session = requests.post(f"{API}/computer/sessions", headers=H,
                        json={"display": {"width": 1024, "height": 768}, "start_url": "https://www.wikipedia.org"}).json()
shot = session["screenshot"]["data"]          # base64 PNG: show it to your model

act = lambda **a: requests.post(f"{API}/computer/sessions/{session['id']}/actions", headers=H, json=a).json()
act(type="click", x=450, y=493)                 # coordinates your model chose from the screenshot
act(type="type", text="Mount Fuji")
result = act(type="keypress", keys=["ENTER"])
print(result["current_url"])                    # https://en.wikipedia.org/wiki/Mount_Fuji

{
  "error": {
    "type": "invalid_request_error",
    "code": "model_not_found",
    "message": "The model 'gpt-4o' does not exist or is not available. Available models: perceptix-vex-amber-2.0, …",
    "param": "model",
    "request_id": "req_6b1f0c…"
  }
}

raw = client.chat.completions.with_raw_response.create(model="perceptix-vex-amber-2.0", messages=[...])
print(raw.headers["x-request-id"])   # req_…
completion = raw.parse()