> Para sa mga AI agent: step-by-step na gabay sa setup — [`/docs/agents.md`](https://gate.joingonka.ai/docs/agents.md), index ng dokumentasyon — [`/llms.txt`](https://gate.joingonka.ai/llms.txt).

# API reference

Lahat tungkol sa mga request sa gateway: mga protocol, address, key, at parameter. Sa ibaba — streaming, tool calling, reasoning, plugins, at ang halaga ng request sa response.

## Mga protocol at address

Tumatanggap ang gateway ng OpenAI at Anthropic formats. Ang base URL para sa OpenAI SDK ay `https://gate.joingonka.ai/v1`, para sa Anthropic SDK ay `https://gate.joingonka.ai`. Gumagana ang lahat ng protocol sa isang key at isang balance: ang request sa anumang format ay dumadaan sa parehong path.

| Method at path | Format | Para saan | Mga detalye |
| --- | --- | --- | --- |
| `POST /v1/chat/completions` | OpenAI Chat Completions | Chat, agents, tool calls | Pangunahing path: dito isinasalin ng gateway ang iba pang format. |
| `POST /v1/messages` | Anthropic Messages | Claude Code at Anthropic SDK | Base URL na walang `/v1`; ang mga modelong `claude-*` ay pinapalitan ng inirerekomenda; required ang field na `max_tokens`. |
| `POST /v1/responses` | OpenAI Responses | Codex CLI at mga bagong OpenAI SDK | Walang state: ipadala ang buong history sa bawat request. |
| `POST /v1/completions` | OpenAI Completions (legacy) | Autocomplete at pag-edit ng code sa mga editor | Ang `suffix` ay ipinapasa sa modelo bilang hint; sa response ay `logprobs: null`. |
| `POST /v1/embeddings` | OpenAI Embeddings | Vector representations ng text | Response na `501`: walang embedding models sa network. |

### Mga reference address

Sumasagot nang walang key. Ang talahanayan ng mga modelo na may context at status ay nasa seksyong [Mga Modelo](https://gate.joingonka.ai/tl/docs/models).

| Method at path | Paglalarawan |
| --- | --- |
| `GET /v1/models` | Listahan ng mga modelo: context, presyo, mga sinusuportahang parameter — mga field sa OpenRouter format. |
| `GET /v1/models/{model}` | Card ng isang modelo; ang slash sa id — as is o `%2F`. Nakatago o hindi kilalang modelo — `404 model_not_found`. |
| `GET /v1/capabilities` | Mga kakayahan ng gateway: parameters, protocols, plugins, cost fields, at limits (`limits`). |
| `GET /v1/plugins` | Mga plugin: id at pangalan. |
| `GET /v1/network-status` | Estado ng mga modelo ng network: availability, latency, uptime. |
| `GET /v1/nodes` | Buod ng node pool: ilan ang total, active, at nasa quarantine. |
| `GET /v1/web-search/engines` | Kung naka-enable ang web search at ano ang estado ng mga engine nito. |

### Anthropic Messages

- Base URL — `https://gate.joingonka.ai`: idadagdag mismo ng SDK ang `/v1/messages`.
- Key — sa header na `x-api-key` (ganito ang ipinapadala ng Anthropic SDK) o `Authorization: Bearer`.
- Ang mga modelong `claude-*` ay pinapalitan ng gateway ng inirerekomenda (`MiniMaxAI/MiniMax-M2.7`); sa field na `model` ng response, nananatili ang pangalang ipinadala ng client.
- Required ang `max_tokens`, tulad sa Anthropic API; kung lumampas sa ceiling ng modelo — pinuputol.
- Stream — Anthropic events; sa mga pause, nagpapadala ang gateway ng `event: ping`, dumarating ang error bilang event na `event: error`.
- Hindi kasama sa response ang reasoning ng modelo: walang `thinking` blocks.
- Ang built-in na tool na `web_search` ay pinapatupad ng web search plugin ng gateway — tingnan ang seksyong [Mga plugin](https://gate.joingonka.ai/tl/docs/api#plugins).
- Walang token counting (`/v1/messages/count_tokens`) — response na `404`.

Mas madaling i-setup ang Claude Code gamit ang installer — [pagkonekta ng mga tool](https://gate.joingonka.ai/tl/docs#connect). Manu-manong paraan — gamit ang environment variables; ang `ANTHROPIC_MODEL` ay nagpi-pin ng network model.

#### Claude Code

```bash
export ANTHROPIC_BASE_URL=https://gate.joingonka.ai
export ANTHROPIC_AUTH_TOKEN=$JOINGONKA_API_KEY
export ANTHROPIC_MODEL=MiniMaxAI/MiniMax-M2.7
claude
```

#### cURL

```bash
curl https://gate.joingonka.ai/v1/messages \
  -H "x-api-key: $JOINGONKA_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MiniMaxAI/MiniMax-M2.7",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "What is Gonka?"}]
  }'
```

### OpenAI Responses

- Hindi nag-iimbak ng responses ang gateway: ipadala ang buong history sa `input`. Ang mga field na `previous_response_id` at `conversation` — error na `400` na may code.
- Tinatanggap ang `store` at wala itong binabago.
- Mga tool: `function` at `web_search` — pinapatupad ito ng web search plugin. Ang iba pang built-in na tool ay nilalaktawan ng gateway, at ang request ay tumatakbo nang wala ang mga ito; ang paghingi ng ganoong tool sa pamamagitan ng `tool_choice` — error na `400`.
- Ang mga parteng `input_image` at `input_file` — error na `400`: text lang ang kayang gawin ng mga modelo ng network.
- Ang mga state address (`GET /v1/responses/{id}`, `DELETE /v1/responses/{id}`, `GET /v1/responses/{id}/input_items`, `POST /v1/responses/{id}/cancel`, `POST /v1/responses/compact`) ay sumasagot ng `404` na may code — hindi nag-iimbak ng responses ang gateway.
- Codex CLI: itakda ang sariling provider id sa `model_provider` (hindi openai) — sa ganoon, ang Codex mismo ang nag-compress ng history, walang `/v1/responses/compact`.

### Legacy Completions

- Ang `prompt` — string o array na may isang string; ang response — sa `choices[].text`. Maraming prompt o tokens sa halip na text — error na `400`.
- Ang `suffix` ay ipinapasa sa modelo bilang hint sa prompt: walang tunay na middle fill ang network.
- Sa response ay `logprobs: null`; hindi pinapansin ang `best_of`; gumagana ang `echo`.

## Mga key at authorization

Ipinapasa ang key sa header na `Authorization: Bearer jg-…` o `x-api-key: jg-…` — sa lahat ng address. Ginagawa ang key pagkatapos ng registration sa page na [gate.joingonka.ai/keys](https://gate.joingonka.ai/keys).

| Prefix | Key | Mga request sa mga modelo |
| --- | --- | --- |
| `jg-` | Karaniwang key ng account | oo |
| `gc-` | Child key: sariling limits, gastos — mula sa balance ng may-ari | oo |
| `gm-` | Management key: para sa pamamahala ng mga child key lang | hindi — `403 forbidden` |

- Bawat key sa account ay maaaring bigyan ng limit sa gastos kada araw, kada buwan, at total; paglampas — `402 child_key_limit_exceeded`.
- Limitado ang bilang ng request kada minuto bawat key — ang mga value ay nasa seksyong [Mga limitasyon](https://gate.joingonka.ai/tl/docs/errors#limits).
- Walang key na gumagana maliban sa demo chat sa site: ang request na walang key mula sa sariling code ay makakatanggap ng `402` na may `is_demo`.
- Sa account lang pinapamahalaan ang mga key: ang `/api/keys` na may API key ay hindi available. Balance at gastos bawat key — [API ng account](https://gate.joingonka.ai/tl/docs/billing#account-api).

> Ang susi ay isang sikreto: huwag itong itago sa repository o sa code ng frontend, ipasa ito sa pamamagitan ng mga environment variable.

## Mga halimbawa

Isang kahilingan, apat na SDK. Ang modelo ay ang inirerekomenda (`MiniMaxAI/MiniMax-M2.7`), ang susi ay mula sa environment variable na `JOINGONKA_API_KEY`.

### Python

```python
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://gate.joingonka.ai/v1",
    api_key=os.environ["JOINGONKA_API_KEY"],
)

response = client.chat.completions.create(
    model="MiniMaxAI/MiniMax-M2.7",
    messages=[{"role": "user", "content": "What is Gonka?"}],
)
print(response.choices[0].message.content)
```

### TypeScript

```typescript
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://gate.joingonka.ai/v1",
  apiKey: process.env.JOINGONKA_API_KEY,
});

const response = await client.chat.completions.create({
  model: "MiniMaxAI/MiniMax-M2.7",
  messages: [{ role: "user", content: "What is Gonka?" }],
});
console.log(response.choices[0].message.content);
```

### cURL

```bash
curl https://gate.joingonka.ai/v1/chat/completions \
  -H "Authorization: Bearer $JOINGONKA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MiniMaxAI/MiniMax-M2.7",
    "messages": [{"role": "user", "content": "What is Gonka?"}]
  }'
```

### Anthropic SDK

```python
import os
import anthropic

client = anthropic.Anthropic(
    base_url="https://gate.joingonka.ai",
    api_key=os.environ["JOINGONKA_API_KEY"],
)

message = client.messages.create(
    model="MiniMaxAI/MiniMax-M2.7",
    max_tokens=1024,
    messages=[{"role": "user", "content": "What is Gonka?"}],
)
print(message.content[0].text)
```

### Streaming na tugon

#### Python

```python
import os
from openai import OpenAI

client = OpenAI(base_url="https://gate.joingonka.ai/v1", api_key=os.environ["JOINGONKA_API_KEY"])

stream = client.chat.completions.create(
    model="MiniMaxAI/MiniMax-M2.7",
    messages=[{"role": "user", "content": "What is Gonka?"}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
```

#### TypeScript

```typescript
import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://gate.joingonka.ai/v1", apiKey: process.env.JOINGONKA_API_KEY });

const stream = await client.chat.completions.create({
  model: "MiniMaxAI/MiniMax-M2.7",
  messages: [{ role: "user", content: "What is Gonka?" }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}
```

#### cURL

```bash
curl -N https://gate.joingonka.ai/v1/chat/completions \
  -H "Authorization: Bearer $JOINGONKA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MiniMaxAI/MiniMax-M2.7",
    "messages": [{"role": "user", "content": "What is Gonka?"}],
    "stream": true
  }'
```

#### Anthropic SDK

```python
import os
import anthropic

client = anthropic.Anthropic(base_url="https://gate.joingonka.ai", api_key=os.environ["JOINGONKA_API_KEY"])

with client.messages.stream(
    model="MiniMaxAI/MiniMax-M2.7",
    max_tokens=1024,
    messages=[{"role": "user", "content": "What is Gonka?"}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
```

## Mga parameter ng kahilingan

Ang mga parameter ng `POST /v1/chat/completions` na garantiyado mismo ng gateway — ang listahang `supported_parameters` sa sagot ng capabilities:

| Parameter | Paglalarawan |
| --- | --- |
| `temperature` | Ang randomness ng tugon: mas mataas, mas iba-iba. |
| `top_p` | Pagpili ng mga token ayon sa kabuuang probabilidad. |
| `top_k` | Pagpili mula sa k pinaka-malamang na mga token. |
| `min_p` | Pagtatanggal ng mga token na mababa ang probabilidad kumpara sa pinaka-malamang. |
| `frequency_penalty` | Parusa sa madalas na pag-uulit. |
| `presence_penalty` | Parusa sa mga token na lumitaw na. |
| `repetition_penalty` | Multiplier laban sa pag-uulit. |
| `stop` | Mga string kung saan humihinto ang generasyon. |
| `seed` | Seed para sa reproducibility. |
| `max_tokens` | Limitasyon ng mga token ng tugon; lampas sa kisame ng modelo — pinuputol hanggang sa kisame. |
| `max_completion_tokens` | Isa pang pangalan ng `max_tokens`: inililipat ng gateway ang halaga dito. |
| `tools` | Mga function na maaaring tawagin ng modelo, sa format ng OpenAI. |
| `tool_choice` | Kung tatawagin ang function: bahala sa modelo, hindi kailanman, sapilitan, o isang partikular. |
| `response_format` | May istrukturang tugon: `json_object` o `json_schema`. |

- Kung walang `temperature`, naglalagay ang gateway ng `0.7`.
- Kung walang `max_tokens`, naglalagay ang gateway ng default ng modelo: walang stream — mas maikli, sa stream — kisame ng modelo. Ang mga numero ayon sa modelo — sa seksyong [Mga limitasyon](https://gate.joingonka.ai/tl/docs/errors#limits).

### Ipinapasa sa network nang ganito

`reasoning_effort`, `reasoning`, `enable_thinking`, `chat_template_kwargs`, `thinking_token_budget`, `min_tokens`, `logit_bias`, `n`, `parallel_tool_calls`, `extra_body`. Hindi ito sinusuri ng gateway: ang halagang wala sa listahan ng network — error na `400` na may type na `api_error`.

### Hindi ipinapasa sa network

Ang iba pang field ay tinatanggap ng gateway at hindi ipinapasa sa network — halimbawa, `user`, `metadata`, `store`, `logprobs`, `top_logprobs`, `thinking`, `stream_options`, `web_search_options`. Ang `usage` sa stream ay laging dumarating.

## Streaming

- `stream: true` — tugon sa mga event na SSE; ang huling event — `data: [DONE]`.
- Bago ang pagtatapos ay dumarating ang chunk na may `usage` — lagi, kahit walang `stream_options`.
- Sa mga paghinto, bawat 15 s ay nagpapadala ang gateway ng komentong `: keep-alive` — nilalaktawan ito ng mga SSE client.
- Habang hindi pa bukas ang stream, ang pagtanggi ay dumarating sa karaniwang response code; pagkatapos mabuksan — sa chunk na `joingonka-error`.
- Sa `delta.tool_calls` — isang tawag bawat chunk: ang mga tawag na pinagdikit ng network ay hinihiwalay ng gateway.

```text
data: {"object":"chat.completion.chunk","model":"MiniMaxAI/MiniMax-M2.7","choices":[{"index":0,"delta":{"content":"Hi"},"finish_reason":null}]}

data: {"object":"chat.completion.chunk","model":"MiniMaxAI/MiniMax-M2.7","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: {"object":"chat.completion.chunk","model":"MiniMaxAI/MiniMax-M2.7","choices":[],"usage":{"prompt_tokens":12,"completion_tokens":2,"total_tokens":14}}

data: [DONE]
```

### Mga service chunk ng gateway

Makikilala ang mga ito sa field na `id`:

| `id` | Kailan at ano ang nasa loob |
| --- | --- |
| `joingonka-error` | Pagkabigo pagkatapos mabuksan ang stream: field na `error`, pagkatapos ay putol na walang `[DONE]`. |
| `joingonka-stream-stalled` | Tumahimik ang network nang mas matagal kaysa sa pinapayagang paghinto: nagsasara ang stream na may `finish_reason: stop`. |
| `joingonka-stream-unfinished` | Pinutol ng network ang generasyon: `finish_reason: length` — ipagpatuloy sa susunod na kahilingan. |
| `joingonka-citations` | Mga pinagmulan ng web search sa `delta.annotations` — bago ang pagtatapos. |
| `joingonka-meta` | Gastos at timing — may header na `x-joingonka-meta: 1` lamang. |

### Stream sa iba pang protocol

- Anthropic Messages: mga event mula `message_start` hanggang `message_stop`, sa mga paghinto `event: ping`, pagkabigo — `event: error`.
- OpenAI Responses: mga event na `response.*`, pagkabigo — `response.failed`.
- Legacy Completions: sa pagkabigo — `data: {"error": …}`, pagkatapos ay `[DONE]`.

## Pagtawag ng tool

- Format ng OpenAI: `tools` at `tool_choice`. Tinatanggap din ang lumang format na `functions` at `function_call` — darating ang tugon sa parehong format.
- Sa stream — isang tawag bawat chunk: ang mga client na binabasa lamang ang unang elemento ay hindi nawawalan ng mga tawag.
- Ang kasaysayan kung saan magbabalik sana ng error na `400` ang network ay inaayos ng gateway: ang papel na `developer` ay nagiging `system`, ang mga walang laman at paulit-ulit na id ng tawag ay binibigyan ng natatangi, ang `arguments` bilang object ay ginagawang JSON string, ang nawawalang `type` ay dinadagdagan, ang tawag na walang pangalan ay tinatanggal kasama ang resulta.
- Ang tawag na isinulat ng modelo bilang markup sa teksto ay inililipat ng gateway sa `tool_calls`; ang mga huwad na tawag sa sagot sa kahilingang walang tool ay tinatanggal.
- Naputol ang generasyon sa gitna ng mga argumento — darating ang `finish_reason: length`, hindi ang `tool_calls`: taasan ang limitasyon ng tugon.

```json
{
  "model": "MiniMaxAI/MiniMax-M2.7",
  "messages": [{"role": "user", "content": "What is the weather in Paris?"}],
  "tools": [{
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "Current weather for a city",
      "parameters": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"]
      }
    }
  }]
}
```

### Mga limitasyon ng JSON-Schema

Ang mga schema ng tool at `response_format` ay kinokompila ng network sa gramatika; ang mga regular expression — sa engine na RE2. Ginagabayan ng gateway ang schema sa anyong tatanggapin ng network:

- Ang `$ref` ay ibinubukas sa lugar, ang mga seksyong `$defs` at `definitions` ay tinatanggal; ang recursive reference ay nagiging schema na walang limitasyon.
- Ang `pattern` na may mga konstruksyon na wala sa RE2 (lookahead at lookbehind, backreference, atomic group, possessive quantifier) ay inaalis; ang mga pag-uulit na higit sa 1000 ay pinaiikli hanggang 1000.
- Ang `anyOf` at `oneOf` mula sa mga constant ay nagsasama-sama sa `enum`; kung ang mga hindi masasamang sangay ay higit sa 16, ang unyon ay inaalis.

> Maaaring maging mas maluwag ang schema kaysa sa orihinal — suriin ang mga argumento ng tawag sa inyong panig.

## May istrukturang tugon

`response_format`: `{"type": "json_object"}` — tugon na valid na JSON, `{"type": "json_schema", "json_schema": {"name": …, "schema": …}}` — ayon sa inyong schema na may mga limitasyon sa itaas. Ang pinutol na JSON na walang stream ay inaayos ng plugin na `response-healing`.

```json
{
  "model": "MiniMaxAI/MiniMax-M2.7",
  "messages": [{"role": "user", "content": "Name three planets."}],
  "response_format": {
    "type": "json_schema",
    "json_schema": {
      "name": "planets",
      "schema": {
        "type": "object",
        "properties": {"planets": {"type": "array", "items": {"type": "string"}}},
        "required": ["planets"]
      }
    }
  }
}
```

## Pangangatwiran

- Ang pangangatwiran ng modelo ay dumarating hiwalay sa tugon: `message.reasoning_content`, sa stream — `delta.reasoning_content`. Ang field na `reasoning` ay pinapalitan ng pangalan ng gateway sa format na ito.
- Ang pangangatwiran ay gumagastos ng `max_tokens`: sa maliit na limitasyon, napuputol ang tugon (`finish_reason: length`) bago pa ang teksto.
- Kung walang teksto ng tugon ngunit may pangangatwiran, inililipat ito ng gateway sa `content` — maliban sa mga tugon na may tawag ng tool.
- Ang `reasoning_effort` at `reasoning.effort` ay ipinapasa sa network. Kung ang modelo ay may dalawang mode lamang, iniaayos ng gateway ang halaga sa mga ito: `none` at `minimal` — sa `low`, mas mataas — sa default na pangangatwiran.
- Kung tinanggihan ng node ang halaga, ibinababa ito ng gateway (`max` at `xhigh` → `high`, `minimal` → `low`, kung hindi ay inaalis ang field) at inuulit ang kahilingan.
- Sa `/v1/messages`, hindi ipinapasa ang pangangatwiran — walang mga block na `thinking`.

## Mga plugin

Ang mga plugin ay pinapagana ng field na `plugins` — array ng mga string o object na may mga opsyon. Ang listahan — `GET /v1/plugins`.

| Plugin | Paglalarawan | Mga kondisyon |
| --- | --- | --- |
| `response-healing` | Inaayos ang pinutol na JSON sa tugon ng modelo. | Walang stream lamang at kung ang tugon ay nagsisimula sa `{` o `[`. |
| `privacy-sanitization` | Tinatakpan sa mga text message ang email, IPv4, numero ng card, JWT, 64-character hex key at mga key na parang `sk-…`, `gw_…`, `gm-…`, `Bearer …`. | Mode — field na `privacy_mode`: `redact` (default) o `tokenize`. |
| `file-parser` | Kinukuha ang teksto mula sa PDF. | Kung ang teksto ng mensahe ay buong PDF sa base64: `data:application/pdf;base64,…` o walang prefix. |
| `web` | Web search: ang mga resulta ay hinahalo sa kahilingan, ang tugon ay nakakakuha ng mga link sa mga pinagmulan. | Kasama ng `privacy-sanitization` — error na `400`. |

### Web search

- Mga opsyon: `max_results` — mula 1 hanggang 10, default 5; `engine` — hint ng engine; `search_prompt` — sariling teksto bago ang mga resulta; `enabled: false` — patayin ang paghahanap.
- Mga pinagmulan — sa `message.annotations[].url_citation`; sa stream — chunk na `joingonka-citations` bago ang pagtatapos.
- `mode: "agent"` — ang modelo mismo ang nagpapasya kung maghahanap at ano; `max_searches` — mula 1 hanggang 5, default 3.
- Pagbabayad: sa normal na mode — mga token lang (kasama sa input tokens ang mga resulta ng paghahanap); sa agent mode — mga token ng lahat ng hakbang at 1000 nGNK para sa bawat isinagawang paghahanap (`x_joingonka.web_search_surcharge_ngonka`).
- Sa Anthropic Messages at OpenAI Responses, ang built-in na tool na `web_search` ay nagpapatupad ng parehong plugin sa agent mode.

#### plugins: web

```json
{
  "model": "MiniMaxAI/MiniMax-M2.7",
  "messages": [{"role": "user", "content": "What is new in the Gonka network?"}],
  "plugins": [{"id": "web", "max_results": 5}]
}
```

#### mode: agent

```json
{
  "model": "MiniMaxAI/MiniMax-M2.7",
  "messages": [{"role": "user", "content": "What is new in the Gonka network?"}],
  "plugins": [{"id": "web", "mode": "agent", "max_searches": 3}]
}
```

## Gastos at mga service field

Ang sagot na walang stream ay nagdadala ng gastos ng request sa `usage`:

| Field | Paglalarawan |
| --- | --- |
| `usage.cost_gnk` | Gastos ng request sa GNK |
| `usage.platform_fee_gnk` | Mula rito — ang markup ng platform, GNK |
| `usage.total_cost_gnk` | Kabuuan na ibabawas sa GNK |
| `usage.total_cost_usd` | Kabuuan sa dolyar ayon sa kasalukuyang rate ng GNK |

- Sa stream, ang `usage` ay naglalaman lamang ng mga token; ang gastos — sa chunk na `joingonka-meta`.
- Sa header na `x-joingonka-meta: 1`, ang sagot na `POST /v1/chat/completions` ay nakakakuha ng block na `x_joingonka`: gastos (`cost_ngonka`), balanse pagkatapos ng pagbawas (`balance_ngonka`, walang stream lang) at mga timing (`ttft_ms`). Hindi ibinibigay ng ibang protocol ang block na ito.
- `x-request-id` — identifier ng request: isama ito sa iyong pakikipag-ugnayan sa support.
- Dumarating ang `Retry-After` kasama ng `429`: ganoong karaming segundo ang hintayin bago ulitin.
- Ang mga header na `X-Title` at `HTTP-Referer` (tulad ng sa OpenRouter) ay tumutulong sa gateway na makilala ang iyong app; hindi iniimbak ang kanilang teksto.

## Mga limitasyon

- Mga larawan: ang mga bahaging `image_url` ay pinapalitan ng text placeholder — hindi nakikita ng modelo ang larawan (`vision: false` sa mga kakayahan).
- Mula sa browser, ang API ay maa-access lamang mula sa mga domain ng JoinGonka (check ng `Origin`): tawagin ito mula sa iyong server, huwag ilagay ang key sa frontend.
- Mga embedding: ang `POST /v1/embeddings` ay tumutugon ng `501` — walang embedding models sa network.
- Mga error code, limitasyon at timeout — sa seksyong [Mga Error at Limit](https://gate.joingonka.ai/tl/docs/errors).