From 89cd8bc49f2620144bf7af4168fe599362a6b064 Mon Sep 17 00:00:00 2001 From: jope35 <15650945+jope35@users.noreply.github.com> Date: Mon, 14 Sep 2026 10:59:51 +0200 Subject: [PATCH 1/2] feat(melious): add Melious provider with the GLM, DeepSeek and Kimi families Melious AI GmbH is a European OpenAI-compatible relay of open-weight models. This is the first of two PRs: it adds the provider and the 15 models whose lab metadata already exists under models/, so it touches providers/melious/ only -- no models/, labs/ or render.tsx changes. The remaining catalog follows once this lands. Every entry uses base_model and is override-only. Data: GET https://api.melious.ai/v1/models?include_meta=true, cross-checked against the per-model hub pages. Prices are the default `balanced` route (a bare chat model ID resolves to `balanced`), converted at 1.1592 USD/EUR (ECB euro reference rate, 2026-09-11). Each file records its EUR figures, the rate and the date so the arithmetic is checkable from the diff. Reasoning: reasoning_effort is the only control this host exposes -- no lab-native thinking field, no reasoning budget, so no toggle or budget_tokens. The host accepts any effort string without a 4xx, so the authored values are the documented ladder (low|medium|high) plus none, which was measured to be a real off state: it returns usage.reasoning_tokens = 0 and no reasoning_content on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. Because none is reachable this is an effort list containing none, not a toggle. Reasoning text is returned in message.reasoning_content. Co-Authored-By: Claude Opus 5 (1M context) --- providers/melious/logo.svg | 3 ++ .../melious/models/deepseek-r1-0528.toml | 35 ++++++++++++++++ providers/melious/models/deepseek-v3.2.toml | 35 ++++++++++++++++ .../models/deepseek-v4-flash-0731.toml | 30 +++++++++++++ .../melious/models/deepseek-v4-pro-0813.toml | 30 +++++++++++++ providers/melious/models/deepseek-v4-pro.toml | 30 +++++++++++++ .../melious/models/deepseek-v4.1-flash.toml | 30 +++++++++++++ providers/melious/models/glm-5.1.toml | 36 ++++++++++++++++ providers/melious/models/glm-5.2.toml | 30 +++++++++++++ providers/melious/models/glm-5.3-flash.toml | 36 ++++++++++++++++ providers/melious/models/glm-5.3.toml | 30 +++++++++++++ providers/melious/models/glm-5.toml | 36 ++++++++++++++++ providers/melious/models/kimi-k2.5.toml | 42 +++++++++++++++++++ providers/melious/models/kimi-k2.6.toml | 38 +++++++++++++++++ providers/melious/models/kimi-k2.7-code.toml | 30 +++++++++++++ providers/melious/models/kimi-k3.toml | 36 ++++++++++++++++ providers/melious/provider.toml | 28 +++++++++++++ 17 files changed, 535 insertions(+) create mode 100644 providers/melious/logo.svg create mode 100644 providers/melious/models/deepseek-r1-0528.toml create mode 100644 providers/melious/models/deepseek-v3.2.toml create mode 100644 providers/melious/models/deepseek-v4-flash-0731.toml create mode 100644 providers/melious/models/deepseek-v4-pro-0813.toml create mode 100644 providers/melious/models/deepseek-v4-pro.toml create mode 100644 providers/melious/models/deepseek-v4.1-flash.toml create mode 100644 providers/melious/models/glm-5.1.toml create mode 100644 providers/melious/models/glm-5.2.toml create mode 100644 providers/melious/models/glm-5.3-flash.toml create mode 100644 providers/melious/models/glm-5.3.toml create mode 100644 providers/melious/models/glm-5.toml create mode 100644 providers/melious/models/kimi-k2.5.toml create mode 100644 providers/melious/models/kimi-k2.6.toml create mode 100644 providers/melious/models/kimi-k2.7-code.toml create mode 100644 providers/melious/models/kimi-k3.toml create mode 100644 providers/melious/provider.toml diff --git a/providers/melious/logo.svg b/providers/melious/logo.svg new file mode 100644 index 00000000000..a2ff326807a --- /dev/null +++ b/providers/melious/logo.svg @@ -0,0 +1,3 @@ + + + diff --git a/providers/melious/models/deepseek-r1-0528.toml b/providers/melious/models/deepseek-r1-0528.toml new file mode 100644 index 00000000000..9b71913f21d --- /dev/null +++ b/providers/melious/models/deepseek-r1-0528.toml @@ -0,0 +1,35 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 0.60 in / EUR 2.40 +# out / EUR 0.16 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/deepseek-r1-0528 (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. OpenRouter records no caller control for this model; that enum +# is not reachable through this API. The host accepts any effort string without a 4xx, +# so acceptance proves nothing; the values below are the documented ladder +# (low|medium|high) plus none, which was measured to be a real off state -- +# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. +# Because none is reachable, this is an effort list with none rather than a toggle. +# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour +# distinct from high, so they are not authored. Measured 2026-09-14 against +# api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +# limit.context: the catalog reports 164_000 for this deployment, not the lab's +# 128_000. +base_model = "deepseek/deepseek-r1" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 0.69552 +output = 2.78208 +cache_read = 0.185472 + +[limit] +context = 164_000 + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/models/deepseek-v3.2.toml b/providers/melious/models/deepseek-v3.2.toml new file mode 100644 index 00000000000..f59ad411ab4 --- /dev/null +++ b/providers/melious/models/deepseek-v3.2.toml @@ -0,0 +1,35 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 0.30 in / EUR 0.50 +# out / EUR 0.08 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/deepseek-v3.2 (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. OpenRouter exposes an on/off thinking toggle for this model; +# that enum is not reachable through this API. The host accepts any effort string +# without a 4xx, so acceptance proves nothing; the values below are the documented +# ladder (low|medium|high) plus none, which was measured to be a real off state -- +# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. +# Because none is reachable, this is an effort list with none rather than a toggle. +# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour +# distinct from high, so they are not authored. Measured 2026-09-14 against +# api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +# limit.context: the catalog reports 164_000 for this deployment, not the lab's +# 128_000. +base_model = "deepseek/deepseek-v3.2" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 0.34776 +output = 0.5796 +cache_read = 0.092736 + +[limit] +context = 164_000 + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/models/deepseek-v4-flash-0731.toml b/providers/melious/models/deepseek-v4-flash-0731.toml new file mode 100644 index 00000000000..95ada7ed642 --- /dev/null +++ b/providers/melious/models/deepseek-v4-flash-0731.toml @@ -0,0 +1,30 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 0.10 in / EUR 0.25 +# out / EUR 0.02 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/deepseek-v4-flash-0731 (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. OpenRouter exposes toggle + low|high|max for this model; that +# enum is not reachable through this API. The host accepts any effort string without a +# 4xx, so acceptance proves nothing; the values below are the documented ladder +# (low|medium|high) plus none, which was measured to be a real off state -- +# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. +# Because none is reachable, this is an effort list with none rather than a toggle. +# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour +# distinct from high, so they are not authored. Measured 2026-09-14 against +# api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +base_model = "deepseek/deepseek-v4-flash-0731" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 0.11592 +output = 0.2898 +cache_read = 0.023184 + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/models/deepseek-v4-pro-0813.toml b/providers/melious/models/deepseek-v4-pro-0813.toml new file mode 100644 index 00000000000..8093e0e5a43 --- /dev/null +++ b/providers/melious/models/deepseek-v4-pro-0813.toml @@ -0,0 +1,30 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 1.00 in / EUR 3.00 +# out / EUR 0.10 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/deepseek-v4-pro-0813 (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. OpenRouter exposes toggle + low|high|max for this model; that +# enum is not reachable through this API. The host accepts any effort string without a +# 4xx, so acceptance proves nothing; the values below are the documented ladder +# (low|medium|high) plus none, which was measured to be a real off state -- +# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. +# Because none is reachable, this is an effort list with none rather than a toggle. +# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour +# distinct from high, so they are not authored. Measured 2026-09-14 against +# api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +base_model = "deepseek/deepseek-v4-pro-0813" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 1.1592 +output = 3.4776 +cache_read = 0.11592 + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/models/deepseek-v4-pro.toml b/providers/melious/models/deepseek-v4-pro.toml new file mode 100644 index 00000000000..b1b192a8bf4 --- /dev/null +++ b/providers/melious/models/deepseek-v4-pro.toml @@ -0,0 +1,30 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 1.60 in / EUR 3.20 +# out / EUR 0.40 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/deepseek-v4-pro (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. deepseek first-party exposes toggle + high|max for this model; +# that enum is not reachable through this API. The host accepts any effort string +# without a 4xx, so acceptance proves nothing; the values below are the documented +# ladder (low|medium|high) plus none, which was measured to be a real off state -- +# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. +# Because none is reachable, this is an effort list with none rather than a toggle. +# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour +# distinct from high, so they are not authored. Measured 2026-09-14 against +# api.melious.ai/v1/chat/completions on this model. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +base_model = "deepseek/deepseek-v4-pro" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 1.85472 +output = 3.70944 +cache_read = 0.46368 + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/models/deepseek-v4.1-flash.toml b/providers/melious/models/deepseek-v4.1-flash.toml new file mode 100644 index 00000000000..d30b0cba793 --- /dev/null +++ b/providers/melious/models/deepseek-v4.1-flash.toml @@ -0,0 +1,30 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 0.20 in / EUR 1.00 +# out / EUR 0.01 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/deepseek-v4.1-flash (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. OpenRouter exposes toggle + low|high|max for this model; that +# enum is not reachable through this API. The host accepts any effort string without a +# 4xx, so acceptance proves nothing; the values below are the documented ladder +# (low|medium|high) plus none, which was measured to be a real off state -- +# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. +# Because none is reachable, this is an effort list with none rather than a toggle. +# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour +# distinct from high, so they are not authored. Measured 2026-09-14 against +# api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +base_model = "deepseek/deepseek-v4.1-flash" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 0.23184 +output = 1.1592 +cache_read = 0.011592 + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/models/glm-5.1.toml b/providers/melious/models/glm-5.1.toml new file mode 100644 index 00000000000..e9d0e168f8a --- /dev/null +++ b/providers/melious/models/glm-5.1.toml @@ -0,0 +1,36 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 1.30 in / EUR 4.00 +# out / EUR 0.32 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/glm-5.1 (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. zhipuai first-party exposes an on/off thinking toggle for this +# model; that enum is not reachable through this API. The host accepts any effort +# string without a 4xx, so acceptance proves nothing; the values below are the +# documented ladder (low|medium|high) plus none, which was measured to be a real off +# state -- reasoning_effort="none" returns usage.reasoning_tokens = 0 and no +# reasoning_content. Because none is reachable, this is an effort list with none +# rather than a toggle. minimal/xhigh/max are accepted but are undocumented and did +# not produce behaviour distinct from high, so they are not authored. Measured +# 2026-09-14 against api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro +# and kimi-k2.7-code. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +# limit.context: the catalog reports 203_000 for this deployment, not the lab's +# 200_000. +base_model = "zhipuai/glm-5.1" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 1.50696 +output = 4.6368 +cache_read = 0.370944 + +[limit] +context = 203_000 + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/models/glm-5.2.toml b/providers/melious/models/glm-5.2.toml new file mode 100644 index 00000000000..9089a429ce8 --- /dev/null +++ b/providers/melious/models/glm-5.2.toml @@ -0,0 +1,30 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 1.00 in / EUR 4.00 +# out / EUR 0.25 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/glm-5.2 (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. zhipuai first-party exposes high|max for this model; that enum +# is not reachable through this API. The host accepts any effort string without a 4xx, +# so acceptance proves nothing; the values below are the documented ladder +# (low|medium|high) plus none, which was measured to be a real off state -- +# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. +# Because none is reachable, this is an effort list with none rather than a toggle. +# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour +# distinct from high, so they are not authored. Measured 2026-09-14 against +# api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +base_model = "zhipuai/glm-5.2" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 1.1592 +output = 4.6368 +cache_read = 0.2898 + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/models/glm-5.3-flash.toml b/providers/melious/models/glm-5.3-flash.toml new file mode 100644 index 00000000000..033361ee652 --- /dev/null +++ b/providers/melious/models/glm-5.3-flash.toml @@ -0,0 +1,36 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 0.10 in / EUR 0.40 +# out / EUR 0.02 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/glm-5.3-flash (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. zhipuai first-party and most relay peers expose low|high|max for +# this model; that enum is not reachable through this API. The host accepts any effort +# string without a 4xx, so acceptance proves nothing; the values below are the +# documented ladder (low|medium|high) plus none, which was measured to be a real off +# state -- reasoning_effort="none" returns usage.reasoning_tokens = 0 and no +# reasoning_content. Because none is reachable, this is an effort list with none +# rather than a toggle. minimal/xhigh/max are accepted but are undocumented and did +# not produce behaviour distinct from high, so they are not authored. Measured +# 2026-09-14 against api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro +# and kimi-k2.7-code. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +# modalities.input: this host routes ["text", "image", "video"], narrower than the +# lab's ["text", "image", "video", "pdf"]. +base_model = "zhipuai/glm-5.3-flash" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 0.11592 +output = 0.46368 +cache_read = 0.023184 + +[modalities] +input = ["text", "image", "video"] + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/models/glm-5.3.toml b/providers/melious/models/glm-5.3.toml new file mode 100644 index 00000000000..eb53ed2d08a --- /dev/null +++ b/providers/melious/models/glm-5.3.toml @@ -0,0 +1,30 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 1.00 in / EUR 3.00 +# out / EUR 0.20 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/glm-5.3 (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. zhipuai first-party and most relay peers expose low|high|max for +# this model; that enum is not reachable through this API. The host accepts any effort +# string without a 4xx, so acceptance proves nothing; the values below are the +# documented ladder (low|medium|high) plus none, which was measured to be a real off +# state -- reasoning_effort="none" returns usage.reasoning_tokens = 0 and no +# reasoning_content. Because none is reachable, this is an effort list with none +# rather than a toggle. minimal/xhigh/max are accepted but are undocumented and did +# not produce behaviour distinct from high, so they are not authored. Measured +# 2026-09-14 against api.melious.ai/v1/chat/completions on this model. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +base_model = "zhipuai/glm-5.3" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 1.1592 +output = 3.4776 +cache_read = 0.23184 + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/models/glm-5.toml b/providers/melious/models/glm-5.toml new file mode 100644 index 00000000000..d9218721567 --- /dev/null +++ b/providers/melious/models/glm-5.toml @@ -0,0 +1,36 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 0.95 in / EUR 2.90 +# out / EUR 0.23 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/glm-5 (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. zhipuai first-party exposes an on/off thinking toggle for this +# model; that enum is not reachable through this API. The host accepts any effort +# string without a 4xx, so acceptance proves nothing; the values below are the +# documented ladder (low|medium|high) plus none, which was measured to be a real off +# state -- reasoning_effort="none" returns usage.reasoning_tokens = 0 and no +# reasoning_content. Because none is reachable, this is an effort list with none +# rather than a toggle. minimal/xhigh/max are accepted but are undocumented and did +# not produce behaviour distinct from high, so they are not authored. Measured +# 2026-09-14 against api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro +# and kimi-k2.7-code. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +# limit.context: the catalog reports 203_000 for this deployment, not the lab's +# 204_800. +base_model = "zhipuai/glm-5" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 1.10124 +output = 3.36168 +cache_read = 0.266616 + +[limit] +context = 203_000 + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/models/kimi-k2.5.toml b/providers/melious/models/kimi-k2.5.toml new file mode 100644 index 00000000000..7aa04e7f2c9 --- /dev/null +++ b/providers/melious/models/kimi-k2.5.toml @@ -0,0 +1,42 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 0.50 in / EUR 2.55 +# out / EUR 0.12 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/kimi-k2.5 (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. OpenRouter exposes an on/off thinking toggle for this model; +# that enum is not reachable through this API. The host accepts any effort string +# without a 4xx, so acceptance proves nothing; the values below are the documented +# ladder (low|medium|high) plus none, which was measured to be a real off state -- +# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. +# Because none is reachable, this is an effort list with none rather than a toggle. +# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour +# distinct from high, so they are not authored. Measured 2026-09-14 against +# api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +# limit.context: the catalog reports 262_000 for this deployment, not the lab's +# 262_144. limit.output: max_output_tokens is null for this model, so output is capped +# at the served context rather than inheriting the lab's larger 262_144. +# modalities.input: this host routes ["text", "image"], narrower than the lab's +# ["text", "image", "video"]. +base_model = "moonshotai/kimi-k2.5" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 0.5796 +output = 2.95596 +cache_read = 0.139104 + +[limit] +context = 262_000 +output = 262_000 + +[modalities] +input = ["text", "image"] + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/models/kimi-k2.6.toml b/providers/melious/models/kimi-k2.6.toml new file mode 100644 index 00000000000..effdbe69be3 --- /dev/null +++ b/providers/melious/models/kimi-k2.6.toml @@ -0,0 +1,38 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 0.70 in / EUR 3.50 +# out / EUR 0.23 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/kimi-k2.6 (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. moonshotai first-party exposes an on/off thinking toggle for +# this model; that enum is not reachable through this API. The host accepts any effort +# string without a 4xx, so acceptance proves nothing; the values below are the +# documented ladder (low|medium|high) plus none, which was measured to be a real off +# state -- reasoning_effort="none" returns usage.reasoning_tokens = 0 and no +# reasoning_content. Because none is reachable, this is an effort list with none +# rather than a toggle. minimal/xhigh/max are accepted but are undocumented and did +# not produce behaviour distinct from high, so they are not authored. Measured +# 2026-09-14 against api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro +# and kimi-k2.7-code. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +# limit.context: the catalog reports 256_000 for this deployment, not the lab's +# 262_144. limit.output: max_output_tokens is null for this model, so output is capped +# at the served context rather than inheriting the lab's larger 262_144. +base_model = "moonshotai/kimi-k2.6" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 0.81144 +output = 4.0572 +cache_read = 0.266616 + +[limit] +context = 256_000 +output = 256_000 + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/models/kimi-k2.7-code.toml b/providers/melious/models/kimi-k2.7-code.toml new file mode 100644 index 00000000000..56556775b83 --- /dev/null +++ b/providers/melious/models/kimi-k2.7-code.toml @@ -0,0 +1,30 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 0.70 in / EUR 3.00 +# out / EUR 0.19 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/kimi-k2.7-code (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. moonshotai first-party records no caller control for this model; +# that enum is not reachable through this API. The host accepts any effort string +# without a 4xx, so acceptance proves nothing; the values below are the documented +# ladder (low|medium|high) plus none, which was measured to be a real off state -- +# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. +# Because none is reachable, this is an effort list with none rather than a toggle. +# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour +# distinct from high, so they are not authored. Measured 2026-09-14 against +# api.melious.ai/v1/chat/completions on this model. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +base_model = "moonshotai/kimi-k2.7-code" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 0.81144 +output = 3.4776 +cache_read = 0.220248 + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/models/kimi-k3.toml b/providers/melious/models/kimi-k3.toml new file mode 100644 index 00000000000..5141f3af0de --- /dev/null +++ b/providers/melious/models/kimi-k3.toml @@ -0,0 +1,36 @@ +# Cost: Melious list price for the default `balanced` route -- EUR 2.75 in / EUR 13.75 +# out / EUR 0.68 cache read per 1M tokens -- converted at 1.1592 USD/EUR (ECB euro +# reference rate, 2026-09-11). +# Sources: GET https://api.melious.ai/v1/models?include_meta=true and +# https://melious.ai/hub/models/kimi-k3 (both accessed 2026-09-14) +# FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html +# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards +# no lab-native thinking field and has no reasoning budget, so no toggle or +# budget_tokens here. moonshotai first-party exposes toggle + low|high|max for this +# model; that enum is not reachable through this API. The host accepts any effort +# string without a 4xx, so acceptance proves nothing; the values below are the +# documented ladder (low|medium|high) plus none, which was measured to be a real off +# state -- reasoning_effort="none" returns usage.reasoning_tokens = 0 and no +# reasoning_content. Because none is reachable, this is an effort list with none +# rather than a toggle. minimal/xhigh/max are accepted but are undocumented and did +# not produce behaviour distinct from high, so they are not authored. Measured +# 2026-09-14 against api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro +# and kimi-k2.7-code. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Reasoning text is returned in choices[].message.reasoning_content. cache_read: +# usage.cached_tokens are billed at Melious's discounted prefix-cache rate. +# limit.context: the catalog reports 1_000_000 for this deployment, not the lab's +# 1_048_576. +base_model = "moonshotai/kimi-k3" +reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] + +[cost] +input = 3.1878 +output = 15.939 +cache_read = 0.788256 + +[limit] +context = 1_000_000 + +[interleaved] +field = "reasoning_content" diff --git a/providers/melious/provider.toml b/providers/melious/provider.toml new file mode 100644 index 00000000000..4e5d1490605 --- /dev/null +++ b/providers/melious/provider.toml @@ -0,0 +1,28 @@ +# Melious AI GmbH relays open-weight models built by other labs on European +# infrastructure. It is not the lab for any model it serves, so every model entry +# here uses base_model. Raw HTTP is POST /v1/chat/completions; the OpenAI SDK works +# by pointing base_url at the API. +# Reasoning: the only control on this surface is `reasoning_effort`. No lab-native +# field is forwarded -- there is no thinking object, no enable_thinking, and no +# reasoning budget field -- so no entry here uses `toggle` or `budget_tokens`. +# The host accepts any effort string without a 4xx, so acceptance alone proves +# nothing. Entries author the documented ladder (low|medium|high) plus `none`, which +# was measured to be a real off state: reasoning_effort="none" returns +# usage.reasoning_tokens = 0 and no reasoning_content. Because `none` is reachable +# these are effort lists containing `none`, not toggles. Undocumented values +# (minimal, xhigh, max) are accepted but produced no behaviour distinct from `high`, +# so they are not authored. Reasoning text is returned in +# choices[].message.reasoning_content. +# https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) +# Routing: a flavour is selected with a model-ID suffix (`:balanced`, `:speed`, +# `:price`, `:eco`, `:batch`). A bare chat model ID resolves to `balanced`, which is +# what the ids and prices here describe; only bare ids are published. A `preset` +# field biases routing, not reasoning depth. +# https://melious.ai/docs/concepts/routing (accessed 2026-09-14) +# Caching: usage.cached_tokens are prompt tokens served from the prefix cache and +# are billed at a cheaper cache-read rate, recorded as cost.cache_read. +name = "Melious" +npm = "@ai-sdk/openai-compatible" +api = "https://api.melious.ai/v1" +env = ["MELIOUS_API_KEY"] +doc = "https://melious.ai/docs/reference/models" From 6180a3cf07c6c08bda4e90d256c90b471b3a1baa Mon Sep 17 00:00:00 2001 From: jope35 <15650945+jope35@users.noreply.github.com> Date: Mon, 14 Sep 2026 11:53:02 +0200 Subject: [PATCH 2/2] fix(melious): derive reasoning_options per model from measurement Replaces the uniform effort ["none","low","medium","high"] on all 15 entries, which asserted a graded ladder this host does not implement. Every model was probed against api.melious.ai/v1/chat/completions on 2026-09-14 at temperature 0 with the same prompt, comparing emitted reasoning_content across none/low/medium/high (repeat samples where the result was load-bearing): - 12 models: reasoning_effort="none" is a real off state (reasoning_tokens = 0, no reasoning_content) while low/medium/high all reason with no ordered difference in depth -> effort ["none", "high"]. An effort list containing none rather than a toggle, since off is reachable through this field. - glm-5, deepseek-r1-0528, kimi-k2.5: "none" does not suppress reasoning and no level grades -> reasoning_options = []. An affirmative measurement of no caller control, not an untested default. No model showed graded effort, so no graded levels are published. The host accepts any effort string without a 4xx, so acceptance was not treated as evidence. The catalog's reasoning_type is not a reliable guide either: glm-5.3-flash is typed always-on yet honours "none", glm-5 is typed hybrid yet ignores it. Co-Authored-By: Claude Opus 5 (1M context) --- .../melious/models/deepseek-r1-0528.toml | 20 +++++++--------- providers/melious/models/deepseek-v3.2.toml | 22 ++++++++---------- .../models/deepseek-v4-flash-0731.toml | 22 ++++++++---------- .../melious/models/deepseek-v4-pro-0813.toml | 22 ++++++++---------- providers/melious/models/deepseek-v4-pro.toml | 22 ++++++++---------- .../melious/models/deepseek-v4.1-flash.toml | 22 ++++++++---------- providers/melious/models/glm-5.1.toml | 23 ++++++++----------- providers/melious/models/glm-5.2.toml | 22 ++++++++---------- providers/melious/models/glm-5.3-flash.toml | 23 ++++++++----------- providers/melious/models/glm-5.3.toml | 22 ++++++++---------- providers/melious/models/glm-5.toml | 21 +++++++---------- providers/melious/models/kimi-k2.5.toml | 20 +++++++--------- providers/melious/models/kimi-k2.6.toml | 23 ++++++++----------- providers/melious/models/kimi-k2.7-code.toml | 22 ++++++++---------- providers/melious/models/kimi-k3.toml | 23 ++++++++----------- providers/melious/provider.toml | 23 +++++++++++-------- 16 files changed, 158 insertions(+), 194 deletions(-) diff --git a/providers/melious/models/deepseek-r1-0528.toml b/providers/melious/models/deepseek-r1-0528.toml index 9b71913f21d..78d2c96463c 100644 --- a/providers/melious/models/deepseek-r1-0528.toml +++ b/providers/melious/models/deepseek-r1-0528.toml @@ -4,24 +4,20 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/deepseek-r1-0528 (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. OpenRouter records no caller control for this model; that enum -# is not reachable through this API. The host accepts any effort string without a 4xx, -# so acceptance proves nothing; the values below are the documented ladder -# (low|medium|high) plus none, which was measured to be a real off state -- -# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. -# Because none is reachable, this is an effort list with none rather than a toggle. -# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour -# distinct from high, so they are not authored. Measured 2026-09-14 against -# api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget. Measured against this +# deployment on 2026-09-14, it has no effect on this model: reasoning_effort="none" +# still returns reasoning (reasoning_content 2_786/3_010 chars across repeat samples), +# and low/medium/high produce no ordered difference. reasoning_options is therefore [] +# -- this model reasons, with no caller control on this host. That is an affirmative +# measurement, not an untested default. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. # limit.context: the catalog reports 164_000 for this deployment, not the lab's # 128_000. base_model = "deepseek/deepseek-r1" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [] [cost] input = 0.69552 diff --git a/providers/melious/models/deepseek-v3.2.toml b/providers/melious/models/deepseek-v3.2.toml index f59ad411ab4..87e4436bc09 100644 --- a/providers/melious/models/deepseek-v3.2.toml +++ b/providers/melious/models/deepseek-v3.2.toml @@ -4,24 +4,22 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/deepseek-v3.2 (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. OpenRouter exposes an on/off thinking toggle for this model; -# that enum is not reachable through this API. The host accepts any effort string -# without a 4xx, so acceptance proves nothing; the values below are the documented -# ladder (low|medium|high) plus none, which was measured to be a real off state -- -# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. -# Because none is reachable, this is an effort list with none rather than a toggle. -# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour -# distinct from high, so they are not authored. Measured 2026-09-14 against -# api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget, so no toggle or +# budget_tokens. Measured against this deployment on 2026-09-14: +# reasoning_effort="none" is a real off state (usage.reasoning_tokens = 0 and no +# reasoning_content), while low/medium/high all return reasoning with no ordered +# difference in depth, so they are not published as separate grades. The host also +# accepts undocumented values without a 4xx, so acceptance is not evidence. Because +# off is reachable through the effort field this is an effort list containing none, +# not a toggle. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. # limit.context: the catalog reports 164_000 for this deployment, not the lab's # 128_000. base_model = "deepseek/deepseek-v3.2" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [{ type = "effort", values = ["none", "high"] }] [cost] input = 0.34776 diff --git a/providers/melious/models/deepseek-v4-flash-0731.toml b/providers/melious/models/deepseek-v4-flash-0731.toml index 95ada7ed642..6f5c2d8fa23 100644 --- a/providers/melious/models/deepseek-v4-flash-0731.toml +++ b/providers/melious/models/deepseek-v4-flash-0731.toml @@ -4,22 +4,20 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/deepseek-v4-flash-0731 (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. OpenRouter exposes toggle + low|high|max for this model; that -# enum is not reachable through this API. The host accepts any effort string without a -# 4xx, so acceptance proves nothing; the values below are the documented ladder -# (low|medium|high) plus none, which was measured to be a real off state -- -# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. -# Because none is reachable, this is an effort list with none rather than a toggle. -# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour -# distinct from high, so they are not authored. Measured 2026-09-14 against -# api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget, so no toggle or +# budget_tokens. Measured against this deployment on 2026-09-14: +# reasoning_effort="none" is a real off state (usage.reasoning_tokens = 0 and no +# reasoning_content), while low/medium/high all return reasoning with no ordered +# difference in depth, so they are not published as separate grades. The host also +# accepts undocumented values without a 4xx, so acceptance is not evidence. Because +# off is reachable through the effort field this is an effort list containing none, +# not a toggle. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. base_model = "deepseek/deepseek-v4-flash-0731" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [{ type = "effort", values = ["none", "high"] }] [cost] input = 0.11592 diff --git a/providers/melious/models/deepseek-v4-pro-0813.toml b/providers/melious/models/deepseek-v4-pro-0813.toml index 8093e0e5a43..0cdb0c82645 100644 --- a/providers/melious/models/deepseek-v4-pro-0813.toml +++ b/providers/melious/models/deepseek-v4-pro-0813.toml @@ -4,22 +4,20 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/deepseek-v4-pro-0813 (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. OpenRouter exposes toggle + low|high|max for this model; that -# enum is not reachable through this API. The host accepts any effort string without a -# 4xx, so acceptance proves nothing; the values below are the documented ladder -# (low|medium|high) plus none, which was measured to be a real off state -- -# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. -# Because none is reachable, this is an effort list with none rather than a toggle. -# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour -# distinct from high, so they are not authored. Measured 2026-09-14 against -# api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget, so no toggle or +# budget_tokens. Measured against this deployment on 2026-09-14: +# reasoning_effort="none" is a real off state (usage.reasoning_tokens = 0 and no +# reasoning_content), while low/medium/high all return reasoning with no ordered +# difference in depth, so they are not published as separate grades. The host also +# accepts undocumented values without a 4xx, so acceptance is not evidence. Because +# off is reachable through the effort field this is an effort list containing none, +# not a toggle. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. base_model = "deepseek/deepseek-v4-pro-0813" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [{ type = "effort", values = ["none", "high"] }] [cost] input = 1.1592 diff --git a/providers/melious/models/deepseek-v4-pro.toml b/providers/melious/models/deepseek-v4-pro.toml index b1b192a8bf4..ca2515e3ebf 100644 --- a/providers/melious/models/deepseek-v4-pro.toml +++ b/providers/melious/models/deepseek-v4-pro.toml @@ -4,22 +4,20 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/deepseek-v4-pro (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. deepseek first-party exposes toggle + high|max for this model; -# that enum is not reachable through this API. The host accepts any effort string -# without a 4xx, so acceptance proves nothing; the values below are the documented -# ladder (low|medium|high) plus none, which was measured to be a real off state -- -# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. -# Because none is reachable, this is an effort list with none rather than a toggle. -# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour -# distinct from high, so they are not authored. Measured 2026-09-14 against -# api.melious.ai/v1/chat/completions on this model. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget, so no toggle or +# budget_tokens. Measured against this deployment on 2026-09-14: +# reasoning_effort="none" is a real off state (usage.reasoning_tokens = 0 and no +# reasoning_content), while low/medium/high all return reasoning with no ordered +# difference in depth, so they are not published as separate grades. The host also +# accepts undocumented values without a 4xx, so acceptance is not evidence. Because +# off is reachable through the effort field this is an effort list containing none, +# not a toggle. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. base_model = "deepseek/deepseek-v4-pro" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [{ type = "effort", values = ["none", "high"] }] [cost] input = 1.85472 diff --git a/providers/melious/models/deepseek-v4.1-flash.toml b/providers/melious/models/deepseek-v4.1-flash.toml index d30b0cba793..679d9879d8b 100644 --- a/providers/melious/models/deepseek-v4.1-flash.toml +++ b/providers/melious/models/deepseek-v4.1-flash.toml @@ -4,22 +4,20 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/deepseek-v4.1-flash (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. OpenRouter exposes toggle + low|high|max for this model; that -# enum is not reachable through this API. The host accepts any effort string without a -# 4xx, so acceptance proves nothing; the values below are the documented ladder -# (low|medium|high) plus none, which was measured to be a real off state -- -# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. -# Because none is reachable, this is an effort list with none rather than a toggle. -# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour -# distinct from high, so they are not authored. Measured 2026-09-14 against -# api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget, so no toggle or +# budget_tokens. Measured against this deployment on 2026-09-14: +# reasoning_effort="none" is a real off state (usage.reasoning_tokens = 0 and no +# reasoning_content), while low/medium/high all return reasoning with no ordered +# difference in depth, so they are not published as separate grades. The host also +# accepts undocumented values without a 4xx, so acceptance is not evidence. Because +# off is reachable through the effort field this is an effort list containing none, +# not a toggle. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. base_model = "deepseek/deepseek-v4.1-flash" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [{ type = "effort", values = ["none", "high"] }] [cost] input = 0.23184 diff --git a/providers/melious/models/glm-5.1.toml b/providers/melious/models/glm-5.1.toml index e9d0e168f8a..63766b09ff8 100644 --- a/providers/melious/models/glm-5.1.toml +++ b/providers/melious/models/glm-5.1.toml @@ -4,25 +4,22 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/glm-5.1 (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. zhipuai first-party exposes an on/off thinking toggle for this -# model; that enum is not reachable through this API. The host accepts any effort -# string without a 4xx, so acceptance proves nothing; the values below are the -# documented ladder (low|medium|high) plus none, which was measured to be a real off -# state -- reasoning_effort="none" returns usage.reasoning_tokens = 0 and no -# reasoning_content. Because none is reachable, this is an effort list with none -# rather than a toggle. minimal/xhigh/max are accepted but are undocumented and did -# not produce behaviour distinct from high, so they are not authored. Measured -# 2026-09-14 against api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro -# and kimi-k2.7-code. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget, so no toggle or +# budget_tokens. Measured against this deployment on 2026-09-14: +# reasoning_effort="none" is a real off state (usage.reasoning_tokens = 0 and no +# reasoning_content), while low/medium/high all return reasoning with no ordered +# difference in depth, so they are not published as separate grades. The host also +# accepts undocumented values without a 4xx, so acceptance is not evidence. Because +# off is reachable through the effort field this is an effort list containing none, +# not a toggle. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. # limit.context: the catalog reports 203_000 for this deployment, not the lab's # 200_000. base_model = "zhipuai/glm-5.1" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [{ type = "effort", values = ["none", "high"] }] [cost] input = 1.50696 diff --git a/providers/melious/models/glm-5.2.toml b/providers/melious/models/glm-5.2.toml index 9089a429ce8..8ca4dbe4c3e 100644 --- a/providers/melious/models/glm-5.2.toml +++ b/providers/melious/models/glm-5.2.toml @@ -4,22 +4,20 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/glm-5.2 (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. zhipuai first-party exposes high|max for this model; that enum -# is not reachable through this API. The host accepts any effort string without a 4xx, -# so acceptance proves nothing; the values below are the documented ladder -# (low|medium|high) plus none, which was measured to be a real off state -- -# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. -# Because none is reachable, this is an effort list with none rather than a toggle. -# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour -# distinct from high, so they are not authored. Measured 2026-09-14 against -# api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget, so no toggle or +# budget_tokens. Measured against this deployment on 2026-09-14: +# reasoning_effort="none" is a real off state (usage.reasoning_tokens = 0 and no +# reasoning_content), while low/medium/high all return reasoning with no ordered +# difference in depth, so they are not published as separate grades. The host also +# accepts undocumented values without a 4xx, so acceptance is not evidence. Because +# off is reachable through the effort field this is an effort list containing none, +# not a toggle. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. base_model = "zhipuai/glm-5.2" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [{ type = "effort", values = ["none", "high"] }] [cost] input = 1.1592 diff --git a/providers/melious/models/glm-5.3-flash.toml b/providers/melious/models/glm-5.3-flash.toml index 033361ee652..d25a740b3f3 100644 --- a/providers/melious/models/glm-5.3-flash.toml +++ b/providers/melious/models/glm-5.3-flash.toml @@ -4,25 +4,22 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/glm-5.3-flash (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. zhipuai first-party and most relay peers expose low|high|max for -# this model; that enum is not reachable through this API. The host accepts any effort -# string without a 4xx, so acceptance proves nothing; the values below are the -# documented ladder (low|medium|high) plus none, which was measured to be a real off -# state -- reasoning_effort="none" returns usage.reasoning_tokens = 0 and no -# reasoning_content. Because none is reachable, this is an effort list with none -# rather than a toggle. minimal/xhigh/max are accepted but are undocumented and did -# not produce behaviour distinct from high, so they are not authored. Measured -# 2026-09-14 against api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro -# and kimi-k2.7-code. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget, so no toggle or +# budget_tokens. Measured against this deployment on 2026-09-14: +# reasoning_effort="none" is a real off state (usage.reasoning_tokens = 0 and no +# reasoning_content), while low/medium/high all return reasoning with no ordered +# difference in depth, so they are not published as separate grades. The host also +# accepts undocumented values without a 4xx, so acceptance is not evidence. Because +# off is reachable through the effort field this is an effort list containing none, +# not a toggle. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. # modalities.input: this host routes ["text", "image", "video"], narrower than the # lab's ["text", "image", "video", "pdf"]. base_model = "zhipuai/glm-5.3-flash" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [{ type = "effort", values = ["none", "high"] }] [cost] input = 0.11592 diff --git a/providers/melious/models/glm-5.3.toml b/providers/melious/models/glm-5.3.toml index eb53ed2d08a..03eac7197c0 100644 --- a/providers/melious/models/glm-5.3.toml +++ b/providers/melious/models/glm-5.3.toml @@ -4,22 +4,20 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/glm-5.3 (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. zhipuai first-party and most relay peers expose low|high|max for -# this model; that enum is not reachable through this API. The host accepts any effort -# string without a 4xx, so acceptance proves nothing; the values below are the -# documented ladder (low|medium|high) plus none, which was measured to be a real off -# state -- reasoning_effort="none" returns usage.reasoning_tokens = 0 and no -# reasoning_content. Because none is reachable, this is an effort list with none -# rather than a toggle. minimal/xhigh/max are accepted but are undocumented and did -# not produce behaviour distinct from high, so they are not authored. Measured -# 2026-09-14 against api.melious.ai/v1/chat/completions on this model. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget, so no toggle or +# budget_tokens. Measured against this deployment on 2026-09-14: +# reasoning_effort="none" is a real off state (usage.reasoning_tokens = 0 and no +# reasoning_content), while low/medium/high all return reasoning with no ordered +# difference in depth, so they are not published as separate grades. The host also +# accepts undocumented values without a 4xx, so acceptance is not evidence. Because +# off is reachable through the effort field this is an effort list containing none, +# not a toggle. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. base_model = "zhipuai/glm-5.3" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [{ type = "effort", values = ["none", "high"] }] [cost] input = 1.1592 diff --git a/providers/melious/models/glm-5.toml b/providers/melious/models/glm-5.toml index d9218721567..19ac9f0e728 100644 --- a/providers/melious/models/glm-5.toml +++ b/providers/melious/models/glm-5.toml @@ -4,25 +4,20 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/glm-5 (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. zhipuai first-party exposes an on/off thinking toggle for this -# model; that enum is not reachable through this API. The host accepts any effort -# string without a 4xx, so acceptance proves nothing; the values below are the -# documented ladder (low|medium|high) plus none, which was measured to be a real off -# state -- reasoning_effort="none" returns usage.reasoning_tokens = 0 and no -# reasoning_content. Because none is reachable, this is an effort list with none -# rather than a toggle. minimal/xhigh/max are accepted but are undocumented and did -# not produce behaviour distinct from high, so they are not authored. Measured -# 2026-09-14 against api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro -# and kimi-k2.7-code. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget. Measured against this +# deployment on 2026-09-14, it has no effect on this model: reasoning_effort="none" +# still returns reasoning (reasoning_content 2_444/2_239/686/3_907 chars across repeat +# samples), and low/medium/high produce no ordered difference. reasoning_options is +# therefore [] -- this model reasons, with no caller control on this host. That is an +# affirmative measurement, not an untested default. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. # limit.context: the catalog reports 203_000 for this deployment, not the lab's # 204_800. base_model = "zhipuai/glm-5" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [] [cost] input = 1.10124 diff --git a/providers/melious/models/kimi-k2.5.toml b/providers/melious/models/kimi-k2.5.toml index 7aa04e7f2c9..fabc024c1a0 100644 --- a/providers/melious/models/kimi-k2.5.toml +++ b/providers/melious/models/kimi-k2.5.toml @@ -4,17 +4,13 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/kimi-k2.5 (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. OpenRouter exposes an on/off thinking toggle for this model; -# that enum is not reachable through this API. The host accepts any effort string -# without a 4xx, so acceptance proves nothing; the values below are the documented -# ladder (low|medium|high) plus none, which was measured to be a real off state -- -# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. -# Because none is reachable, this is an effort list with none rather than a toggle. -# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour -# distinct from high, so they are not authored. Measured 2026-09-14 against -# api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro and kimi-k2.7-code. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget. Measured against this +# deployment on 2026-09-14, it has no effect on this model: reasoning_effort="none" +# still returns reasoning (reasoning_content 1_177/1_714/1_100 chars across repeat +# samples), and low/medium/high produce no ordered difference. reasoning_options is +# therefore [] -- this model reasons, with no caller control on this host. That is an +# affirmative measurement, not an untested default. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. @@ -24,7 +20,7 @@ # modalities.input: this host routes ["text", "image"], narrower than the lab's # ["text", "image", "video"]. base_model = "moonshotai/kimi-k2.5" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [] [cost] input = 0.5796 diff --git a/providers/melious/models/kimi-k2.6.toml b/providers/melious/models/kimi-k2.6.toml index effdbe69be3..4784a6bc4c8 100644 --- a/providers/melious/models/kimi-k2.6.toml +++ b/providers/melious/models/kimi-k2.6.toml @@ -4,18 +4,15 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/kimi-k2.6 (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. moonshotai first-party exposes an on/off thinking toggle for -# this model; that enum is not reachable through this API. The host accepts any effort -# string without a 4xx, so acceptance proves nothing; the values below are the -# documented ladder (low|medium|high) plus none, which was measured to be a real off -# state -- reasoning_effort="none" returns usage.reasoning_tokens = 0 and no -# reasoning_content. Because none is reachable, this is an effort list with none -# rather than a toggle. minimal/xhigh/max are accepted but are undocumented and did -# not produce behaviour distinct from high, so they are not authored. Measured -# 2026-09-14 against api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro -# and kimi-k2.7-code. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget, so no toggle or +# budget_tokens. Measured against this deployment on 2026-09-14: +# reasoning_effort="none" is a real off state (usage.reasoning_tokens = 0 and no +# reasoning_content), while low/medium/high all return reasoning with no ordered +# difference in depth, so they are not published as separate grades. The host also +# accepts undocumented values without a 4xx, so acceptance is not evidence. Because +# off is reachable through the effort field this is an effort list containing none, +# not a toggle. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. @@ -23,7 +20,7 @@ # 262_144. limit.output: max_output_tokens is null for this model, so output is capped # at the served context rather than inheriting the lab's larger 262_144. base_model = "moonshotai/kimi-k2.6" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [{ type = "effort", values = ["none", "high"] }] [cost] input = 0.81144 diff --git a/providers/melious/models/kimi-k2.7-code.toml b/providers/melious/models/kimi-k2.7-code.toml index 56556775b83..a38cc7a360b 100644 --- a/providers/melious/models/kimi-k2.7-code.toml +++ b/providers/melious/models/kimi-k2.7-code.toml @@ -4,22 +4,20 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/kimi-k2.7-code (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. moonshotai first-party records no caller control for this model; -# that enum is not reachable through this API. The host accepts any effort string -# without a 4xx, so acceptance proves nothing; the values below are the documented -# ladder (low|medium|high) plus none, which was measured to be a real off state -- -# reasoning_effort="none" returns usage.reasoning_tokens = 0 and no reasoning_content. -# Because none is reachable, this is an effort list with none rather than a toggle. -# minimal/xhigh/max are accepted but are undocumented and did not produce behaviour -# distinct from high, so they are not authored. Measured 2026-09-14 against -# api.melious.ai/v1/chat/completions on this model. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget, so no toggle or +# budget_tokens. Measured against this deployment on 2026-09-14: +# reasoning_effort="none" is a real off state (usage.reasoning_tokens = 0 and no +# reasoning_content), while low/medium/high all return reasoning with no ordered +# difference in depth, so they are not published as separate grades. The host also +# accepts undocumented values without a 4xx, so acceptance is not evidence. Because +# off is reachable through the effort field this is an effort list containing none, +# not a toggle. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. base_model = "moonshotai/kimi-k2.7-code" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [{ type = "effort", values = ["none", "high"] }] [cost] input = 0.81144 diff --git a/providers/melious/models/kimi-k3.toml b/providers/melious/models/kimi-k3.toml index 5141f3af0de..6f9d4f8021b 100644 --- a/providers/melious/models/kimi-k3.toml +++ b/providers/melious/models/kimi-k3.toml @@ -4,25 +4,22 @@ # Sources: GET https://api.melious.ai/v1/models?include_meta=true and # https://melious.ai/hub/models/kimi-k3 (both accessed 2026-09-14) # FX: https://www.ecb.europa.eu/stats/policy_and_exchange_rates/euro_reference_exchange_rates/html/eurofxref-graph-usd.en.html -# Effort: reasoning_effort, the only reasoning control this host exposes. It forwards -# no lab-native thinking field and has no reasoning budget, so no toggle or -# budget_tokens here. moonshotai first-party exposes toggle + low|high|max for this -# model; that enum is not reachable through this API. The host accepts any effort -# string without a 4xx, so acceptance proves nothing; the values below are the -# documented ladder (low|medium|high) plus none, which was measured to be a real off -# state -- reasoning_effort="none" returns usage.reasoning_tokens = 0 and no -# reasoning_content. Because none is reachable, this is an effort list with none -# rather than a toggle. minimal/xhigh/max are accepted but are undocumented and did -# not produce behaviour distinct from high, so they are not authored. Measured -# 2026-09-14 against api.melious.ai/v1/chat/completions on glm-5.3, deepseek-v4-pro -# and kimi-k2.7-code. +# Effort: reasoning_effort is the only reasoning control this host exposes, and it +# forwards no lab-native thinking field and no reasoning budget, so no toggle or +# budget_tokens. Measured against this deployment on 2026-09-14: +# reasoning_effort="none" is a real off state (usage.reasoning_tokens = 0 and no +# reasoning_content), while low/medium/high all return reasoning with no ordered +# difference in depth, so they are not published as separate grades. The host also +# accepts undocumented values without a 4xx, so acceptance is not evidence. Because +# off is reachable through the effort field this is an effort list containing none, +# not a toggle. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Reasoning text is returned in choices[].message.reasoning_content. cache_read: # usage.cached_tokens are billed at Melious's discounted prefix-cache rate. # limit.context: the catalog reports 1_000_000 for this deployment, not the lab's # 1_048_576. base_model = "moonshotai/kimi-k3" -reasoning_options = [{ type = "effort", values = ["none", "low", "medium", "high"] }] +reasoning_options = [{ type = "effort", values = ["none", "high"] }] [cost] input = 3.1878 diff --git a/providers/melious/provider.toml b/providers/melious/provider.toml index 4e5d1490605..db50ccc00f3 100644 --- a/providers/melious/provider.toml +++ b/providers/melious/provider.toml @@ -3,15 +3,20 @@ # here uses base_model. Raw HTTP is POST /v1/chat/completions; the OpenAI SDK works # by pointing base_url at the API. # Reasoning: the only control on this surface is `reasoning_effort`. No lab-native -# field is forwarded -- there is no thinking object, no enable_thinking, and no -# reasoning budget field -- so no entry here uses `toggle` or `budget_tokens`. -# The host accepts any effort string without a 4xx, so acceptance alone proves -# nothing. Entries author the documented ladder (low|medium|high) plus `none`, which -# was measured to be a real off state: reasoning_effort="none" returns -# usage.reasoning_tokens = 0 and no reasoning_content. Because `none` is reachable -# these are effort lists containing `none`, not toggles. Undocumented values -# (minimal, xhigh, max) are accepted but produced no behaviour distinct from `high`, -# so they are not authored. Reasoning text is returned in +# field is forwarded -- no thinking object, no enable_thinking, no reasoning budget -- +# so no entry here uses `toggle` or `budget_tokens`. The host also accepts any effort +# string without a 4xx, including undocumented ones, so acceptance is not evidence. +# Every model here was measured against this deployment on 2026-09-14 instead. Two +# behaviours were found, and neither matches the vendor docs' low|medium|high ladder: +# on 12 models reasoning_effort="none" is a real off state (usage.reasoning_tokens = 0 +# and no reasoning_content) while low, medium and high all reason with no ordered +# difference in depth -- those are authored as effort ["none", "high"], an effort list +# containing none rather than a toggle, because off is reachable through this field. +# On glm-5, deepseek-r1-0528 and kimi-k2.5, "none" does not suppress reasoning and no +# level grades, so those carry reasoning_options = [] -- an affirmative measurement of +# no caller control, not an untested default. The catalog's own reasoning_type is not +# a reliable guide: glm-5.3-flash is typed always-on yet honours "none", and glm-5 is +# typed hybrid yet ignores it. Reasoning text is returned in # choices[].message.reasoning_content. # https://melious.ai/docs/reference/chat-completions (accessed 2026-09-14) # Routing: a flavour is selected with a model-ID suffix (`:balanced`, `:speed`,