> Для получения чистого Markdown любой страницы добавьте .md к URL‑адресу страницы.  
> Для полного индекса документации см. https://api.vega.chat/docs/llms.txt.  
> Для полного содержания документации см. https://api.vega.chat/docs/llms-full.txt.  
> Для интеграции AI‑клиентов (Claude Code, Cursor и др.) подключитесь к MCP‑серверу по адресу https://api.vega.chat/docs/_mcp/server.

# Маршрутизация провайдеров

VEGA маршрутизирует запросы к лучшим доступным провайдерам для вашей модели. По умолчанию [запросы балансируются по нагрузке](#price-based-load-balancing-default-strategy) между топ‑провайдерами, чтобы максимизировать время безотказной работы.

Вы можете настроить, как ваши запросы будут маршрутизироваться, используя объект `provider` в теле запроса для [Chat Completions](/docs/api-reference/chat-completion).

Объект `provider` может содержать следующие поля:

| Поле                      | Тип               | По умолчанию | Описание                                                                                                                                                      |
| -------------------------- | ----------------- | ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `order`                    | string\[]         | -             | Список slug‑ов провайдеров в порядке попытки (например, `["anthropic", "openai"]`). [Подробнее](#ordering-specific-providers)                                   |
| `allow_fallbacks`          | boolean           | `true`        | Разрешать резервные провайдеры, если основной недоступен. [Подробнее](#disabling-fallbacks)                                                                    |
| `require_parameters`       | boolean           | `false`       | Использовать только провайдеры, поддерживающие все параметры вашего запроса. [Подробнее](#requiring-providers-to-support-all-parameters-beta)                     |
| `data_collection`          | "allow" \| "deny" | "allow"       | Управлять использованием провайдеров, которые могут сохранять данные. [Подробнее](#requiring-providers-to-comply-with-data-policies)                               |
| `zdr`                      | boolean           | -             | Ограничить маршрутизацию только ZDR (Zero Data Retention) конечными точками. [Подробнее](#zero-data-retention-enforcement)                                      |
| `enforce_distillable_text` | boolean           | -             | Ограничить маршрутизацию только моделями, допускающими дистилляцию текста. [Подробнее](#distillable-text-enforcement)                                         |
| `only`                     | string\[]         | -             | Список slug‑ов провайдеров, разрешённых для этого запроса. [Подробнее](#allowing-only-specific-providers)                                                       |
| `ignore`                   | string\[]         | -             | Список slug‑ов провайдеров, которые следует пропустить для этого запроса. [Подробнее](#ignoring-providers)                                                    |
| `quantizations`            | string\[]         | -             | Список уровней квантизации для фильтрации (например, `["int4", "int8"]`). [Подробнее](#quantization)                                                          |
| `sort`                     | string \| object  | -             | Сортировать провайдеры по цене, пропускной способности или задержке. Может быть строкой (например, `"price"`) или объектом с полями `by` и `partition`. [Подробнее](#provider-sorting) |
| `preferred_min_throughput` | number \| object  | -             | Предпочтительная минимальная пропускная способность (токенов/сек). Может быть числом или объектом с процентильными порогами (p50, p75, p90, p99). [Подробнее](#performance-thresholds) |
| `preferred_max_latency`    | number \| object  | -             | Предпочтительная максимальная задержка (секунды). Может быть числом или объектом с процентильными порогами (p50, p75, p90, p99). [Подробнее](#performance-thresholds) |
| `max_price`                | object            | -             | Максимальная цена, которую вы готовы платить за этот запрос. [Подробнее](#maximum-price)                                                                        |

VEGA поддерживает маршрутизацию в пределах ЕС для корпоративных клиентов. При включении запросы и ответы обрабатываются полностью в ЕС. Подробнее в наших [документах по конфиденциальности](/docs/guides/privacy/provider-logging#enterprise-eu-in-region-routing). Чтобы связаться с нашей корпоративной командой, [заполните эту форму](https://api.vega.chat/enterprise/form).

## Балансировка нагрузки на основе цены (стратегия по умолчанию)

Для каждой модели в вашем запросе поведение VEGA по умолчанию — балансировать запросы между провайдерами, отдавая приоритет цене.

Если вам важнее пропускная способность, чем цена, вы можете использовать поле `sort`, чтобы явно отдать приоритет пропускной способности.

Когда вы отправляете запрос с `tools` или `tool_choice`, VEGA будет маршрутизировать только к провайдерам, поддерживающим использование инструментов. Аналогично, если вы задаёте `max_tokens`, VEGA будет маршрутизировать только к провайдерам, поддерживающим ответы такой длины.

Стратегия балансировки нагрузки VEGA по умолчанию:

1. Приоритет провайдерам, у которых не было значительных сбоев за последние 30 секунд.  
2. Среди стабильных провайдеров смотреть на кандидатов с наименьшей стоимостью и выбирать их с весом, обратным квадрату цены (пример ниже).  
3. Оставшиеся провайдеры использовать как резервные.

Если провайдер A стоит 100 ₽ за миллион токенов, провайдер B — $2, а провайдер C — $3, и у провайдера B недавно были сбои:

* Ваш запрос будет направлен к провайдеру A. Провайдер A в 9 раз более вероятен, чем провайдер C, потому что $(1 / 3^2 = 1/9)$ (обратный квадрат цены).  
* Если провайдер A не справится, будет попытка с провайдером C.  
* Если провайдер C тоже не справится, последней будет попытка с провайдером B.

Если в ваших предпочтениях провайдера заданы `sort` или `order`, балансировка нагрузки будет отключена.

## Сортировка провайдеров

Как описано выше, VEGA балансирует по цене, учитывая время безотказной работы.

Если вы хотите *явно* отдать приоритет определённому атрибуту провайдера, включите поле `sort` в настройках `provider`. Балансировка будет отключена, и роутер будет пробовать провайдеры в указанном порядке.

Три варианта сортировки:

* `"price"`: отдать приоритет самой низкой цене  
* `"throughput"`: отдать приоритет самой высокой пропускной способности  
* `"latency"`: отдать приоритет самой низкой задержке  

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  model: 'meta-llama/llama-3.3-70b-instruct',
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    sort: 'throughput',
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'HTTP-Referer': '<YOUR_SITE_URL>',
    'X-OpenRouter-Title': '<YOUR_SITE_NAME>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'meta-llama/llama-3.3-70b-instruct',
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      sort: 'throughput',
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'HTTP-Referer': '<YOUR_SITE_URL>',
  'X-OpenRouter-Title': '<YOUR_SITE_NAME>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'model': 'meta-llama/llama-3.3-70b-instruct',
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'sort': 'throughput',
  },
})
```

Чтобы *всегда* отдавать приоритет низким ценам и не применять балансировку, установите `sort` в `"price"`.

Чтобы *всегда* отдавать приоритет низкой задержке и не применять балансировку, установите `sort` в `"latency"`.

## Быстрый способ Nitro

Вы можете добавить `:nitro` к любому slug модели как сокращение для сортировки по пропускной способности. Это полностью эквивалентно установке `provider.sort` в `"throughput"`.

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  model: 'meta-llama/llama-3.3-70b-instruct:nitro',
  messages: [{ role: 'user', content: 'Hello' }],
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'meta-llama/llama-3.3-70b-instruct:nitro',
    messages: [{ role: 'user', content: 'Hello' }],
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'model': 'meta-llama/llama-3.3-70b-instruct:nitro',
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
})
```

## Быстрый способ Floor

Вы можете добавить `:floor` к любому slug модели как сокращение для сортировки по цене. Это полностью эквивалентно установке `provider.sort` в `"price"`.

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  model: 'meta-llama/llama-3.3-70b-instruct:floor',
  messages: [{ role: 'user', content: 'Hello' }],
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'meta-llama/llama-3.3-70b-instruct:floor',
    messages: [{ role: 'user', content: 'Hello' }],
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'model': 'meta-llama/llama-3.3-70b-instruct:floor',
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
})
```

## Продвинутая сортировка с разделением (partition)

При использовании [fallback‑моделей](/docs/features/model-routing) поле `sort` можно задать как объект с дополнительными опциями, контролирующими, как конечные точки сортируются между несколькими моделями.

| Поле                | Тип   | По умолчанию | Описание                                                                 |
| ------------------- | ----- | ------------- | ------------------------------------------------------------------------ |
| `sort.by`           | string| -             | Стратегия сортировки: `"price"`, `"throughput"` или `"latency"`.        |
| `sort.partition`   | string| `"model"`     | Как группировать конечные точки для сортировки: `"model"` (по умолчанию) или `"none"`. |

По умолчанию, когда вы указываете несколько моделей (fallback‑модели), VEGA группирует конечные точки по модели перед сортировкой. Это значит, что конечные точки основной модели всегда пробуются первыми, независимо от их характеристик. Установка `partition` в `"none"` убирает эту группировку, позволяя сортировать конечные точки глобально по всем моделям.

Чтобы явно использовать поведение по умолчанию, задайте `partition: "model"`. Подробнее о работе fallback‑моделей см. в разделе [Model Fallbacks](/docs/guides/routing/model-fallbacks).

`preferred_max_latency` и `preferred_min_throughput` **не гарантируют**, что вы получите провайдера или модель с указанным уровнем производительности. Однако провайдеры и модели, соответствующие вашим порогам, будут предпочтительнее. Указание этих предпочтений никогда не помешает выполнению вашего запроса. Это отличается от `max_price`, который может полностью блокировать запрос, если цена превышает указанный лимит.

### Сценарий 1: Маршрутизация к модели с наивысшей пропускной способностью или наименьшей задержкой

Когда у вас есть несколько приемлемых моделей и вы хотите использовать ту, которая сейчас показывает лучшую производительность, используйте `partition: "none"` вместе с сортировкой по пропускной способности или задержке. Это полезно, когда важна скорость, а не конкретная модель.

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  models: [
    'anthropic/claude-sonnet-4.5',
    'openai/gpt-5-mini',
    'google/gemini-3-flash-preview',
  ],
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    sort: {
      by: 'throughput',
      partition: 'none',
    },
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    models: [
      'anthropic/claude-sonnet-4.5',
      'openai/gpt-5-mini',
      'google/gemini-3-flash-preview',
    ],
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      sort: {
        by: 'throughput',
        partition: 'none',
      },
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'models': [
    'anthropic/claude-sonnet-4.5',
    'openai/gpt-5-mini',
    'google/gemini-3-flash-preview',
  ],
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'sort': {
      'by': 'throughput',
      'partition': 'none',
    },
  },
})
```

```bash title="cURL"
curl https://api.vega.chat/api/v1/chat/completions \
  -H "Authorization: Bearer <VEGA_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "models": [
      "anthropic/claude-sonnet-4.5",
      "openai/gpt-5-mini",
      "google/gemini-3-flash-preview"
    ],
    "messages": [{ "role": "user", "content": "Hello" }],
    "provider": {
      "sort": {
        "by": "throughput",
        "partition": "none"
      }
    }
  }'
```

В этом примере VEGA будет направлять запрос к любой конечной точке из всех трёх моделей, которая в данный момент имеет наивысшую пропускную способность, вместо того чтобы всегда сначала пробовать Claude.

## Пороговые значения производительности

Вы можете задать минимальную пропускную способность или максимальную задержку, чтобы отфильтровать конечные точки. Конечные точки, не соответствующие этим порогам, будут перемещены в конец списка, а не полностью исключены.

| Поле                      | Тип               | По умолчанию | Описание                                                                 |
| -------------------------- | ----------------- | ------------ | ----------------------------------------------------------------------- |
| `preferred_min_throughput` | number \| object  | -            | Предпочтительная минимальная пропускная способность в токенах/сек. Может быть числом (применяется к p50) или объектом с процентильными порогами. |
| `preferred_max_latency`    | number \| object  | -            | Предпочтительная максимальная задержка в секундах. Может быть числом (применяется к p50) или объектом с процентильными порогами. |

### Как работают процентильные показатели

VEGA отслеживает метрики задержки и пропускной способности для каждой модели и провайдера, используя процентильные статистики, рассчитанные за скользящее 5‑минутное окно. Доступные процентильные показатели:

* **p50** (медиана): 50 % запросов работают лучше этого значения  
* **p75**: 75 % запросов работают лучше этого значения  
* **p90**: 90 % запросов работают лучше этого значения  
* **p99**: 99 % запросов работают лучше этого значения  

Более высокие процентильные показатели (p90, p99) дают большую уверенность в худших сценариях, тогда как более низкие (p50) отражают типичную производительность. Например, если у модели и провайдера p90‑задержка = 2 сек., это значит, что 90 % запросов завершаются быстрее 2 сек.

Когда вы указываете несколько процентильных порогов, **все** указанные пороги должны быть выполнены, чтобы модель и провайдер попали в предпочтительную группу. Это позволяет задавать как типичные, так и худшие требования к производительности.

### Когда использовать процентильные предпочтения

* **Реальное время**: используйте пороги p90 или p99, чтобы обеспечить стабильные времена отклика для пользовательских функций.  
* **Пакетная обработка**: используйте p50‑пропускную способность, когда важна средняя производительность.  
* **Соответствие SLA**: комбинируйте несколько процентильных порогов, чтобы гарантировать выполнение соглашений об уровне обслуживания.  
* **Оптимизация стоимости**: совместите с `sort: "price"`, чтобы получить самый дешёвый провайдер, удовлетворяющий требованиям к производительности.

### Сценарий 2: Найти самую дешёвую модель, удовлетворяющую требованиям к производительности

Комбинируйте `partition: "none"` с пороговыми значениями, чтобы найти самый дешёвый вариант среди нескольких моделей, который удовлетворяет вашим требованиям к производительности. Это полезно, когда у вас есть «пол" по производительности», но вы хотите минимизировать затраты.

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  models: [
    'anthropic/claude-sonnet-4.5',
    'openai/gpt-5-mini',
    'google/gemini-3-flash-preview',
  ],
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    sort: {
      by: 'price',
      partition: 'none',
    },
    preferredMinThroughput: {
      p90: 50, // Предпочитать провайдеров с >50 токенов/сек для 90 % запросов за последние 5 минут
    },
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    models: [
      'anthropic/claude-sonnet-4.5',
      'openai/gpt-5-mini',
      'google/gemini-3-flash-preview',
    ],
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      sort: {
        by: 'price',
        partition: 'none',
      },
      preferred_min_throughput: {
        p90: 50, // Предпочитать провайдеров с >50 токенов/сек для 90 % запросов за последние 5 минут
      },
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'models': [
    'anthropic/claude-sonnet-4.5',
    'openai/gpt-5-mini',
    'google/gemini-3-flash-preview',
  ],
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'sort': {
      'by': 'price',
      'partition': 'none',
    },
    'preferred_min_throughput': {
      'p90': 50, # Предпочитать провайдеров с >50 токенов/сек для 90 % запросов за последние 5 минут
    },
  },
})
```

```bash title="cURL"
curl https://api.vega.chat/api/v1/chat/completions \
  -H "Authorization: Bearer <VEGA_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "models": [
      "anthropic/claude-sonnet-4.5",
      "openai/gpt-5-mini",
      "google/gemini-3-flash-preview"
    ],
    "messages": [{ "role": "user", "content": "Hello" }],
    "provider": {
      "sort": {
        "by": "price",
        "partition": "none"
      },
      "preferred_min_throughput": {
        "p90": 50
      }
    }
  }'
```

В этом примере VEGA найдёт самую дешёвую модель и провайдера среди всех трёх моделей, у которых пропускная способность ≥ 50 токенов/сек на уровне p90 (т.е. 90 % запросов достигают этой скорости). Модели и провайдеры ниже этого порога всё равно останутся доступными как резервные варианты, если все предпочтительные варианты не сработают.

Вы также можете использовать `preferred_max_latency`, чтобы задать максимальную приемлемую задержку:

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  models: [
    'anthropic/claude-sonnet-4.5',
    'openai/gpt-5-mini',
  ],
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    sort: {
      by: 'price',
      partition: 'none',
    },
    preferredMaxLatency: {
      p90: 3, // Предпочитать провайдеров с <3 сек задержки для 90 % запросов за последние 5 минут
    },
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    models: [
      'anthropic/claude-sonnet-4.5',
      'openai/gpt-5-mini',
    ],
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      sort: {
        by: 'price',
        partition: 'none',
      },
      preferred_max_latency: {
        p90: 3, // Предпочитать провайдеров с <3 сек задержки для 90 % запросов за последние 5 минут
      },
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'models': [
    'anthropic/claude-sonnet-4.5',
    'openai/gpt-5-mini',
  ],
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'sort': {
      'by': 'price',
      'partition': 'none',
    },
    'preferred_max_latency': {
      'p90': 3, # Предпочитать провайдеров с <3 сек задержки для 90 % запросов за последние 5 минут
    },
  },
})
```

```bash title="cURL"
curl https://api.vega.chat/api/v1/chat/completions \
  -H "Authorization: Bearer <VEGA_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "models": [
      "anthropic/claude-sonnet-4.5",
      "openai/gpt-5-mini"
    ],
    "messages": [{ "role": "user", "content": "Hello" }],
    "provider": {
      "sort": {
        "by": "price",
        "partition": "none"
      },
      "preferred_max_latency": {
        "p90": 3
      }
    }
  }'
```

### Пример: использование нескольких процентильных порогов

Вы можете указать несколько процентильных порогов, чтобы задать как типичные, так и худшие требования к производительности. Все указанные пороги должны быть выполнены, чтобы модель и провайдер попали в предпочтительную группу.

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  model: 'deepseek/deepseek-v3.2',
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    preferredMaxLatency: {
      p50: 1, // <1 сек задержки для 50 % запросов за последние 5 минут
      p90: 3, // <3 сек задержки для 90 % запросов
      p99: 5, // <5 сек задержки для 99 % запросов
    },
    preferredMinThroughput: {
      p50: 100, // >100 токенов/сек для 50 % запросов
      p90: 50,  // >50 токенов/сек для 90 % запросов
    },
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'deepseek/deepseek-v3.2',
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      preferred_max_latency: {
        p50: 1, // <1 сек задержки для 50 % запросов за последние 5 минут
        p90: 3, // <3 сек задержки для 90 % запросов
        p99: 5, // <5 сек задержки для 99 % запросов
      },
      preferred_min_throughput: {
        p50: 100, // >100 токенов/сек для 50 % запросов
        p90: 50,  // >50 токенов/сек для 90 % запросов
      },
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'model': 'deepseek/deepseek-v3.2',
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'preferred_max_latency': {
      'p50': 1, # <1 сек задержки для 50 % запросов за последние 5 минут
      'p90': 3, # <3 сек задержки для 90 % запросов
      'p99': 5, # <5 сек задержки для 99 % запросов
    },
    'preferred_min_throughput': {
      'p50': 100, # >100 токенов/сек для 50 % запросов
      'p90': 50,  # >50 токенов/сек для 90 % запросов
    },
  },
})
```

```bash title="cURL"
curl https://api.vega.chat/api/v1/chat/completions \
  -H "Authorization: Bearer <VEGA_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek/deepseek-v3.2",
    "messages": [{ "role": "user", "content": "Hello" }],
    "provider": {
      "preferred_max_latency": {
        "p50": 1,
        "p90": 3,
        "p99": 5
      },
      "preferred_min_throughput": {
        "p50": 100,
        "p90": 50
      }
    }
  }'
```

### Сценарий 3: Максимизировать использование BYOK между моделями

Если вы используете [Bring Your Own Key (BYOK)](/docs/guides/overview/auth/byok) и хотите максимально использовать свои собственные API‑ключи, `partition: "none"` может помочь. Когда у основной модели нет доступного BYOK‑провайдера, VEGA может переключиться на fallback‑модель, поддерживающую BYOK.

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  models: [
    'anthropic/claude-sonnet-4.5',
    'openai/gpt-5-mini',
    'google/gemini-3-flash-preview',
  ],
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    sort: {
      by: 'price',
      partition: 'none',
    },
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    models: [
      'anthropic/claude-sonnet-4.5',
      'openai/gpt-5-mini',
      'google/gemini-3-flash-preview',
    ],
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      sort: {
        by: 'price',
        partition: 'none',
      },
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'models': [
    'anthropic/claude-sonnet-4.5',
    'openai/gpt-5-mini',
    'google/gemini-3-flash-preview',
  ],
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'sort': {
      'by': 'price',
      'partition': 'none',
    },
  },
})
```

```bash title="cURL"
curl https://api.vega.chat/api/v1/chat/completions \
  -H "Authorization: Bearer <VEGA_API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{
    "models": [
      "anthropic/claude-sonnet-4.5",
      "openai/gpt-5-mini",
      "google/gemini-3-flash-preview"
    ],
    "messages": [{ "role": "user", "content": "Hello" }],
    "provider": {
      "sort": {
        "by": "price",
        "partition": "none"
      }
    }
  }'
```

В этом примере, если у вас настроен BYOK‑ключ для OpenAI, но не для Anthropic, VEGA может направить запрос к эндпоинту GPT‑4o, используя ваш собственный ключ, даже если Claude указан первым. Без `partition: "none"` роутер всегда будет сначала пробовать конечные точки Claude, а уже потом переключаться на GPT‑4o.

BYOK‑конечные точки автоматически получают приоритет, когда у вас настроены API‑ключи для провайдера. Настройка `partition: "none"` позволяет этому приоритету работать через границы моделей.

## Указание порядка конкретных провайдеров

Вы можете задать провайдеры, которым VEGA будет отдавать приоритет, используя поле `order`.

| Поле   | Тип      | По умолчанию | Описание                                                            |
| ------ | -------- | ------------- | -------------------------------------------------------------------- |
| `order`| string\[]| -             | Список slug‑ов провайдеров в порядке попытки (например, `["anthropic", "openai"]`). |

Роутер будет отдавать приоритет провайдерам из этого списка и в указанном порядке для выбранной модели. Если поле не задано, роутер будет [балансировать нагрузку](#price-based-load-balancing-default-strategy) между топ‑провайдерами, чтобы максимизировать время безотказной работы.

Вы можете воспользоваться кнопкой копирования рядом с именами провайдеров на страницах моделей, чтобы получить точный slug, включая варианты вроде “/turbo”. См. раздел [Targeting Specific Provider Endpoints](#targeting-specific-provider-endpoints) для деталей.

VEGA будет пробовать их по одному и переходить к другим провайдерам, если текущий недоступен. Если вы не хотите, чтобы использовались другие провайдеры, также следует [отключить fallback‑механизм](#disabling-fallbacks).

### Пример: указание провайдеров с fallback‑механизмом

В этом примере пропускаем OpenAI (у него нет Mixtral), пробуем Together, а затем переходим к обычному списку провайдеров VEGA:

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  model: 'mistralai/mixtral-8x7b-instruct',
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    order: ['openai', 'together'],
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'HTTP-Referer': '<YOUR_SITE_URL>',
    'X-OpenRouter-Title': '<YOUR_SITE_NAME>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'mistralai/mixtral-8x7b-instruct',
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      order: ['openai', 'together'],
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'HTTP-Referer': '<YOUR_SITE_URL>',
  'X-OpenRouter-Title': '<YOUR_SITE_NAME>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'model': 'mistralai/mixtral-8x7b-instruct',
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'order': ['openai', 'together'],
  },
})
```

### Пример: указание провайдеров с отключёнными fallback‑механизмом

Здесь `allow_fallbacks` установлен в `false`, поэтому после неудачи Together запрос завершится ошибкой.

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  model: 'mistralai/mixtral-8x7b-instruct',
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    order: ['openai', 'together'],
    allowFallbacks: false,
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'HTTP-Referer': '<YOUR_SITE_URL>',
    'X-OpenRouter-Title': '<YOUR_SITE_NAME>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'mistralai/mixtral-8x7b-instruct',
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      order: ['openai', 'together'],
      allow_fallbacks: false,
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'HTTP-Referer': '<YOUR_SITE_URL>',
  'X-OpenRouter-Title': '<YOUR_SITE_NAME>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'model': 'mistralai/mixtral-8x7b-instruct',
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'order': ['openai', 'together'],
    'allow_fallbacks': False,
  },
})
```

## Выбор конкретных конечных точек провайдера

Каждый провайдер в VEGA может предлагать несколько конечных точек для одной модели, например, обычную и специализированную “turbo”, либо региональные варианты вроде `google-vertex/us-east5`. Чтобы выбрать конкретную конечную точку, используйте кнопку копирования рядом с именем провайдера на странице модели и вставьте полученный slug в запрос.

### Сопоставление базового slug

Если вы используете базовый slug провайдера (например, `"google-vertex"`) в любом поле маршрутизации провайдера (`order`, `only` или `ignore`), он будет **соответствовать всем** конечным точкам этого провайдера, включая любые варианты и регионы. Например, `"google-vertex"` соответствует `google-vertex`, `google-vertex/us-east5`, `google-vertex/us-central1` и т.д.

Чтобы выбрать **конкретный** вариант или регион, используйте полный slug с суффиксом (например, `"google-vertex/us-east5"` или `"deepinfra/turbo"`).

| Slug в запросе            | Что соответствует                                            |
| -------------------------- | ----------------------------------------------------------- |
| `"google-vertex"`          | Все конечные точки Google Vertex (во всех регионах)        |
| `"google-vertex/us-east5"`| Только конечная точка в регионе `us-east5`                 |
| `"deepinfra"`              | Все конечные точки DeepInfra (по умолчанию + turbo)        |
| `"deepinfra/turbo"`        | Только turbo‑конечная точка DeepInfra                       |

### Пример: выбор конкретного варианта конечной точки

DeepInfra предлагает DeepSeek R1 через несколько конечных точек:

* Обычная конечная точка с slug `deepinfra`  
* Turbo‑конечная точка с slug `deepinfra/turbo`

Скопировав точный slug и указав его в массиве `order`, вы гарантируете, что запрос будет направлен именно к нужному варианту:

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  model: 'deepseek/deepseek-r1',
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    order: ['deepinfra/turbo'],
    allowFallbacks: false,
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'HTTP-Referer': '<YOUR_SITE_URL>',
    'X-OpenRouter-Title': '<YOUR_SITE_NAME>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'deepseek/deepseek-r1',
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      order: ['deepinfra/turbo'],
      allow_fallbacks: false,
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'HTTP-Referer': '<YOUR_SITE_URL>',
  'X-OpenRouter-Title': '<YOUR_SITE_NAME>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'model': 'deepseek/deepseek-r1',
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'order': ['deepinfra/turbo'],
    'allow_fallbacks': False,
  },
})
```

Этот подход особенно полезен, когда вы хотите постоянно использовать конкретный вариант модели у определённого провайдера.

Чтобы маршрутизировать запрос **ко всем** конечным точкам провайдера (во всех регионах и вариантах), просто используйте базовый slug без суффикса, например `"google-vertex"`.

## Требование поддержки всех параметров провайдерами

Вы можете ограничить запрос только провайдерами, которые поддерживают **все** параметры вашего запроса, используя поле `require_parameters`.

| Поле                | Тип    | По умолчанию | Описание                                                                 |
| ------------------- | ------ | ------------- | ------------------------------------------------------------------------ |
| `require_parameters`| boolean| `false`       | Использовать только провайдеры, поддерживающие все параметры запроса.   |

При стратегии маршрутизации по умолчанию провайдеры, которые не поддерживают некоторые из [параметров LLM](/docs/api-reference/parameters), всё равно могут получить запрос, но игнорируют неизвестные параметры. Если установить `require_parameters` в `true`, запрос даже не будет направлен к таким провайдерам.

### Пример: исключить провайдеров, не поддерживающих формат JSON

Например, чтобы использовать только провайдеров, поддерживающих формат JSON:

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    requireParameters: true,
  },
  responseFormat: { type: 'json_object' },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'HTTP-Referer': '<YOUR_SITE_URL>',
    'X-OpenRouter-Title': '<YOUR_SITE_NAME>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      require_parameters: true,
    },
    response_format: { type: 'json_object' },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'HTTP-Referer': '<YOUR_SITE_URL>',
  'X-OpenRouter-Title': '<YOUR_SITE_NAME>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'require_parameters': True,
  },
  'response_format': { 'type': 'json_object' },
})
```

## Требование соответствия провайдеров политике данных

Вы можете ограничить запрос только провайдерами, которые соответствуют вашей политике данных, используя поле `data_collection`.

| Поле             | Тип                | По умолчанию | Описание                                            |
| ---------------- | ------------------ | ------------ | --------------------------------------------------- |
| `data_collection`| "allow" \| "deny" | "allow"      | Управлять использованием провайдеров, которые могут сохранять данные. |

* `allow` (по умолчанию): разрешать провайдеры, которые сохраняют пользовательские данные и могут их использовать для обучения.  
* `deny`: использовать только провайдеры, которые **не** собирают пользовательские данные.

Некоторые провайдеры могут логировать подсказки, поэтому на страницах моделей мы отображаем тег **Data Policy**. Это не является окончательным источником информации о сторонних политиках, а отражает наше лучшее знание.

Эта настройка также доступна в разделе [ваши настройки конфиденциальности](/settings/privacy). Вы можете отключить сторонних провайдеров, которые сохраняют вводы для обучения.

### Пример: исключить провайдеров, не соответствующих политике данных

Чтобы исключить провайдеров, не соответствующих вашей политике, установите `data_collection` в `deny`:

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    dataCollection: 'deny', // или "allow"
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'HTTP-Referer': '<YOUR_SITE_URL>',
    'X-OpenRouter-Title': '<YOUR_SITE_NAME>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      data_collection: 'deny', // или "allow"
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'HTTP-Referer': '<YOUR_SITE_URL>',
  'X-OpenRouter-Title': '<YOUR_SITE_NAME>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'data_collection': 'deny', # или "allow"
  },
})
```

## Принудительное соблюдение Zero Data Retention (ZDR)

Вы можете принудительно включить Zero Data Retention (ZDR) для отдельного запроса, используя параметр `zdr`, гарантируя, что запрос будет направлен только к конечным точкам, не сохраняющим подсказки.

| Поле | Тип    | По умолчанию | Описание |
| ---- | ------ | ------------ | -------- |
| `zdr`| boolean| -            | Ограничить маршрутизацию только к ZDR‑конечным точкам. |

Если `zdr` установлен в `true`, запрос будет направлен только к конечным точкам с политикой Zero Data Retention. Если `zdr` `false` или не указан, параметр не влияет на маршрутизацию.

ZDR также можно включить для групп моделей (Anthropic, OpenAI, Google и др.) в ваших [настройках конфиденциальности](/settings/privacy) или через [guardrails](/docs/guides/features/guardrails). Параметр `zdr` уровня запроса работает как **ИЛИ** с вашими глобальными настройками и guardrail‑настройками — если любой из них включён, применяется ZDR. Параметр уровня запроса может только **включать** ZDR, но не переопределять глобальные настройки.

### Пример: принудительное включение ZDR для конкретного запроса

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  model: 'gpt-4',
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    zdr: true,
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'HTTP-Referer': '<YOUR_SITE_URL>',
    'X-OpenRouter-Title': '<YOUR_SITE_NAME>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'gpt-4',
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      zdr: true,
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'HTTP-Referer': '<YOUR_SITE_URL>',
  'X-OpenRouter-Title': '<YOUR_SITE_NAME>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'model': 'gpt-4',
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'zdr': True,
  },
})
```

Это полезно для клиентов, которые не хотят глобально включать ZDR, но нуждаются в гарантии, что отдельные запросы используют только ZDR‑конечные точки.

## Принудительное соблюдение возможности дистилляции текста

Вы можете включить фильтрацию дистилляции текста на уровне запроса, используя параметр `enforce_distillable_text`, гарантируя, что запрос будет направлен только к моделям, где автор разрешил дистилляцию текста.

| Поле                      | Тип    | По умолчанию | Описание |
| -------------------------- | ------ | ------------ | -------- |
| `enforce_distillable_text` | boolean| -            | Ограничить маршрутизацию только к моделям, позволяющим дистилляцию текста. |

Если `enforce_distillable_text` установлен в `true`, запрос будет направлен только к моделям, где автор явно включил дистилляцию текста. Если `false` или не указано, параметр не влияет на маршрутизацию.

Это полезно для приложений, которым необходимо использовать только модели, допускающие дистилляцию текста для обучения (например, при построении наборов данных для дообучения).

### Пример: принудительное включение дистилляции текста для конкретного запроса

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  model: 'meta-llama/llama-3.3-70b-instruct',
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    enforceDistillableText: true,
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'meta-llama/llama-3.3-70b-instruct',
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      enforce_distillable_text: true,
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'model': 'meta-llama/llama-3.3-70b-instruct',
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'enforce_distillable_text': True,
  },
})
```

## Отключение fallback‑механизма

Чтобы гарантировать, что ваш запрос будет обслужен только самым дешёвым провайдером, вы можете отключить fallback‑механизм.

Это комбинируется с полем `order` из раздела [Ordering Specific Providers](#ordering-specific-providers), чтобы ограничить список провайдеров, которые VEGA будет рассматривать.

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    allowFallbacks: false,
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      allow_fallbacks: false,
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'allow_fallbacks': False,
  },
})
```

## Разрешить только конкретные провайдеры

Вы можете разрешить только определённые провайдеры для запроса, задав поле `only` в объекте `provider`.

| Поле  | Тип      | По умолчанию | Описание                                   |
| ----- | -------- | ------------ | ------------------------------------------ |
| `only`| string\[]| -            | Список slug‑ов провайдеров, разрешённых для этого запроса. |

Разрешение только некоторых провайдеров может существенно сократить количество fallback‑вариантов и ограничить возможность восстановления запроса.

Вы можете задать разрешённые провайдеры для всех запросов аккаунта в [настройках конфиденциальности](/settings/privacy). Эта конфигурация применяется ко всем API‑запросам и сообщениям в чат‑комнатах.

Обратите внимание, что при указании провайдеров для конкретного запроса список разрешённых провайдеров объединяется с вашими глобальными разрешёнными провайдерами.

### Пример: разрешить Azure для запроса к GPT‑4 Omni

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  model: 'openai/gpt-5-mini',
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    only: ['azure'],
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'openai/gpt-5-mini',
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      only: ['azure'],
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'model': 'openai/gpt-5-mini',
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'only': ['azure'],
  },
})
```

## Игнорирование провайдеров

Вы можете игнорировать провайдеров для запроса, задав поле `ignore` в объекте `provider`.

| Поле    | Тип      | По умолчанию | Описание                                 |
| ------- | -------- | ------------ | ---------------------------------------- |
| `ignore`| string\[]| -            | Список slug‑ов провайдеров, которые следует пропустить для этого запроса. |

Игнорирование нескольких провайдеров может существенно сократить количество fallback‑вариантов и ограничить возможность восстановления запроса.

Вы можете игнорировать провайдеры для всех запросов аккаунта в [настройках конфиденциальности](/settings/privacy). Эта конфигурация применяется ко всем API‑запросам и сообщениям в чат‑комнатах.

Обратите внимание, что при игнорировании провайдеров для конкретного запроса список игнорируемых провайдеров объединяется с вашими глобальными игнорируемыми провайдерами.

### Пример: игнорировать DeepInfra для запроса к Llama 3.3 70b

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  model: 'meta-llama/llama-3.3-70b-instruct',
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    ignore: ['deepinfra'],
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'meta-llama/llama-3.3-70b-instruct',
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      ignore: ['deepinfra'],
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'model': 'meta-llama/llama-3.3-70b-instruct',
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'ignore': ['deepinfra'],
  },
})
```

## Квантизация

Квантизация уменьшает размер модели и требования к вычислениям, стараясь сохранить производительность. Большинство современных LLM используют FP16 или BF16 для обучения и инференса, сокращая потребление памяти вдвое по сравнению с FP32. Некоторые оптимизации используют FP8 или квантизацию (например, INT8, INT4) для дальнейшего уменьшения размера.

| Поле           | Тип      | По умолчанию | Описание |
| -------------- | -------- | ------------- | -------- |
| `quantizations`| string\[]| -             | Список уровней квантизации для фильтрации (например, `["int4", "int8"]`). [Подробнее](#quantization) |

Квантизированные модели могут показывать ухудшенную производительность для некоторых подсказок, в зависимости от выбранного метода.

Провайдеры могут поддерживать различные уровни квантизации для моделей с открытыми весами.

### Уровни квантизации

По умолчанию запросы балансируются между всеми доступными провайдерами, упорядоченными по цене. Чтобы отфильтровать провайдеров по уровню квантизации, укажите поле `quantizations` в параметре `provider` со следующими значениями:

* `int4`: целое (4 бита)  
* `int8`: целое (8 бит)  
* `fp4`: плавающая точка (4 бита)  
* `fp6`: плавающая точка (6 бит)  
* `fp8`: плавающая точка (8 бит)  
* `fp16`: плавающая точка (16 бит)  
* `bf16`: brain‑floating point (16 бит)  
* `fp32`: плавающая точка (32 бита)  
* `unknown`: неизвестно  

### Пример: запрос FP8‑квантизации

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send({
  model: 'meta-llama/llama-3.1-8b-instruct',
  messages: [{ role: 'user', content: 'Hello' }],
  provider: {
    quantizations: ['fp8'],
  },
  stream: false,
});
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'meta-llama/llama-3.1-8b-instruct',
    messages: [{ role: 'user', content: 'Hello' }],
    provider: {
      quantizations: ['fp8'],
    },
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'Content-Type': 'application/json',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'model': 'meta-llama/llama-3.1-8b-instruct',
  'messages': [{ 'role': 'user', 'content': 'Hello' }],
  'provider': {
    'quantizations': ['fp8'],
  },
})
```

### Максимальная цена

Чтобы отфильтровать провайдеров по цене, задайте поле `max_price` в параметре `provider` как JSON‑объект, указывающий максимальную цену, которую вы готовы принять.

Например, значение `{"prompt": 1, "completion": 2}` будет направлять запрос к любому провайдеру, у которого цена за токен подсказки ≤ 100 ₽/млн и цена за токен завершения ≤ $2/млн.

Некоторые провайдеры поддерживают ценообразование per‑request, в этом случае можно использовать атрибут `request` внутри `max_price`. Также доступен атрибут `image`, указывающий максимальную цену за изображение.

На практике это поле часто комбинируется с `sort`, чтобы, например, «использовать провайдера с наивысшей пропускной способностью, пока его стоимость не превышает $x/млн токенов».

## Специфичные заголовки провайдеров

Некоторые провайдеры поддерживают бета‑фичи, которые можно включать через специальные заголовки. VEGA позволяет передавать такие бета‑заголовки при выполнении запросов.

### Бета‑фичи Anthropic

При работе с моделями Anthropic (Claude) вы можете запросить конкретные бета‑фичи, включив заголовок `x-anthropic-beta` в запрос. VEGA пробрасывает поддерживаемые бета‑фичи к Anthropic.

#### Поддерживаемые бета‑фичи

| Фича                     | Значение заголовка                     | Описание |
| ------------------------ | -------------------------------------- | -------- |
| Fine‑Grained Tool Streaming | `fine-grained-tool-streaming-2025-05-14` | Позволяет более детально стримить события во время вызовов инструментов, предоставляя обновления в реальном времени по мере генерации аргументов. |
| Interleaved Thinking     | `interleaved-thinking-2025-05-14`      | Позволяет чередовать размышления Claude с обычным выводом, вместо того чтобы они шли одним блоком. |
| Structured Outputs       | `structured-outputs-2025-11-13`        | Включает строгий режим использования инструментов для поддерживаемых моделей Claude, проверяя параметры инструмента согласно вашей схеме. |

VEGA автоматически управляет некоторыми бета‑фичами Anthropic:

* **Кеширование подсказок и расширенный контекст** включаются автоматически в зависимости от возможностей модели.  
* **Structured outputs для формата ответа JSON schema** (`response_format.type: "json_schema"`) — заголовок применяется автоматически.

Для **строгого использования инструментов** (`strict: true` в `tools`) необходимо явно передать заголовок `structured-outputs-2025-11-13`. Без него VEGA удалит поле `strict` и выполнит запрос обычным способом.

#### Пример: включение Fine‑Grained Tool Streaming

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send(
  {
    model: 'anthropic/claude-sonnet-4.5',
    messages: [{ role: 'user', content: 'What is the weather in Tokyo?' }],
    tools: [
      {
        type: 'function',
        function: {
          name: 'get_weather',
          description: 'Get the current weather for a location',
          parameters: {
            type: 'object',
            properties: {
              location: { type: 'string' },
            },
            required: ['location'],
          },
        },
      },
    ],
    stream: true,
  },
  {
    headers: {
      'x-anthropic-beta': 'fine-grained-tool-streaming-2025-05-14',
    },
  },
);
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'Content-Type': 'application/json',
    'x-anthropic-beta': 'fine-grained-tool-streaming-2025-05-14',
  },
  body: JSON.stringify({
    model: 'anthropic/claude-sonnet-4.5',
    messages: [{ role: 'user', content: 'What is the weather in Tokyo?' }],
    tools: [
      {
        type: 'function',
        function: {
          name: 'get_weather',
          description: 'Get the current weather for a location',
          parameters: {
            type: 'object',
            properties: {
              location: { type: 'string' },
            },
            required: ['location'],
          },
        },
      },
    ],
    stream: true,
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'Content-Type': 'application/json',
  'x-anthropic-beta': 'fine-grained-tool-streaming-2025-05-14',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'model': 'anthropic/claude-sonnet-4.5',
  'messages': [{ 'role': 'user', 'content': 'What is the weather in Tokyo?' }],
  'tools': [
    {
      'type': 'function',
      'function': {
        'name': 'get_weather',
        'description': 'Get the current weather for a location',
        'parameters': {
          'type': 'object',
          'properties': {
            'location': { 'type': 'string' },
          },
          'required': ['location'],
        },
      },
    },
  ],
  'stream': True,
})
```

#### Пример: включение Interleaved Thinking

```typescript title="TypeScript SDK"
import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
  apiKey: '<VEGA_API_KEY>',
});

const completion = await client.chat.send(
  {
    model: 'anthropic/claude-sonnet-4.5',
    messages: [{ role: 'user', content: 'Solve this step by step: What is 15% of 240?' }],
    stream: true,
  },
  {
    headers: {
      'x-anthropic-beta': 'interleaved-thinking-2025-05-14',
    },
  },
);
```

```typescript title="TypeScript (fetch)"
fetch('https://api.vega.chat/api/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <VEGA_API_KEY>',
    'Content-Type': 'application/json',
    'x-anthropic-beta': 'interleaved-thinking-2025-05-14',
  },
  body: JSON.stringify({
    model: 'anthropic/claude-sonnet-4.5',
    messages: [{ role: 'user', content: 'Solve this step by step: What is 15% of 240?' }],
    stream: true,
  }),
});
```

```python title="Python"
import requests

headers = {
  'Authorization': 'Bearer <VEGA_API_KEY>',
  'Content-Type': 'application/json',
  'x-anthropic-beta': 'interleaved-thinking-2025-05-14',
}

response = requests.post('https://api.vega.chat/api/v1/chat/completions', headers=headers, json={
  'model': 'anthropic/claude-sonnet-4.5',
  'messages': [{ 'role': 'user', 'content': 'Solve this step by step: What is 15% of 240?' }],
  'stream': True,
})
```

#### Комбинирование нескольких бета‑фич

Вы можете включить несколько бета‑фич, разделив их запятыми:

```bash
x-anthropic-beta: fine-grained-tool-streaming-2025-05-14,interleaved-thinking-2025-05-14
```

Бета‑фичи находятся в экспериментальном статусе и могут изменяться или быть удалены Anthropic. Смотрите актуальную информацию в [документации Anthropic](https://docs.anthropic.com/en/api/beta-features).

## Условия использования

Вы можете ознакомиться с условиями использования каждого провайдера ниже. Вы не имеете права нарушать условия использования или политики сторонних провайдеров, которые предоставляют модели в VEGA.