diff --git a/models/bytedance-seed/seed-2.1-pro-0915.toml b/models/bytedance-seed/seed-2.1-pro-0915.toml new file mode 100644 index 0000000000..7cf103012b --- /dev/null +++ b/models/bytedance-seed/seed-2.1-pro-0915.toml @@ -0,0 +1,45 @@ +# Sources (accessed 2026-10-31): +# - Snapshot ID doubao-seed-2-1-pro-260915 (YYMMDD suffix = 2026-09-15), the newer Seed 2.1 Pro +# snapshot on Volcengine Ark: https://www.volcengine.com/docs/82379/1330310 +# - Limits: 1M context, up to 256K output; the earlier 260628 snapshot is 256K context +# (bytedance-seed/seed-2.1-pro). +# - Image/video formats: same Ark image and video understanding tables as seed-2.1-pro: +# https://www.volcengine.com/docs/82379/1362931, https://www.volcengine.com/docs/82379/1895586 +# - Sampling: the Ark Chat API takes temperature and top_p and has no top_k: https://www.volcengine.com/docs/82379/1494384 +schema = 2 +name = "Seed 2.1 Pro 0915" +description = "September 2026 snapshot of ByteDance's flagship Seed 2.1 Pro with a 1M context window for multimodal reasoning, coding, and agents" +family = "seed" +open_weights = false +release_date = "2026-09-15" + +[modalities] +input = [ + "text", + "image/jpeg", + "image/png", + "image/gif", + "image/webp", + "image/bmp", + "image/tiff", + "image/x-icon", + "image/x-icns", + "image/sgi", + "image/jp2", + "image/heic", + "video/mp4", + "video/x-msvideo", + "video/quicktime", +] +output = ["text"] + +[capabilities] +tools = { supported = true } +reasoning = { supported = true } +temperature = true +top_p = true +top_k = false + +[limit] +context = 1_048_576 +output = 262_144 diff --git a/models/kuaishou/kling-v4.toml b/models/kuaishou/kling-v4.toml new file mode 100644 index 0000000000..c434ba57ef --- /dev/null +++ b/models/kuaishou/kling-v4.toml @@ -0,0 +1,28 @@ +# Released 2026-10-15: https://bernama.com/en/press/news.php?id=2622471 +# ("Kling AI Officially Launches Next-Generation Kling 4.0"). +# Inputs: text prompt plus first/last-frame images (JPG/JPEG or PNG, as for Kling 3.0): +# https://app.klingai.com/global/dev/document-api/apiReference/model/imageToVideo +# Output: MP4; generated sound is a track inside the MP4, so no audio MIME type is listed. +# Sampling: the task API has no temperature, top_p or top_k. +schema = 2 +v2_only = true +type = "video" +name = "Kling VIDEO 4.0" +description = "Kling 4.0 video model with clips up to 30 seconds, keyframe control and native audio" +open_weights = false +release_date = "2026-10-15" + +[modalities] +input = ["text", "image/jpeg", "image/png"] +output = ["video/mp4"] + +[capabilities] +tools = { supported = false } +reasoning = { supported = false } +temperature = false +top_p = false +top_k = false + +[limit] +context = 0 +output = 0 diff --git a/models/xai/grok-4.20-multi-agent-0309.toml b/models/xai/grok-4.20-multi-agent-0309.toml new file mode 100644 index 0000000000..9e7ffe77b8 --- /dev/null +++ b/models/xai/grok-4.20-multi-agent-0309.toml @@ -0,0 +1,26 @@ +# Sources (docs.x.ai), mirrored from providers/xai/models/grok-4.20-multi-agent-0309.toml: +# - Model page: https://docs.x.ai/developers/models/grok-4.20-multi-agent-0309 +# - Client-side function tools need beta access on xAI ("Client-side tools for multi-agent models +# require beta access"), so tools stay off for general access. +# Lab file added so relays can point base_model at it; the xAI provider file stays a full definition. +schema = 2 +name = "Grok 4.20 Multi-Agent" +description = "Grok model for agentic tool use, reasoning, coding, and live assistance" +family = "grok" +open_weights = false +release_date = "2026-03-09" + +[modalities] +input = ["text", "image/jpeg", "image/png", "application/pdf"] +output = ["text"] + +[capabilities] +tools = { supported = false } +reasoning = { supported = true } +temperature = true +top_p = true +top_k = true + +[limit] +context = 1_000_000 +output = 30_000 diff --git a/providers/hopbase/logo.svg b/providers/hopbase/logo.svg new file mode 100644 index 0000000000..b21e194e3f --- /dev/null +++ b/providers/hopbase/logo.svg @@ -0,0 +1,5 @@ + + + + + diff --git a/providers/hopbase/models/claude-fable-5-2.toml b/providers/hopbase/models/claude-fable-5-2.toml new file mode 100644 index 0000000000..d1e0d416ee --- /dev/null +++ b/providers/hopbase/models/claude-fable-5-2.toml @@ -0,0 +1,32 @@ +# Verified live 2026-11-10 against POST https://api.hop-base.com/v1/messages (Anthropic Messages, +# x-api-key auth) with this exact model ID and a regular customer API key. HopBase serves Claude +# models over Messages only, so this file overrides the provider's Chat Completions endpoint. +# Streaming returned message_delta usage and message_stop. tool_choice auto returned a well-formed +# tool_use; a strict tool returned tool_use; tool_choice any returns HTTP 400 "tool_choice: type +# \"tool\" and \"any\" are not supported for this model", as on Anthropic. +# Effort: output_config.effort = low|medium|high|xhigh|max all accepted. +# Images: a red 64x64 PNG returned "Red". +# Cache: cache_control on the system block wrote 6,026 tokens and the repeat read 6,026. Only explicit +# caching is declared: HopBase documents cache_control markers and makes no promise for prompts sent +# without them. +# Pricing: price any registered account pays in the public "Claude Max (ccmax)" group, USD +# (official $8 / $40, $0.20 cache read, $10 5m cache write, https://platform.claude.com/docs/en/about-claude/pricing, +# times the group rate, rounded up). Model page: https://hop-base.com/en/docs/models/claude-fable-5-2 +schema = 2 +base_model = "anthropic/claude-fable-5-2" + +[capabilities] +tools = { supported = true, strict = true, choice = ["auto", "none"] } +reasoning = { supported = true, effort = ["low", "medium", "high", "xhigh", "max"] } +cache = { explicit = { ttl = ["5m"], max_breakpoints = 4, targets = ["tools", "system", "messages"] } } + +[api.messages] +base_url = "https://api.hop-base.com/v1" +sdk = { aisdk = "@ai-sdk/anthropic", opencodeai = "@opencode/ai/providers/anthropic-compatible" } + +[cost.text.input] +price = 2.24 +cache = { read = 0.056, write = 2.8 } + +[cost.text.output] +price = 11.18 diff --git a/providers/hopbase/models/deepseek-v4-pro-202606.toml b/providers/hopbase/models/deepseek-v4-pro-202606.toml new file mode 100644 index 0000000000..1c51c09f30 --- /dev/null +++ b/providers/hopbase/models/deepseek-v4-pro-202606.toml @@ -0,0 +1,38 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# HopBase serves DeepSeek V4 Pro 0813 under the ID deepseek-v4-pro-202606 (https://hop-base.com/llms.txt). +# Limits: 1,048,576-token context, up to 393,216 output tokens (same source). Text only: an image +# returns HTTP 400 image_input_not_supported before reaching the model. +# Toggle: thinking.type = enabled|disabled (disabled -> 0 reasoning tokens). +# Effort: reasoning_effort = low|high|max, the native DeepSeek levels; medium is accepted and +# mapped by DeepSeek, none also turns thinking off, an unknown value returns HTTP 400. +# Relative effort was not benchmarked. +# Reasoning text is returned in message.reasoning_content and delta.reasoning_content. +# Structured output: json_schema with strict = true returned an enum-valid object. +# Cache: repeating a ~2.5K-token prefix returned cached_tokens = 2048. +# Pricing: HopBase self-serve price, USD (https://hop-base.com/pricing, also in https://hop-base.com/llms.txt). Single all-day rate: +# HopBase does not apply DeepSeek's peak multiplier to this ID (billing logs: 3,037 requests over +# the 14 days to 2026-10-31, every one at the same per-token price across peak and off-peak hours). +schema = 2 +base_model = "deepseek/deepseek-v4-pro-0813" + +[capabilities] +reasoning = { supported = true, toggle = true, effort = ["low", "high", "max"] } +structured_output = true +stream_usage = true +cache = { implicit = true } + +[limit] +context = 1_048_576 +output = 393_216 + +[api.chat-completions] +compatibility = { reasoning_field = "reasoning_content" } + +[cost.text.input] +price = 0.726 +cache = { read = 0.0242 } + +[cost.text.output] +price = 2.178 diff --git a/providers/hopbase/models/deepseek-v4.1-flash-1017-sg.toml b/providers/hopbase/models/deepseek-v4.1-flash-1017-sg.toml new file mode 100644 index 0000000000..0efa28efa4 --- /dev/null +++ b/providers/hopbase/models/deepseek-v4.1-flash-1017-sg.toml @@ -0,0 +1,46 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Same DeepSeek V4.1 Flash 2026-10-17 release, served from a Singapore data center under its own ID. +# Limits: 1M context, up to 393,216 output tokens (https://hop-base.com/llms.txt). +# Toggle: thinking.type = enabled|disabled (disabled -> 0 reasoning tokens). +# Effort: reasoning_effort = low|high|max, the native DeepSeek levels; medium is accepted and +# mapped by DeepSeek, none also turns thinking off, an unknown value returns HTTP 400. +# Relative effort was not benchmarked. +# Reasoning text is returned in message.reasoning_content and delta.reasoning_content. +# Images: a red PNG data URL returned "Red". Structured output: json_schema with strict = true +# returned an enum-valid object. Cache: a repeated ~2.4K-token prefix returned +# prompt_tokens_details.cached_tokens = 2432. tool_choice none|required|named all honoured. +# Also checked through @ai-sdk/openai-compatible 1.0.60 (generateText, streamText, tool round trip). +# Pricing: HopBase self-serve price, USD (https://hop-base.com/pricing, also in https://hop-base.com/llms.txt). +# Peak: weekdays 09:00-12:00 and 14:00-18:00 Asia/Shanghai (UTC 01-04, 06-10); off-peak and weekends bill at half. +# Cache reads: this group discounts cached input (off-peak 0.0018); the non-sg ID bills cache reads +# at the official cache price (0.00295 off-peak), which is why the two differ. +# Peak also applies on Chinese public holidays that fall on weekdays: HopBase billing uses the +# weekday windows only, with no holiday exception. +schema = 2 +base_model = "deepseek/deepseek-v4.1-flash-1017" + +[capabilities] +tools = { supported = true, choice = ["auto", "none", "required", "tool"] } +reasoning = { supported = true, toggle = true, effort = ["low", "high", "max"] } +structured_output = true +stream_usage = true +cache = { implicit = true } + +[limit] +output = 393_216 + +[api.chat-completions] +compatibility = { reasoning_field = "reasoning_content" } + +[cost.text.input] +price = 0.08825 +cache = { read = 0.0018 } + +[cost.text.output] +price = 0.35295 + +[[cost.multipliers]] +when = { utc_days = { in = ["mon", "tue", "wed", "thu", "fri"] }, any = [{ all = [{ utc_hours = { gte = "01:00" } }, { utc_hours = { lt = "04:00" } }] }, { all = [{ utc_hours = { gte = "06:00" } }, { utc_hours = { lt = "10:00" } }] }] } +factor = 2 diff --git a/providers/hopbase/models/deepseek-v4.1-flash-1017.toml b/providers/hopbase/models/deepseek-v4.1-flash-1017.toml new file mode 100644 index 0000000000..729d5cf6f5 --- /dev/null +++ b/providers/hopbase/models/deepseek-v4.1-flash-1017.toml @@ -0,0 +1,44 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Limits: 1M context, up to 393,216 output tokens (https://hop-base.com/llms.txt). +# Toggle: thinking.type = enabled|disabled (disabled -> 0 reasoning tokens). +# Effort: reasoning_effort = low|high|max, the native DeepSeek levels; medium is accepted and +# mapped by DeepSeek, none also turns thinking off, an unknown value returns HTTP 400. +# Relative effort was not benchmarked. +# Reasoning text is returned in message.reasoning_content and delta.reasoning_content. +# Images: a red PNG data URL returned "Red". Structured output: json_schema with strict = true +# returned an enum-valid object. Cache: repeating a ~2.4K-token prefix returned cached_tokens = 2432. +# tool_choice none|required|named all honoured. +# Pricing: HopBase self-serve price, USD (https://hop-base.com/pricing, also in https://hop-base.com/llms.txt). +# Peak: weekdays 09:00-12:00 and 14:00-18:00 Asia/Shanghai (UTC 01-04, 06-10); off-peak and weekends bill at half. +# Cache reads: this ID's group bills cached input at the official cache price, so the off-peak +# cache read is 0.00295 (half of 0.0059); the -sg ID's group discounts cache reads too (0.0018). +# Peak also applies on Chinese public holidays that fall on weekdays: HopBase billing uses the +# weekday windows only, with no holiday exception. +schema = 2 +base_model = "deepseek/deepseek-v4.1-flash-1017" + +[capabilities] +tools = { supported = true, choice = ["auto", "none", "required", "tool"] } +reasoning = { supported = true, toggle = true, effort = ["low", "high", "max"] } +structured_output = true +stream_usage = true +cache = { implicit = true } + +[limit] +output = 393_216 + +[api.chat-completions] +compatibility = { reasoning_field = "reasoning_content" } + +[cost.text.input] +price = 0.08825 +cache = { read = 0.00295 } + +[cost.text.output] +price = 0.35295 + +[[cost.multipliers]] +when = { utc_days = { in = ["mon", "tue", "wed", "thu", "fri"] }, any = [{ all = [{ utc_hours = { gte = "01:00" } }, { utc_hours = { lt = "04:00" } }] }, { all = [{ utc_hours = { gte = "06:00" } }, { utc_hours = { lt = "10:00" } }] }] } +factor = 2 diff --git a/providers/hopbase/models/doubao-seed-2-0-mini-260428.toml b/providers/hopbase/models/doubao-seed-2-0-mini-260428.toml new file mode 100644 index 0000000000..f6c8b6edb0 --- /dev/null +++ b/providers/hopbase/models/doubao-seed-2-0-mini-260428.toml @@ -0,0 +1,51 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Limits: 256K context, up to 128K output (https://hop-base.com/llms.txt); max_tokens=131072 -> 200, +# 131073 -> HTTP 400 "expected a value <= 131072". +# tool_choice none|required|named all honoured. +# Effort: reasoning_effort = none|minimal|low|medium|high|xhigh|max, all accepted live; none and +# minimal return 0 reasoning tokens, so no separate toggle is declared (thinking.type = disabled is +# also accepted). An unknown value returns HTTP 400. Relative effort was not benchmarked. +# Reasoning text is returned in message.reasoning_content and delta.reasoning_content. +# Images: a red PNG data URL returned "Red"; HopBase documents image input (public URL or base64) +# but not video, so input is limited to text and common image types here. +# Structured output: json_schema with strict = true returned an enum-valid object. +# Pricing: HopBase list price, USD; base rates follow the official Volcano Engine list price. +# Tiers follow HopBase billing, not Volcano's table: a single +# long-context tier when input is greater than 32,768 tokens (long_context.threshold = 32768 in +# https://api.hop-base.com/api/v1/models/pricing); no further tier on this host. +schema = 2 +base_model = "bytedance-seed/seed-2.0-mini" + +[modalities] +input = ["text", "image/jpeg", "image/png", "image/gif", "image/webp"] +output = ["text"] + +[capabilities] +tools = { supported = true, choice = ["auto", "none", "required", "tool"] } +reasoning = { supported = true, effort = ["none", "minimal", "low", "medium", "high", "xhigh", "max"] } +structured_output = true +stream_usage = true + +[limit] +output = 131_072 + +[api.chat-completions] +compatibility = { reasoning_field = "reasoning_content" } + +[cost.text.input] +price = 0.0295 +cache = { read = 0.0059 } + +[[cost.text.input.overrides]] +when = { context = { gt = 32_768 } } +price = 0.0589 +cache = { read = 0.0118 } + +[cost.text.output] +price = 0.2942 + +[[cost.text.output.overrides]] +when = { context = { gt = 32_768 } } +price = 0.5883 diff --git a/providers/hopbase/models/doubao-seed-2-1-lite-260915.toml b/providers/hopbase/models/doubao-seed-2-1-lite-260915.toml new file mode 100644 index 0000000000..492caaaef5 --- /dev/null +++ b/providers/hopbase/models/doubao-seed-2-1-lite-260915.toml @@ -0,0 +1,35 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Limits: 1M context, up to 256K output (https://hop-base.com/llms.txt); max_tokens=262145 -> HTTP 400. +# tool_choice none|required|named all honoured. +# Effort: reasoning_effort = none|minimal|low|medium|high|xhigh|max, all accepted live; none and +# minimal return 0 reasoning tokens, so no separate toggle is declared (thinking.type = disabled is +# also accepted). An unknown value returns HTTP 400. Relative effort was not benchmarked. +# Reasoning text is returned in message.reasoning_content and delta.reasoning_content. +# Images: a red PNG data URL returned "Red"; HopBase documents image input (public URL or base64) +# but not video, so input is limited to text and common image types here. +# Structured output: json_schema with strict = true returned an enum-valid object. +# Pricing: HopBase list price, USD; follows the official Volcano Engine list price. +schema = 2 +base_model = "bytedance-seed/seed-2.1-lite" + +[modalities] +input = ["text", "image/jpeg", "image/png", "image/gif", "image/webp"] +output = ["text"] + +[capabilities] +tools = { supported = true, choice = ["auto", "none", "required", "tool"] } +reasoning = { supported = true, effort = ["none", "minimal", "low", "medium", "high", "xhigh", "max"] } +structured_output = true +stream_usage = true + +[api.chat-completions] +compatibility = { reasoning_field = "reasoning_content" } + +[cost.text.input] +price = 0.1177 +cache = { read = 0.0236 } + +[cost.text.output] +price = 0.3971 diff --git a/providers/hopbase/models/doubao-seed-2-1-pro-260628.toml b/providers/hopbase/models/doubao-seed-2-1-pro-260628.toml new file mode 100644 index 0000000000..f2b6fdbfc9 --- /dev/null +++ b/providers/hopbase/models/doubao-seed-2-1-pro-260628.toml @@ -0,0 +1,38 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Limits: 256K context, up to 128K output tokens (https://hop-base.com/llms.txt). +# tool_choice none|required|named all honoured. +# Effort: reasoning_effort = none|minimal|low|medium|high|xhigh|max, all accepted live; none and +# minimal return 0 reasoning tokens, so no separate toggle is declared (thinking.type = disabled is +# also accepted). An unknown value returns HTTP 400. Relative effort was not benchmarked. +# Reasoning text is returned in message.reasoning_content and delta.reasoning_content. +# Images: a red PNG data URL returned "Red"; HopBase documents image input (public URL or base64) +# but not video, so input is limited to text and common image types here. +# Structured output: json_schema with strict = true returned an enum-valid object. +# Pricing: HopBase list price, USD; follows the official Volcano Engine list price. +schema = 2 +base_model = "bytedance-seed/seed-2.1-pro" + +[modalities] +input = ["text", "image/jpeg", "image/png", "image/gif", "image/webp"] +output = ["text"] + +[capabilities] +tools = { supported = true, choice = ["auto", "none", "required", "tool"] } +reasoning = { supported = true, effort = ["none", "minimal", "low", "medium", "high", "xhigh", "max"] } +structured_output = true +stream_usage = true + +[limit] +output = 131_072 + +[api.chat-completions] +compatibility = { reasoning_field = "reasoning_content" } + +[cost.text.input] +price = 0.8824 +cache = { read = 0.1765 } + +[cost.text.output] +price = 4.4118 diff --git a/providers/hopbase/models/doubao-seed-2-1-pro-260915.toml b/providers/hopbase/models/doubao-seed-2-1-pro-260915.toml new file mode 100644 index 0000000000..9528619ec0 --- /dev/null +++ b/providers/hopbase/models/doubao-seed-2-1-pro-260915.toml @@ -0,0 +1,37 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Limits: 1M context, up to 256K output (https://hop-base.com/llms.txt); inherited from the lab file. +# tool_choice: ignored by this snapshot (none still called the tool; required/named did not force a +# call), as HopBase documents, so only auto is declared. +# Effort: reasoning_effort = none|minimal|low|medium|high|xhigh|max, all accepted live; none and +# minimal return 0 reasoning tokens, so no separate toggle is declared (thinking.type = disabled is +# also accepted). An unknown value returns HTTP 400. Relative effort was not benchmarked. +# Reasoning text is returned in message.reasoning_content and delta.reasoning_content. +# Images: a red PNG data URL returned "Red"; HopBase documents image input (public URL or base64) +# but not video, so input is limited to text and common image types here. +# Structured output: json_schema with strict = true returned an enum-valid object. +# Also checked through @ai-sdk/openai-compatible 1.0.60 (generateText, streamText, tool round trip). +# Pricing: HopBase list price, USD; follows the official Volcano Engine list price. +schema = 2 +base_model = "bytedance-seed/seed-2.1-pro-0915" + +[modalities] +input = ["text", "image/jpeg", "image/png", "image/gif", "image/webp"] +output = ["text"] + +[capabilities] +tools = { supported = true, choice = ["auto"] } +reasoning = { supported = true, effort = ["none", "minimal", "low", "medium", "high", "xhigh", "max"] } +structured_output = true +stream_usage = true + +[api.chat-completions] +compatibility = { reasoning_field = "reasoning_content" } + +[cost.text.input] +price = 0.8824 +cache = { read = 0.1765 } + +[cost.text.output] +price = 4.4118 diff --git a/providers/hopbase/models/doubao-seed-2-1-turbo-260628.toml b/providers/hopbase/models/doubao-seed-2-1-turbo-260628.toml new file mode 100644 index 0000000000..2519800c9f --- /dev/null +++ b/providers/hopbase/models/doubao-seed-2-1-turbo-260628.toml @@ -0,0 +1,39 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Limits: 256K context, up to 128K output tokens (https://hop-base.com/llms.txt). +# tool_choice: none honoured; required/named returned finish_reason tool_calls without a parsed call +# in this probe, so only auto and none are declared. +# Effort: reasoning_effort = none|minimal|low|medium|high|xhigh|max, all accepted live; none and +# minimal return 0 reasoning tokens, so no separate toggle is declared (thinking.type = disabled is +# also accepted). An unknown value returns HTTP 400. Relative effort was not benchmarked. +# Reasoning text is returned in message.reasoning_content and delta.reasoning_content. +# Images: a red PNG data URL returned "Red"; HopBase documents image input (public URL or base64) +# but not video, so input is limited to text and common image types here. +# Structured output: json_schema with strict = true returned an enum-valid object. +# Pricing: HopBase list price, USD; follows the official Volcano Engine list price. +schema = 2 +base_model = "bytedance-seed/seed-2.1-turbo" + +[modalities] +input = ["text", "image/jpeg", "image/png", "image/gif", "image/webp"] +output = ["text"] + +[capabilities] +tools = { supported = true, choice = ["auto", "none"] } +reasoning = { supported = true, effort = ["none", "minimal", "low", "medium", "high", "xhigh", "max"] } +structured_output = true +stream_usage = true + +[limit] +output = 131_072 + +[api.chat-completions] +compatibility = { reasoning_field = "reasoning_content" } + +[cost.text.input] +price = 0.4412 +cache = { read = 0.0883 } + +[cost.text.output] +price = 2.2059 diff --git a/providers/hopbase/models/doubao-seed-character-260628.toml b/providers/hopbase/models/doubao-seed-character-260628.toml new file mode 100644 index 0000000000..0f31c7c399 --- /dev/null +++ b/providers/hopbase/models/doubao-seed-character-260628.toml @@ -0,0 +1,54 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Limits: 128K context, up to 32K output (https://hop-base.com/llms.txt); max_tokens=32768 -> 200, +# 32769 -> HTTP 400 "expected a value <= 32768". +# tool_choice none|required|named all honoured. +# Toggle: thinking.type = enabled|disabled; thinking is OFF by default (a bare request returned +# 0 reasoning tokens). +# Effort: reasoning_effort = minimal|low|high, paired with thinking.type = enabled. A graded effort +# sent alone returns HTTP 400 "Invalid combination of reasoning_effort and thinking type: low + +# disabled". With thinking enabled: minimal 0, low 1, high 135 reasoning tokens on a short prompt. +# Reasoning text is returned in message.reasoning_content. +# Images: a red PNG data URL returned "Red"; HopBase documents image input (public URL or base64) +# but not video, so input is limited to text and common image types here. +# Structured output: json_schema with strict = true returned an enum-valid object. +# Pricing: HopBase list price, USD; base rates follow the official Volcano Engine list price. +# Tiers follow HopBase billing, not Volcano's table: a single +# long-context tier when input is greater than 32,768 tokens (long_context.threshold = 32768 in +# https://api.hop-base.com/api/v1/models/pricing); no further tier on this host. +schema = 2 +base_model = "bytedance-seed/seed-character" + +[modalities] +input = ["text", "image/jpeg", "image/png", "image/gif", "image/webp"] +output = ["text"] + +[capabilities] +tools = { supported = true, choice = ["auto", "none", "required", "tool"] } +reasoning = { supported = true, toggle = true, effort = ["minimal", "low", "high"] } +structured_output = true +stream_usage = true + +[limit] +context = 131_072 +output = 32_768 + +[api.chat-completions] +compatibility = { reasoning_field = "reasoning_content" } + +[cost.text.input] +price = 0.1177 +cache = { read = 0.0236 } + +[[cost.text.input.overrides]] +when = { context = { gt = 32_768 } } +price = 0.1765 +cache = { read = 0.0236 } + +[cost.text.output] +price = 0.2942 + +[[cost.text.output.overrides]] +when = { context = { gt = 32_768 } } +price = 0.8824 diff --git a/providers/hopbase/models/doubao-seed-evolving.toml b/providers/hopbase/models/doubao-seed-evolving.toml new file mode 100644 index 0000000000..9208712f17 --- /dev/null +++ b/providers/hopbase/models/doubao-seed-evolving.toml @@ -0,0 +1,39 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Limits: 256K context, up to 128K output tokens (https://hop-base.com/llms.txt). +# tool_choice: ignored by this model (none still called the tool; required/named did not force a +# call), as HopBase documents, so only auto is declared. +# Effort: reasoning_effort = none|minimal|low|medium|high|xhigh|max, all accepted live; none and +# minimal return 0 reasoning tokens, so no separate toggle is declared (thinking.type = disabled is +# also accepted). An unknown value returns HTTP 400. Relative effort was not benchmarked. +# Reasoning text is returned in message.reasoning_content and delta.reasoning_content. +# Images: a red PNG data URL returned "Red"; HopBase documents image input (public URL or base64) +# but not video, so input is limited to text and common image types here. +# Structured output: json_schema with strict = true returned an enum-valid object. +# Pricing: HopBase list price, USD; follows the official Volcano Engine list price. +schema = 2 +base_model = "bytedance-seed/seed-evolving" + +[modalities] +input = ["text", "image/jpeg", "image/png", "image/gif", "image/webp"] +output = ["text"] + +[capabilities] +tools = { supported = true, choice = ["auto"] } +reasoning = { supported = true, effort = ["none", "minimal", "low", "medium", "high", "xhigh", "max"] } +structured_output = true +stream_usage = true + +[limit] +output = 131_072 + +[api.chat-completions] +compatibility = { reasoning_field = "reasoning_content" } + +[cost.text.input] +price = 0.8824 +cache = { read = 0.1765 } + +[cost.text.output] +price = 4.4118 diff --git a/providers/hopbase/models/dreamina-seedance-2-5-260628.toml b/providers/hopbase/models/dreamina-seedance-2-5-260628.toml new file mode 100644 index 0000000000..af1c2d2aea --- /dev/null +++ b/providers/hopbase/models/dreamina-seedance-2-5-260628.toml @@ -0,0 +1,34 @@ +# Model ID listed in the public catalog https://hop-base.com/models (category video) and in +# https://api.hop-base.com/api/v1/models/pricing (checked 2026-10-31). No generation was run for +# this listing. +# API: asynchronous task with the Seedance content-array body. POST +# https://api.hop-base.com/v1/video/generate, then poll GET /v1/video/tasks/{task_id} +# (https://hop-base.com/llms.txt, Seedance 2.5 and 2.0). No AI SDK or @opencode/ai package speaks +# this task format, so both are "none". +# Pricing: HopBase price in its public video group, USD per 1M video tokens; requests with a +# reference video bill at the lower input_video rate. +schema = 2 +base_model = "bytedance-seed/seedance-2.5" + +[api.videos] +path = "/video/generate" +sdk = { aisdk = "none", opencodeai = "none" } + +[cost.video.output] +price = 8.56 + +[[cost.video.output.overrides]] +when = { resolution = { equals = "1080p" } } +price = 9.36 + +[[cost.video.output.overrides]] +when = { resolution = { equals = "480p" }, input_video = { equals = true } } +price = 5.12 + +[[cost.video.output.overrides]] +when = { resolution = { equals = "720p" }, input_video = { equals = true } } +price = 5.12 + +[[cost.video.output.overrides]] +when = { resolution = { equals = "1080p" }, input_video = { equals = true } } +price = 5.6 diff --git a/providers/hopbase/models/gemini-3.1-pro-preview.toml b/providers/hopbase/models/gemini-3.1-pro-preview.toml new file mode 100644 index 0000000000..ac434cdffa --- /dev/null +++ b/providers/hopbase/models/gemini-3.1-pro-preview.toml @@ -0,0 +1,41 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Effort: reasoning_effort maps to Gemini thinking on this host: low keeps the model default, +# medium -> thinkingBudget 8192, high -> thinkingBudget 24576. none/minimal are accepted but the +# model still thinks (Gemini 3 cannot switch thinking off), and unknown values fall back to the +# default, so only low|medium|high are declared. Relative effort was not benchmarked. +# Reasoning tokens are reported in usage.completion_tokens_details.reasoning_tokens; no plaintext +# reasoning is returned, so no reasoning_field. +# Images: a red PNG data URL returned "Red". Structured output: json_schema with strict = true +# returned an enum-valid object. +# tool_choice none|required|named all honoured. +# Implicit caching: a repeated ~11K-token prefix returned usage.prompt_tokens_details.cached_tokens +# of about 9.15K from the second call on (2026-11-15). +# Pricing: HopBase self-serve price, USD (https://hop-base.com/pricing, also in https://hop-base.com/llms.txt). Base tier up to 200K input tokens; above 200K, input and cache read x2 and output x1.5 +# (long-context multipliers from https://api.hop-base.com/api/v1/models/pricing). +schema = 2 +base_model = "google/gemini-3.1-pro-preview" + +[capabilities] +tools = { supported = true, choice = ["auto", "none", "required", "tool"] } +reasoning = { supported = true, effort = ["low", "medium", "high"] } +structured_output = true +stream_usage = true +cache = { implicit = { min_tokens = 4_096 } } + +[cost.text.input] +price = 0.9118 +cache = { read = 0.0912 } + +[[cost.text.input.overrides]] +when = { context = { gt = 200_000 } } +price = 1.8236 +cache = { read = 0.1824 } + +[cost.text.output] +price = 5.4706 + +[[cost.text.output.overrides]] +when = { context = { gt = 200_000 } } +price = 8.2059 diff --git a/providers/hopbase/models/gemini-3.8-flash.toml b/providers/hopbase/models/gemini-3.8-flash.toml new file mode 100644 index 0000000000..501f9fe7e9 --- /dev/null +++ b/providers/hopbase/models/gemini-3.8-flash.toml @@ -0,0 +1,32 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Effort: reasoning_effort maps to Gemini thinking on this host: low keeps the model default, +# medium -> thinkingBudget 8192, high -> thinkingBudget 24576. none/minimal are accepted but the +# model still thinks (Gemini 3 cannot switch thinking off), and unknown values fall back to the +# default, so only low|medium|high are declared. Relative effort was not benchmarked. +# Reasoning tokens are reported in usage.completion_tokens_details.reasoning_tokens; no plaintext +# reasoning is returned, so no reasoning_field. +# Images: a red PNG data URL returned "Red". Structured output: json_schema with strict = true +# returned an enum-valid object. +# tool_choice: not honoured in this probe (none still called the tool; required/named did not +# force a call), so only auto is declared. Implicit caching: a repeated ~11K-token +# prefix returned usage.prompt_tokens_details.cached_tokens of about 9.15K from the second or third +# call (2026-11-15); the earlier ~3K-token probe was below Google's 4,096-token minimum. +# Pricing: HopBase self-serve price, USD (https://hop-base.com/pricing, also in https://hop-base.com/llms.txt). +schema = 2 +base_model = "google/gemini-3.8-flash" + +[capabilities] +tools = { supported = true, choice = ["auto"] } +reasoning = { supported = true, effort = ["low", "medium", "high"] } +structured_output = true +stream_usage = true +cache = { implicit = { min_tokens = 4_096 } } + +[cost.text.input] +price = 0.342 +cache = { read = 0.0342 } + +[cost.text.output] +price = 1.7096 diff --git a/providers/hopbase/models/glm-5.3.toml b/providers/hopbase/models/glm-5.3.toml new file mode 100644 index 0000000000..333773fc99 --- /dev/null +++ b/providers/hopbase/models/glm-5.3.toml @@ -0,0 +1,35 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Limits: max_tokens=131072 -> 200, 131073 -> HTTP 400 "限制数值范围[1,131072]" (matches the lab file). +# Text only: an image returns HTTP 400 image_input_not_supported. +# No toggle: thinking.type = disabled is accepted but does not turn thinking off on this host +# (2026-10-31 retest: 182 reasoning tokens and a non-empty reasoning_content), matching the lab file. +# Effort: reasoning_effort = low|high|max, Zhipu's native levels; the host also accepts +# none|minimal|medium|xhigh (error text for an unknown value lists +# "none、minimal、low、medium、high、xhigh、max"). Relative effort was not benchmarked. +# Reasoning text is returned in message.reasoning_content and delta.reasoning_content. +# Structured output: json_schema with strict = true returned an enum-valid object. +# Cache: repeating a ~2.6K-token prefix returned cached_tokens = 2560. +# tool_choice: none honoured; required/named did not force a call, so only auto and none. +# Also checked through @ai-sdk/openai-compatible 1.0.60 (generateText, streamText, tool round trip). +# Pricing: HopBase self-serve price, USD (https://hop-base.com/pricing, also in https://hop-base.com/llms.txt). +schema = 2 +base_model = "zhipuai/glm-5.3" + +[capabilities] +tools = { supported = true, choice = ["auto", "none"] } +reasoning = { supported = true, effort = ["low", "high", "max"] } +structured_output = true +stream_usage = true +cache = { implicit = true } + +[api.chat-completions] +compatibility = { reasoning_field = "reasoning_content" } + +[cost.text.input] +price = 1.19 +cache = { read = 0.221 } + +[cost.text.output] +price = 3.74 diff --git a/providers/hopbase/models/gpt-5.6-sol.toml b/providers/hopbase/models/gpt-5.6-sol.toml new file mode 100644 index 0000000000..51aa0d62ef --- /dev/null +++ b/providers/hopbase/models/gpt-5.6-sol.toml @@ -0,0 +1,41 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Effort: reasoning_effort = none|low|medium|high|xhigh accepted; max returns HTTP 400 "does not +# support 'max' with this model. Supported values are: 'none', 'low', 'medium', 'high', and 'xhigh'". +# No plaintext reasoning is returned on Chat Completions, so no reasoning_field. +# Limits: max_tokens=128000 -> 200, 128001 -> HTTP 400 (matches the lab file). +# Images: a red PNG data URL returned "Red". Structured output: json_schema with strict = true +# returned an enum-valid object. Cache: repeating a ~2.4K-token prefix returned cached_tokens = 2417. +# tool_choice none|required|named all honoured. +# Freeform: with tool_choice=required and the prompt asking for the input 'hello world', a custom +# tool with regex grammar ZZ[0-9]{3} returned "ZZ000" and a lark grammar +# start: "ZZ" DIGIT DIGIT DIGIT returned "ZZ000" (twice each, so the grammar is enforced); a +# custom tool with format type text returned free text. +# Also checked through @ai-sdk/openai-compatible 1.0.60 (generateText, streamText, tool round trip). +# Pricing: HopBase self-serve price, USD (https://hop-base.com/pricing, also in https://hop-base.com/llms.txt). +schema = 2 +base_model = "openai/gpt-5.6-sol" + +[capabilities] +tools = { supported = true, choice = ["auto", "none", "required", "tool"], freeform = ["text", "lark", "regex"] } +reasoning = { supported = true, effort = ["none", "low", "medium", "high", "xhigh"] } +structured_output = true +stream_usage = true +cache = { implicit = true } + +[cost.text.input] +price = 2.6 +cache = { read = 0.26 } + +[[cost.text.input.overrides]] +when = { context = { gt = 272_000 } } +price = 5.2 +cache = { read = 0.52 } + +[cost.text.output] +price = 13 + +[[cost.text.output.overrides]] +when = { context = { gt = 272_000 } } +price = 19.5 diff --git a/providers/hopbase/models/grok-4.20-multi-agent-0309.toml b/providers/hopbase/models/grok-4.20-multi-agent-0309.toml new file mode 100644 index 0000000000..3dab5f6c0e --- /dev/null +++ b/providers/hopbase/models/grok-4.20-multi-agent-0309.toml @@ -0,0 +1,35 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming and streaming (stream_options.include_usage returns usage). HopBase +# accepts Chat Completions for this model. +# Tools: a client-side function tool returns HTTP 400 "Client-side tools for multi-agent models +# require beta access", so tools stay off (inherited from the lab file). +# Effort: reasoning_effort = low|medium|high|xhigh changes how much the agents work (prompt tokens +# 7143/5517/38326/27218 on the same short question, which include the agents' internal context); +# none and unknown values are accepted and run at the default. No plaintext reasoning is returned. +# Cache: cached_tokens = 2560 on repeated requests. +# Pricing: HopBase price in the same public group as grok-4.7, USD (rate per https://hop-base.com/pricing). +# Long-context tier: HopBase applies it when input (including cached) is strictly greater than +# 200,000 tokens, so `gt` rather than xAI's `gte`. +schema = 2 +base_model = "xai/grok-4.20-multi-agent-0309" + +[capabilities] +reasoning = { supported = true, effort = ["low", "medium", "high", "xhigh"] } +stream_usage = true +cache = { implicit = true } + +[cost.text.input] +price = 0.75 +cache = { read = 0.12 } + +[[cost.text.input.overrides]] +when = { context = { gt = 200_000 } } +price = 1.5 +cache = { read = 0.24 } + +[cost.text.output] +price = 1.5 + +[[cost.text.output.overrides]] +when = { context = { gt = 200_000 } } +price = 3.0 diff --git a/providers/hopbase/models/grok-4.7.toml b/providers/hopbase/models/grok-4.7.toml new file mode 100644 index 0000000000..202e6cc6b6 --- /dev/null +++ b/providers/hopbase/models/grok-4.7.toml @@ -0,0 +1,43 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Limits: 500K context (https://hop-base.com/llms.txt), matching the lab file. +# Effort: reasoning_effort = low|medium|high|xhigh accepted (reasoning tokens 51/52/89/99 on a short +# prompt); none returns HTTP 400 "does not support reasoning_effort value none", max and unknown +# values return HTTP 400 "Invalid reasoning effort". Relative effort was not benchmarked. +# Reasoning text is returned in message.reasoning_content and delta.reasoning_content. +# Images: a red PNG data URL returned "Red.". Structured output: json_schema with strict = true +# returned an enum-valid object. Cache: cached_tokens = 1152 on repeated requests. +# tool_choice none|required|named all honoured. +# Also checked through @ai-sdk/openai-compatible 1.0.60 (generateText, streamText, tool round trip). +# Pricing: HopBase self-serve price, USD (https://hop-base.com/pricing, also in https://hop-base.com/llms.txt). +# Long-context tier: HopBase applies it when input (including cached) is strictly greater than +# 200,000 tokens, so `gt` rather than xAI's `gte`. +schema = 2 +base_model = "xai/grok-4.7" + +[capabilities] +tools = { supported = true, choice = ["auto", "none", "required", "tool"] } +reasoning = { supported = true, effort = ["low", "medium", "high", "xhigh"] } +structured_output = true +stream_usage = true +cache = { implicit = true } + +[api.chat-completions] +compatibility = { reasoning_field = "reasoning_content" } + +[cost.text.input] +price = 1.2 +cache = { read = 0.3 } + +[[cost.text.input.overrides]] +when = { context = { gt = 200_000 } } +price = 2.4 +cache = { read = 0.6 } + +[cost.text.output] +price = 3.6 + +[[cost.text.output.overrides]] +when = { context = { gt = 200_000 } } +price = 7.2 diff --git a/providers/hopbase/models/kimi-k3.1-pro.toml b/providers/hopbase/models/kimi-k3.1-pro.toml new file mode 100644 index 0000000000..0ce00d9a1e --- /dev/null +++ b/providers/hopbase/models/kimi-k3.1-pro.toml @@ -0,0 +1,40 @@ +# Verified live 2026-11-17 against https://api.hop-base.com with this exact model ID: +# POST /v1/chat/completions non-streaming and streaming (stream_options.include_usage returns usage), +# POST /v1/responses (streaming, function call + function_call_output round trip) and +# POST /v1/messages (streaming, tool_use + tool_result round trip). +# Limits: 1,048,576-token context; a single 40,000-token output completed normally; max output +# 131,072 tokens per https://hop-base.com/llms.txt. A ~900K-token input retrieved a fact buried at +# 60% depth. +# Images: base64 data URLs only (a red PNG data URL returned "Red"; https image URLs return HTTP 400). +# Reasoning: always on; the trace is returned in message.reasoning_content by default. +# reasoning_effort is accepted and ignored, so no effort levels are declared. +# tool_choice auto|none|required honoured; forcing a named function returns HTTP 400 while thinking. +# Structured output: json_schema with strict = true returned an enum-valid object. +# Cache: repeating a ~25K-token prefix hit ~99% from the second call (prompt_tokens_details.cached_tokens). +# Pricing: HopBase self-serve price, USD (https://hop-base.com/pricing, also in https://hop-base.com/llms.txt). +schema = 2 +base_model = "moonshotai/kimi-k3.1-pro" + +[modalities] +input = ["text", "image/jpeg", "image/png", "image/gif", "image/webp"] +output = ["text"] + +[capabilities] +tools = { supported = true, choice = ["auto", "none", "required"] } +reasoning = { supported = true } +structured_output = true +stream_usage = true +cache = { implicit = true } + +[limit] +output = 131_072 + +[api.chat-completions] +compatibility = { reasoning_field = "reasoning_content" } + +[cost.text.input] +price = 1.1 +cache = { read = 0.11 } + +[cost.text.output] +price = 5.5 diff --git a/providers/hopbase/models/kimi-k3.toml b/providers/hopbase/models/kimi-k3.toml new file mode 100644 index 0000000000..174c40bf85 --- /dev/null +++ b/providers/hopbase/models/kimi-k3.toml @@ -0,0 +1,45 @@ +# Verified live 2026-10-31 against POST https://api.hop-base.com/v1/chat/completions with this exact +# model ID: non-streaming, streaming (stream_options.include_usage returns usage), and a +# tool call (tool_choice auto) that returned a well-formed function call. +# Limits: 1,048,576-token context, max_tokens capped at 32,768 (https://hop-base.com/llms.txt). +# Images: base64 data URLs only (image URLs return HTTP 400, per the same source); a red PNG data +# URL returned "Red". Video input is not offered, so input is limited to text and images here. +# Reasoning: always on (reasoning tokens reported on every request, including with no reasoning +# parameters). HopBase does not apply reasoning_effort on this model: low, high, max, none and an +# invalid value ("banana") all return HTTP 200 (a native endpoint would reject the invalid value), and +# reasoning tokens do not move with the level (two runs each on the same prompt, 2026-10-31: +# low 380/625, high 449/459, max 210/423, omitted 495/506; none still reasons). Thinking cannot be +# turned off and effort is not honoured, so no controls are declared. +# The trace is returned in message.reasoning_content only when the request sets +# include_reasoning = true; without it, only usage.completion_tokens_details.reasoning_tokens. +# Structured output: json_schema with strict = true returned an enum-valid object. +# Cache: repeating a ~2.5K-token prefix returned cached_tokens = 2500. +# tool_choice none|required|named all honoured. +# Also checked through @ai-sdk/openai-compatible 1.0.60 (generateText, streamText, tool round trip). +# Pricing: HopBase self-serve price, USD (https://hop-base.com/pricing, also in https://hop-base.com/llms.txt). +schema = 2 +base_model = "moonshotai/kimi-k3" + +[modalities] +input = ["text", "image/jpeg", "image/png", "image/gif", "image/webp"] +output = ["text"] + +[capabilities] +tools = { supported = true, choice = ["auto", "none", "required", "tool"] } +reasoning = { supported = true } +structured_output = true +stream_usage = true +cache = { implicit = true } + +[limit] +output = 32_768 + +[api.chat-completions] +compatibility = { reasoning_field = "reasoning_content" } + +[cost.text.input] +price = 1.95 +cache = { read = 0.195 } + +[cost.text.output] +price = 9.75 diff --git a/providers/hopbase/models/kling-v4.toml b/providers/hopbase/models/kling-v4.toml new file mode 100644 index 0000000000..478dd74ddc --- /dev/null +++ b/providers/hopbase/models/kling-v4.toml @@ -0,0 +1,23 @@ +# Model ID listed in the public catalog https://hop-base.com/models (category video) and in +# https://api.hop-base.com/api/v1/models/pricing (checked 2026-10-31). No generation was run for +# this listing. +# API: asynchronous task. POST https://api.hop-base.com/v1/video/generate, then poll +# GET /v1/video/tasks/{task_id} (https://hop-base.com/llms.txt, Video Generation). No AI SDK or +# @opencode/ai package speaks this task format, so both are "none". +# Inputs on this host: text prompt and a first-frame image; reference-image mode is not offered. +# Pricing: HopBase price in its public video group, USD per second of output; audio on or off bills the same. +schema = 2 +v2_only = true +base_model = "kuaishou/kling-v4" + +[api.videos] +path = "/video/generate" +sdk = { aisdk = "none", opencodeai = "none" } + +[cost.video.output] +unit = "second" +price = 0.1324 + +[[cost.video.output.overrides]] +when = { resolution = { equals = "1080p" } } +price = 0.1986 diff --git a/providers/hopbase/models/seedream-5-0-pro.toml b/providers/hopbase/models/seedream-5-0-pro.toml new file mode 100644 index 0000000000..359f37bb26 --- /dev/null +++ b/providers/hopbase/models/seedream-5-0-pro.toml @@ -0,0 +1,26 @@ +# Model ID listed in the public catalog https://hop-base.com/models (category image) and in +# https://api.hop-base.com/api/v1/models/pricing (checked 2026-10-31). No generation was run for +# this listing. +# API: synchronous OpenAI-compatible POST https://api.hop-base.com/v1/images/generations +# (optional `image` for image-to-image; up to 10 reference images), plus /v1/images/edits +# (https://hop-base.com/llms.txt, Seedream Image Models). +# Pricing: HopBase price in its public image group, USD per image; output above 2.61 MP bills +# at the higher rate; each reference image bills as image input. +schema = 2 +v2_only = true +base_model = "bytedance-seed/seedream-5.0-pro" + +[api.images] +sdk = { opencodeai = "@opencode/ai/providers/openai-compatible/images" } + +[cost.image.input] +unit = "image" +price = 0.00204 + +[cost.image.output] +unit = "image" +price = 0.0306 + +[[cost.image.output.overrides]] +when = { megapixels = { gt = 2.61 } } +price = 0.0612 diff --git a/providers/hopbase/provider.toml b/providers/hopbase/provider.toml new file mode 100644 index 0000000000..6f5f9bc4ed --- /dev/null +++ b/providers/hopbase/provider.toml @@ -0,0 +1,13 @@ +# OpenAI-compatible Chat Completions: POST https://api.hop-base.com/v1/chat/completions, +# Bearer auth. Model availability is scoped to the API key (GET /v1/models, authenticated); +# public catalog: https://hop-base.com/models +# Reasoning HTTP format (Chat Completions): `reasoning_effort`; DeepSeek and GLM also take +# `thinking.type` = enabled|disabled. Plaintext reasoning, where returned, is in +# `choices[].message.reasoning_content` / `delta.reasoning_content`. +# Machine-readable integration contract: https://hop-base.com/llms.txt +name = "HopBase" +env = ["HOPBASE_API_KEY"] +npm = "@ai-sdk/openai-compatible" +opencodeai = "@opencode/ai/providers/openai-compatible" +api = "https://api.hop-base.com/v1" +doc = "https://hop-base.com/en/docs"