From 755f1fcde5027f135c4a8635fdb6245d130af72e Mon Sep 17 00:00:00 2001 From: Bruno Perez Date: Mon, 20 Jul 2026 11:30:54 +0200 Subject: [PATCH 1/2] feat: add gpt-oss family + thinking-machines/Inkling - add openai/gpt-oss-120b, gpt-oss-20b, gpt-oss-safeguard-120b, gpt-oss-safeguard-20b - add thinking-machines provider with Inkling (Tinker OpenAI-compatible API) - add thinkingLevel toggle to gemma-4-26b-a4b-it and gemma-4-31b-it - commit codegen output --- models/google/gemma-4-26b-a4b-it.yaml | 8 + models/google/gemma-4-31b-it.yaml | 8 + models/openai/gpt-oss-120b.yaml | 56 +++ models/openai/gpt-oss-20b.yaml | 56 +++ models/openai/gpt-oss-safeguard-120b.yaml | 38 ++ models/openai/gpt-oss-safeguard-20b.yaml | 38 ++ models/thinking-machines/Inkling.yaml | 46 +++ packages/modelparams/src/generated/data.ts | 335 ++++++++++++++++++ .../modelparams/src/generated/defaults.ts | 28 ++ .../modelparams/src/generated/model-ids.ts | 6 + .../modelparams/src/generated/params-by-id.ts | 37 ++ 11 files changed, 656 insertions(+) create mode 100644 models/openai/gpt-oss-120b.yaml create mode 100644 models/openai/gpt-oss-20b.yaml create mode 100644 models/openai/gpt-oss-safeguard-120b.yaml create mode 100644 models/openai/gpt-oss-safeguard-20b.yaml create mode 100644 models/thinking-machines/Inkling.yaml diff --git a/models/google/gemma-4-26b-a4b-it.yaml b/models/google/gemma-4-26b-a4b-it.yaml index 16c46fe..1fb64f1 100644 --- a/models/google/gemma-4-26b-a4b-it.yaml +++ b/models/google/gemma-4-26b-a4b-it.yaml @@ -50,6 +50,14 @@ params: description: Number of thinking tokens Gemini should use; -1 uses dynamic thinking, 0 disables thinking, and fixed budgets start at 512 tokens. default: 0 group: reasoning + - path: generationConfig.thinkingConfig.thinkingLevel + type: enum + label: Thinking level + description: Toggles Gemma 4 reasoning; high enables thinking and minimal disables it. + values: + - minimal + - high + group: reasoning - path: generationConfig.thinkingConfig.includeThoughts type: boolean label: Include thoughts diff --git a/models/google/gemma-4-31b-it.yaml b/models/google/gemma-4-31b-it.yaml index 28bee33..1e323c5 100644 --- a/models/google/gemma-4-31b-it.yaml +++ b/models/google/gemma-4-31b-it.yaml @@ -50,6 +50,14 @@ params: description: Number of thinking tokens Gemini should use; -1 uses dynamic thinking, 0 disables thinking, and fixed budgets start at 512 tokens. default: 0 group: reasoning + - path: generationConfig.thinkingConfig.thinkingLevel + type: enum + label: Thinking level + description: Toggles Gemma 4 reasoning; high enables thinking and minimal disables it. + values: + - minimal + - high + group: reasoning - path: generationConfig.thinkingConfig.includeThoughts type: boolean label: Include thoughts diff --git a/models/openai/gpt-oss-120b.yaml b/models/openai/gpt-oss-120b.yaml new file mode 100644 index 0000000..e680b12 --- /dev/null +++ b/models/openai/gpt-oss-120b.yaml @@ -0,0 +1,56 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: openai +authType: api_key +model: gpt-oss-120b +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate. + range: + min: 1 + max: 131072 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. OpenAI recommends sampling at 1.0. + default: 1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. OpenAI recommends sampling at 1.0. + default: 1 + range: + min: 0 + max: 1 + group: sampling + - path: reasoning_effort + type: enum + label: Reasoning effort + description: Controls how much reasoning the model should perform before producing an answer. + default: medium + values: + - low + - medium + - high + group: reasoning + - path: response_format.type + type: enum + label: Response format + description: Controls whether the model returns normal text or a schema-constrained JSON object. + default: text + values: + - text + - json_schema + group: output_format + - path: tool_choice + type: enum + label: Tool choice + description: Controls whether the model may call tools, must call one, or skips tool calls. + values: + - auto + - none + - required + group: tooling diff --git a/models/openai/gpt-oss-20b.yaml b/models/openai/gpt-oss-20b.yaml new file mode 100644 index 0000000..2f9820c --- /dev/null +++ b/models/openai/gpt-oss-20b.yaml @@ -0,0 +1,56 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: openai +authType: api_key +model: gpt-oss-20b +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate. + range: + min: 1 + max: 131072 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. OpenAI recommends sampling at 1.0. + default: 1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. OpenAI recommends sampling at 1.0. + default: 1 + range: + min: 0 + max: 1 + group: sampling + - path: reasoning_effort + type: enum + label: Reasoning effort + description: Controls how much reasoning the model should perform before producing an answer. + default: medium + values: + - low + - medium + - high + group: reasoning + - path: response_format.type + type: enum + label: Response format + description: Controls whether the model returns normal text or a schema-constrained JSON object. + default: text + values: + - text + - json_schema + group: output_format + - path: tool_choice + type: enum + label: Tool choice + description: Controls whether the model may call tools, must call one, or skips tool calls. + values: + - auto + - none + - required + group: tooling diff --git a/models/openai/gpt-oss-safeguard-120b.yaml b/models/openai/gpt-oss-safeguard-120b.yaml new file mode 100644 index 0000000..7446b3c --- /dev/null +++ b/models/openai/gpt-oss-safeguard-120b.yaml @@ -0,0 +1,38 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: openai +authType: api_key +model: gpt-oss-safeguard-120b +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate. + range: + min: 1 + max: 131072 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. OpenAI recommends sampling at 1.0. + default: 1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. OpenAI recommends sampling at 1.0. + default: 1 + range: + min: 0 + max: 1 + group: sampling + - path: reasoning_effort + type: enum + label: Reasoning effort + description: Controls how much reasoning the model performs when interpreting the provided safety policy before returning a classification. + default: medium + values: + - low + - medium + - high + group: reasoning diff --git a/models/openai/gpt-oss-safeguard-20b.yaml b/models/openai/gpt-oss-safeguard-20b.yaml new file mode 100644 index 0000000..ccf7b5d --- /dev/null +++ b/models/openai/gpt-oss-safeguard-20b.yaml @@ -0,0 +1,38 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: openai +authType: api_key +model: gpt-oss-safeguard-20b +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate. + range: + min: 1 + max: 131072 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. OpenAI recommends sampling at 1.0. + default: 1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. OpenAI recommends sampling at 1.0. + default: 1 + range: + min: 0 + max: 1 + group: sampling + - path: reasoning_effort + type: enum + label: Reasoning effort + description: Controls how much reasoning the model performs when interpreting the provided safety policy before returning a classification. + default: medium + values: + - low + - medium + - high + group: reasoning diff --git a/models/thinking-machines/Inkling.yaml b/models/thinking-machines/Inkling.yaml new file mode 100644 index 0000000..787dcaa --- /dev/null +++ b/models/thinking-machines/Inkling.yaml @@ -0,0 +1,46 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: thinking-machines +authType: api_key +model: Inkling +params: + - path: max_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate. + range: + min: 1 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. + default: 1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + default: 1 + range: + min: 0 + max: 1 + group: sampling + - path: reasoning_effort + type: enum + label: Reasoning effort + description: Controls how much thinking Inkling performs before answering. Accepts a preset name or a number between 0.0 and 0.99; presets map to numeric effort levels (none=0.0, minimal=0.1, low=0.2, medium=0.7, high=0.9, xhigh=0.99). + default: high + values: + - none + - minimal + - low + - medium + - high + - xhigh + group: reasoning + - path: separate_reasoning + type: boolean + label: Separate reasoning + description: Returns the model's reasoning in a dedicated reasoning_content field instead of interleaving it with the final message content. + default: true + group: reasoning diff --git a/packages/modelparams/src/generated/data.ts b/packages/modelparams/src/generated/data.ts index 96c83e5..ad50dfc 100644 --- a/packages/modelparams/src/generated/data.ts +++ b/packages/modelparams/src/generated/data.ts @@ -7437,6 +7437,17 @@ export const CATALOG = [ "type": "integer", "default": 0 }, + { + "path": "generationConfig.thinkingConfig.thinkingLevel", + "label": "Thinking level", + "description": "Toggles Gemma 4 reasoning; high enables thinking and minimal disables it.", + "group": "reasoning", + "type": "enum", + "values": [ + "minimal", + "high" + ] + }, { "path": "generationConfig.thinkingConfig.includeThoughts", "label": "Include thoughts", @@ -7527,6 +7538,17 @@ export const CATALOG = [ "type": "integer", "default": 0 }, + { + "path": "generationConfig.thinkingConfig.thinkingLevel", + "label": "Thinking level", + "description": "Toggles Gemma 4 reasoning; high enables thinking and minimal disables it.", + "group": "reasoning", + "type": "enum", + "values": [ + "minimal", + "high" + ] + }, { "path": "generationConfig.thinkingConfig.includeThoughts", "label": "Include thoughts", @@ -13133,6 +13155,258 @@ export const CATALOG = [ } ] }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-oss-120b", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1, + "max": 131072 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. OpenAI recommends sampling at 1.0.", + "group": "sampling", + "type": "number", + "default": 1 + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. OpenAI recommends sampling at 1.0.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning the model should perform before producing an answer.", + "group": "reasoning", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or a schema-constrained JSON object.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_schema" + ] + }, + { + "path": "tool_choice", + "label": "Tool choice", + "description": "Controls whether the model may call tools, must call one, or skips tool calls.", + "group": "tooling", + "type": "enum", + "values": [ + "auto", + "none", + "required" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-oss-20b", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1, + "max": 131072 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. OpenAI recommends sampling at 1.0.", + "group": "sampling", + "type": "number", + "default": 1 + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. OpenAI recommends sampling at 1.0.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning the model should perform before producing an answer.", + "group": "reasoning", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or a schema-constrained JSON object.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_schema" + ] + }, + { + "path": "tool_choice", + "label": "Tool choice", + "description": "Controls whether the model may call tools, must call one, or skips tool calls.", + "group": "tooling", + "type": "enum", + "values": [ + "auto", + "none", + "required" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-oss-safeguard-120b", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1, + "max": 131072 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. OpenAI recommends sampling at 1.0.", + "group": "sampling", + "type": "number", + "default": 1 + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. OpenAI recommends sampling at 1.0.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning the model performs when interpreting the provided safety policy before returning a classification.", + "group": "reasoning", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-oss-safeguard-20b", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1, + "max": 131072 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. OpenAI recommends sampling at 1.0.", + "group": "sampling", + "type": "number", + "default": 1 + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. OpenAI recommends sampling at 1.0.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning the model performs when interpreting the provided safety policy before returning a classification.", + "group": "reasoning", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, { "provider": "openai", "authType": "api_key", @@ -13866,6 +14140,67 @@ export const CATALOG = [ } ] }, + { + "provider": "thinking-machines", + "authType": "api_key", + "model": "Inkling", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 1 + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much thinking Inkling performs before answering. Accepts a preset name or a number between 0.0 and 0.99; presets map to numeric effort levels (none=0.0, minimal=0.1, low=0.2, medium=0.7, high=0.9, xhigh=0.99).", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "none", + "minimal", + "low", + "medium", + "high", + "xhigh" + ] + }, + { + "path": "separate_reasoning", + "label": "Separate reasoning", + "description": "Returns the model's reasoning in a dedicated reasoning_content field instead of interleaving it with the final message content.", + "group": "reasoning", + "type": "boolean", + "default": true + } + ] + }, { "provider": "xai", "authType": "api_key", diff --git a/packages/modelparams/src/generated/defaults.ts b/packages/modelparams/src/generated/defaults.ts index a3bb2df..deeaa3e 100644 --- a/packages/modelparams/src/generated/defaults.ts +++ b/packages/modelparams/src/generated/defaults.ts @@ -1059,6 +1059,28 @@ export const DEFAULTS = { "reasoning.summary": "auto", "text.verbosity": "medium", }, + "openai/gpt-oss-120b": { + temperature: 1, + top_p: 1, + reasoning_effort: "medium", + "response_format.type": "text", + }, + "openai/gpt-oss-20b": { + temperature: 1, + top_p: 1, + reasoning_effort: "medium", + "response_format.type": "text", + }, + "openai/gpt-oss-safeguard-120b": { + temperature: 1, + top_p: 1, + reasoning_effort: "medium", + }, + "openai/gpt-oss-safeguard-20b": { + temperature: 1, + top_p: 1, + reasoning_effort: "medium", + }, "openai/o1": { max_completion_tokens: 4096, reasoning_effort: "medium", @@ -1110,6 +1132,12 @@ export const DEFAULTS = { return_related_questions: false, disable_search: false, }, + "thinking-machines/Inkling": { + temperature: 1, + top_p: 1, + reasoning_effort: "high", + separate_reasoning: true, + }, "xai/grok-4.20-0309-non-reasoning": { temperature: 1, top_p: 1, diff --git a/packages/modelparams/src/generated/model-ids.ts b/packages/modelparams/src/generated/model-ids.ts index 99530ee..4fa6f24 100644 --- a/packages/modelparams/src/generated/model-ids.ts +++ b/packages/modelparams/src/generated/model-ids.ts @@ -173,6 +173,10 @@ export const MODEL_IDS = [ "openai/gpt-5.6-sol-subscription", "openai/gpt-5.6-terra", "openai/gpt-5.6-terra-subscription", + "openai/gpt-oss-120b", + "openai/gpt-oss-20b", + "openai/gpt-oss-safeguard-120b", + "openai/gpt-oss-safeguard-20b", "openai/o1", "openai/o1-mini", "openai/o1-preview", @@ -184,6 +188,7 @@ export const MODEL_IDS = [ "perplexity/sonar-deep-research", "perplexity/sonar-pro", "perplexity/sonar-reasoning-pro", + "thinking-machines/Inkling", "xai/grok-4.20-0309-non-reasoning", "xai/grok-4.20-0309-non-reasoning-subscription", "xai/grok-4.20-0309-reasoning", @@ -234,6 +239,7 @@ export const PROVIDERS = [ "nvidia", "openai", "perplexity", + "thinking-machines", "xai", "xiaomi", "z-ai" diff --git a/packages/modelparams/src/generated/params-by-id.ts b/packages/modelparams/src/generated/params-by-id.ts index 651d6d4..c7c3456 100644 --- a/packages/modelparams/src/generated/params-by-id.ts +++ b/packages/modelparams/src/generated/params-by-id.ts @@ -633,6 +633,7 @@ export type ParamsById = { "generationConfig.topK": number; "generationConfig.seed": number; "generationConfig.thinkingConfig.thinkingBudget": number; + "generationConfig.thinkingConfig.thinkingLevel": "minimal" | "high"; "generationConfig.thinkingConfig.includeThoughts": boolean; "generationConfig.responseMimeType": "text/plain" | "application/json"; }; @@ -643,6 +644,7 @@ export type ParamsById = { "generationConfig.topK": number; "generationConfig.seed": number; "generationConfig.thinkingConfig.thinkingBudget": number; + "generationConfig.thinkingConfig.thinkingLevel": "minimal" | "high"; "generationConfig.thinkingConfig.includeThoughts": boolean; "generationConfig.responseMimeType": "text/plain" | "application/json"; }; @@ -1269,6 +1271,34 @@ export type ParamsById = { "reasoning.summary": "auto" | "concise" | "detailed"; "text.verbosity": "low" | "medium" | "high"; }; + "openai/gpt-oss-120b": { + max_completion_tokens: number; + temperature: number; + top_p: number; + reasoning_effort: "low" | "medium" | "high"; + "response_format.type": "text" | "json_schema"; + tool_choice: "auto" | "none" | "required"; + }; + "openai/gpt-oss-20b": { + max_completion_tokens: number; + temperature: number; + top_p: number; + reasoning_effort: "low" | "medium" | "high"; + "response_format.type": "text" | "json_schema"; + tool_choice: "auto" | "none" | "required"; + }; + "openai/gpt-oss-safeguard-120b": { + max_completion_tokens: number; + temperature: number; + top_p: number; + reasoning_effort: "low" | "medium" | "high"; + }; + "openai/gpt-oss-safeguard-20b": { + max_completion_tokens: number; + temperature: number; + top_p: number; + reasoning_effort: "low" | "medium" | "high"; + }; "openai/o1": { max_completion_tokens: number; reasoning_effort: "low" | "medium" | "high" | "xhigh"; @@ -1353,6 +1383,13 @@ export type ParamsById = { return_related_questions: boolean; disable_search: boolean; }; + "thinking-machines/Inkling": { + max_tokens: number; + temperature: number; + top_p: number; + reasoning_effort: "none" | "minimal" | "low" | "medium" | "high" | "xhigh"; + separate_reasoning: boolean; + }; "xai/grok-4.20-0309-non-reasoning": { max_completion_tokens: number; temperature: number; From abcb0b71947f3f3c8ffc13dfe2b27468a9eb1500 Mon Sep 17 00:00:00 2001 From: Bruno Perez Date: Mon, 20 Jul 2026 12:21:06 +0200 Subject: [PATCH 2/2] feat: add Gemma open weights + GLM-5.2, Qwen 3.7, Kimi K2.7 Code - add gemma-3 (27b/12b/4b/1b), gemma-3n (E4B/E2B), gemma-4 (12B/E4B/E2B) as local open-weight entries - add z-ai/glm-5.2 (api + subscription) with the new reasoning_effort enum - add alibaba/qwen3.7-max, qwen3.7-plus, qwen3.6-flash - add moonshot/kimi-k2.7-code and kimi-k2.7-code-highspeed - add google/gemini-3.1-flash-lite api entry; fix subscription thinking default to minimal - add GLM-5.2 display label and codegen output --- models/alibaba/qwen3.6-flash.yaml | 54 + models/alibaba/qwen3.7-max.yaml | 54 + models/alibaba/qwen3.7-plus.yaml | 54 + .../gemini-3.1-flash-lite-subscription.yaml | 2 +- models/google/gemini-3.1-flash-lite.yaml | 72 ++ models/google/gemma-3-12b-it.yaml | 36 + models/google/gemma-3-1b-it.yaml | 36 + models/google/gemma-3-27b-it.yaml | 36 + models/google/gemma-3-4b-it.yaml | 36 + models/google/gemma-3n-E2B-it.yaml | 36 + models/google/gemma-3n-E4B-it.yaml | 36 + models/google/gemma-4-12B-it.yaml | 35 + models/google/gemma-4-E2B-it.yaml | 35 + models/google/gemma-4-E4B-it.yaml | 35 + models/moonshot/kimi-k2.7-code-highspeed.yaml | 23 + models/moonshot/kimi-k2.7-code.yaml | 23 + models/z-ai/glm-5.2-subscription.yaml | 81 ++ models/z-ai/glm-5.2.yaml | 81 ++ packages/modelparams/src/generated/data.ts | 1127 ++++++++++++++++- .../modelparams/src/generated/defaults.ts | 93 +- .../modelparams/src/generated/model-ids.ts | 19 +- .../modelparams/src/generated/params-by-id.ts | 114 ++ src/data/display.ts | 1 + 23 files changed, 2072 insertions(+), 47 deletions(-) create mode 100644 models/alibaba/qwen3.6-flash.yaml create mode 100644 models/alibaba/qwen3.7-max.yaml create mode 100644 models/alibaba/qwen3.7-plus.yaml create mode 100644 models/google/gemini-3.1-flash-lite.yaml create mode 100644 models/google/gemma-3-12b-it.yaml create mode 100644 models/google/gemma-3-1b-it.yaml create mode 100644 models/google/gemma-3-27b-it.yaml create mode 100644 models/google/gemma-3-4b-it.yaml create mode 100644 models/google/gemma-3n-E2B-it.yaml create mode 100644 models/google/gemma-3n-E4B-it.yaml create mode 100644 models/google/gemma-4-12B-it.yaml create mode 100644 models/google/gemma-4-E2B-it.yaml create mode 100644 models/google/gemma-4-E4B-it.yaml create mode 100644 models/moonshot/kimi-k2.7-code-highspeed.yaml create mode 100644 models/moonshot/kimi-k2.7-code.yaml create mode 100644 models/z-ai/glm-5.2-subscription.yaml create mode 100644 models/z-ai/glm-5.2.yaml diff --git a/models/alibaba/qwen3.6-flash.yaml b/models/alibaba/qwen3.6-flash.yaml new file mode 100644 index 0000000..ee76c5d --- /dev/null +++ b/models/alibaba/qwen3.6-flash.yaml @@ -0,0 +1,54 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: alibaba +authType: api_key +model: qwen3.6-flash +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of tokens to generate, including both reasoning and the final answer. + range: + min: 1 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. + range: + min: 0 + max: 2 + step: 0.1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + range: + min: 0 + max: 1 + step: 0.01 + group: sampling + - path: extra_body.top_k + type: integer + label: Top K + description: Limits generation to the selected number of highest-probability tokens. Values above 100 disable top-k sampling. + default: 20 + range: + min: 0 + group: sampling + - path: extra_body.enable_thinking + type: boolean + label: Enable thinking + description: Toggles the model's hybrid thinking mode, sent as a provider-specific extra body field on OpenAI-compatible clients. + default: true + group: reasoning + - path: extra_body.thinking_budget + type: integer + label: Thinking budget + description: Maximum number of tokens the model may spend on reasoning before it starts the final answer; defaults to the model's maximum reasoning length. + range: + min: 1 + group: reasoning + applicability: + only: + extra_body.enable_thinking: true diff --git a/models/alibaba/qwen3.7-max.yaml b/models/alibaba/qwen3.7-max.yaml new file mode 100644 index 0000000..3fa1777 --- /dev/null +++ b/models/alibaba/qwen3.7-max.yaml @@ -0,0 +1,54 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: alibaba +authType: api_key +model: qwen3.7-max +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of tokens to generate, including both reasoning and the final answer. + range: + min: 1 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. + range: + min: 0 + max: 2 + step: 0.1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + range: + min: 0 + max: 1 + step: 0.01 + group: sampling + - path: extra_body.top_k + type: integer + label: Top K + description: Limits generation to the selected number of highest-probability tokens. Values above 100 disable top-k sampling. + default: 20 + range: + min: 0 + group: sampling + - path: extra_body.enable_thinking + type: boolean + label: Enable thinking + description: Toggles the model's hybrid thinking mode, sent as a provider-specific extra body field on OpenAI-compatible clients. + default: true + group: reasoning + - path: extra_body.thinking_budget + type: integer + label: Thinking budget + description: Maximum number of tokens the model may spend on reasoning before it starts the final answer; defaults to the model's maximum reasoning length. + range: + min: 1 + group: reasoning + applicability: + only: + extra_body.enable_thinking: true diff --git a/models/alibaba/qwen3.7-plus.yaml b/models/alibaba/qwen3.7-plus.yaml new file mode 100644 index 0000000..0500128 --- /dev/null +++ b/models/alibaba/qwen3.7-plus.yaml @@ -0,0 +1,54 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: alibaba +authType: api_key +model: qwen3.7-plus +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of tokens to generate, including both reasoning and the final answer. + range: + min: 1 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. + range: + min: 0 + max: 2 + step: 0.1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + range: + min: 0 + max: 1 + step: 0.01 + group: sampling + - path: extra_body.top_k + type: integer + label: Top K + description: Limits generation to the selected number of highest-probability tokens. Values above 100 disable top-k sampling. + default: 20 + range: + min: 0 + group: sampling + - path: extra_body.enable_thinking + type: boolean + label: Enable thinking + description: Toggles the model's hybrid thinking mode, sent as a provider-specific extra body field on OpenAI-compatible clients. + default: true + group: reasoning + - path: extra_body.thinking_budget + type: integer + label: Thinking budget + description: Maximum number of tokens the model may spend on reasoning before it starts the final answer; defaults to the model's maximum reasoning length. + range: + min: 1 + group: reasoning + applicability: + only: + extra_body.enable_thinking: true diff --git a/models/google/gemini-3.1-flash-lite-subscription.yaml b/models/google/gemini-3.1-flash-lite-subscription.yaml index fafc168..bde86b7 100644 --- a/models/google/gemini-3.1-flash-lite-subscription.yaml +++ b/models/google/gemini-3.1-flash-lite-subscription.yaml @@ -48,7 +48,7 @@ params: type: enum label: Thinking level description: Controls Gemini 3.1 Flash-Lite reasoning effort. - default: high + default: minimal values: - minimal - low diff --git a/models/google/gemini-3.1-flash-lite.yaml b/models/google/gemini-3.1-flash-lite.yaml new file mode 100644 index 0000000..318a8a9 --- /dev/null +++ b/models/google/gemini-3.1-flash-lite.yaml @@ -0,0 +1,72 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: google +authType: api_key +model: gemini-3.1-flash-lite +params: + - path: generationConfig.maxOutputTokens + type: integer + label: Max output tokens + description: Maximum number of tokens to include in a response candidate. + range: + min: 1 + max: 65536 + group: generation_length + - path: generationConfig.temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. + default: 1 + range: + min: 0 + max: 2 + step: 0.1 + group: sampling + - path: generationConfig.topP + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + default: 0.95 + range: + min: 0 + max: 1 + step: 0.01 + group: sampling + - path: generationConfig.topK + type: integer + label: Top K + description: Limits token sampling to the top K most likely next tokens. + default: 64 + range: + min: 0 + group: sampling + - path: generationConfig.seed + type: integer + label: Seed + description: Optional seed used for decoding when reproducible sampling is desired. + group: sampling + - path: generationConfig.thinkingConfig.thinkingLevel + type: enum + label: Thinking level + description: Controls Gemini 3.1 Flash-Lite reasoning effort. + default: minimal + values: + - minimal + - low + - medium + - high + group: reasoning + - path: generationConfig.thinkingConfig.includeThoughts + type: boolean + label: Include thoughts + description: Controls whether Gemini returns available thought summaries in the response parts. + default: false + group: reasoning + - path: generationConfig.responseMimeType + type: enum + label: Response MIME type + description: MIME type for generated text candidates. + default: text/plain + values: + - text/plain + - application/json + group: output_format diff --git a/models/google/gemma-3-12b-it.yaml b/models/google/gemma-3-12b-it.yaml new file mode 100644 index 0000000..f3b51c0 --- /dev/null +++ b/models/google/gemma-3-12b-it.yaml @@ -0,0 +1,36 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: google +authType: api_key +model: gemma-3-12b-it +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate; output shares the 128K context window with the input. + range: + min: 1 + max: 131072 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. + default: 1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + default: 0.95 + range: + min: 0 + max: 1 + group: sampling + - path: top_k + type: integer + label: Top K + description: Limits generation to the selected number of highest-probability tokens. + default: 64 + range: + min: 0 + group: sampling diff --git a/models/google/gemma-3-1b-it.yaml b/models/google/gemma-3-1b-it.yaml new file mode 100644 index 0000000..dab9b28 --- /dev/null +++ b/models/google/gemma-3-1b-it.yaml @@ -0,0 +1,36 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: google +authType: api_key +model: gemma-3-1b-it +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate; output shares the 32K context window with the input. + range: + min: 1 + max: 32768 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. + default: 1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + default: 0.95 + range: + min: 0 + max: 1 + group: sampling + - path: top_k + type: integer + label: Top K + description: Limits generation to the selected number of highest-probability tokens. + default: 64 + range: + min: 0 + group: sampling diff --git a/models/google/gemma-3-27b-it.yaml b/models/google/gemma-3-27b-it.yaml new file mode 100644 index 0000000..5e6557a --- /dev/null +++ b/models/google/gemma-3-27b-it.yaml @@ -0,0 +1,36 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: google +authType: api_key +model: gemma-3-27b-it +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate; output shares the 128K context window with the input. + range: + min: 1 + max: 131072 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. + default: 1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + default: 0.95 + range: + min: 0 + max: 1 + group: sampling + - path: top_k + type: integer + label: Top K + description: Limits generation to the selected number of highest-probability tokens. + default: 64 + range: + min: 0 + group: sampling diff --git a/models/google/gemma-3-4b-it.yaml b/models/google/gemma-3-4b-it.yaml new file mode 100644 index 0000000..c8cd5f9 --- /dev/null +++ b/models/google/gemma-3-4b-it.yaml @@ -0,0 +1,36 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: google +authType: api_key +model: gemma-3-4b-it +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate; output shares the 128K context window with the input. + range: + min: 1 + max: 131072 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. + default: 1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + default: 0.95 + range: + min: 0 + max: 1 + group: sampling + - path: top_k + type: integer + label: Top K + description: Limits generation to the selected number of highest-probability tokens. + default: 64 + range: + min: 0 + group: sampling diff --git a/models/google/gemma-3n-E2B-it.yaml b/models/google/gemma-3n-E2B-it.yaml new file mode 100644 index 0000000..26cf098 --- /dev/null +++ b/models/google/gemma-3n-E2B-it.yaml @@ -0,0 +1,36 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: google +authType: api_key +model: gemma-3n-E2B-it +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate; output shares the 32K context window with the input. + range: + min: 1 + max: 32768 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. + default: 1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + default: 0.95 + range: + min: 0 + max: 1 + group: sampling + - path: top_k + type: integer + label: Top K + description: Limits generation to the selected number of highest-probability tokens. + default: 64 + range: + min: 0 + group: sampling diff --git a/models/google/gemma-3n-E4B-it.yaml b/models/google/gemma-3n-E4B-it.yaml new file mode 100644 index 0000000..6ac0cb3 --- /dev/null +++ b/models/google/gemma-3n-E4B-it.yaml @@ -0,0 +1,36 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: google +authType: api_key +model: gemma-3n-E4B-it +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate; output shares the 32K context window with the input. + range: + min: 1 + max: 32768 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. + default: 1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + default: 0.95 + range: + min: 0 + max: 1 + group: sampling + - path: top_k + type: integer + label: Top K + description: Limits generation to the selected number of highest-probability tokens. + default: 64 + range: + min: 0 + group: sampling diff --git a/models/google/gemma-4-12B-it.yaml b/models/google/gemma-4-12B-it.yaml new file mode 100644 index 0000000..abd00f6 --- /dev/null +++ b/models/google/gemma-4-12B-it.yaml @@ -0,0 +1,35 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: google +authType: api_key +model: gemma-4-12B-it +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate. + range: + min: 1 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. Google's standardized Gemma 4 sampling uses 1.0. + default: 1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + default: 0.95 + range: + min: 0 + max: 1 + group: sampling + - path: top_k + type: integer + label: Top K + description: Limits generation to the selected number of highest-probability tokens. + default: 64 + range: + min: 0 + group: sampling diff --git a/models/google/gemma-4-E2B-it.yaml b/models/google/gemma-4-E2B-it.yaml new file mode 100644 index 0000000..b99e1aa --- /dev/null +++ b/models/google/gemma-4-E2B-it.yaml @@ -0,0 +1,35 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: google +authType: api_key +model: gemma-4-E2B-it +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate. + range: + min: 1 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. Google's standardized Gemma 4 sampling uses 1.0. + default: 1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + default: 0.95 + range: + min: 0 + max: 1 + group: sampling + - path: top_k + type: integer + label: Top K + description: Limits generation to the selected number of highest-probability tokens. + default: 64 + range: + min: 0 + group: sampling diff --git a/models/google/gemma-4-E4B-it.yaml b/models/google/gemma-4-E4B-it.yaml new file mode 100644 index 0000000..b3642e7 --- /dev/null +++ b/models/google/gemma-4-E4B-it.yaml @@ -0,0 +1,35 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: google +authType: api_key +model: gemma-4-E4B-it +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate. + range: + min: 1 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. Google's standardized Gemma 4 sampling uses 1.0. + default: 1 + group: sampling + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + default: 0.95 + range: + min: 0 + max: 1 + group: sampling + - path: top_k + type: integer + label: Top K + description: Limits generation to the selected number of highest-probability tokens. + default: 64 + range: + min: 0 + group: sampling diff --git a/models/moonshot/kimi-k2.7-code-highspeed.yaml b/models/moonshot/kimi-k2.7-code-highspeed.yaml new file mode 100644 index 0000000..accdd06 --- /dev/null +++ b/models/moonshot/kimi-k2.7-code-highspeed.yaml @@ -0,0 +1,23 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: moonshot +authType: api_key +model: kimi-k2.7-code-highspeed +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of tokens to generate in the chat completion, including reasoning tokens. + default: 32768 + range: + min: 1 + group: generation_length + - path: response_format.type + type: enum + label: Response format + description: Forces the response into plain text, a JSON object, or JSON matching a provided schema. + default: text + values: + - text + - json_object + - json_schema + group: output_format diff --git a/models/moonshot/kimi-k2.7-code.yaml b/models/moonshot/kimi-k2.7-code.yaml new file mode 100644 index 0000000..9966876 --- /dev/null +++ b/models/moonshot/kimi-k2.7-code.yaml @@ -0,0 +1,23 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: moonshot +authType: api_key +model: kimi-k2.7-code +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of tokens to generate in the chat completion, including reasoning tokens. + default: 32768 + range: + min: 1 + group: generation_length + - path: response_format.type + type: enum + label: Response format + description: Forces the response into plain text, a JSON object, or JSON matching a provided schema. + default: text + values: + - text + - json_object + - json_schema + group: output_format diff --git a/models/z-ai/glm-5.2-subscription.yaml b/models/z-ai/glm-5.2-subscription.yaml new file mode 100644 index 0000000..907bfe5 --- /dev/null +++ b/models/z-ai/glm-5.2-subscription.yaml @@ -0,0 +1,81 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: z-ai +authType: subscription +model: glm-5.2 +params: + - path: max_tokens + type: integer + label: Max tokens + description: Maximum number of tokens to generate in the response. + default: 65536 + range: + min: 1 + max: 131072 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. + default: 1 + range: + min: 0 + max: 1 + step: 0.1 + group: sampling + applicability: + except: + do_sample: false + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + default: 0.95 + range: + min: 0.01 + max: 1 + step: 0.01 + group: sampling + applicability: + except: + do_sample: false + - path: do_sample + type: boolean + label: Do sample + description: When false, the model uses greedy decoding and ignores temperature and top_p. + default: true + group: sampling + - path: thinking.type + type: enum + label: Thinking mode + description: Toggles the model's extended reasoning before it produces the final answer. + default: enabled + values: + - enabled + - disabled + group: reasoning + - path: reasoning_effort + type: enum + label: Reasoning effort + description: Controls how much reasoning effort GLM-5.2 spends when thinking is enabled. + default: max + values: + - none + - minimal + - low + - medium + - high + - xhigh + - max + group: reasoning + applicability: + only: + thinking.type: enabled + - path: response_format.type + type: enum + label: Response format + description: Forces the response into plain text or a JSON object. + default: text + values: + - text + - json_object + group: output_format diff --git a/models/z-ai/glm-5.2.yaml b/models/z-ai/glm-5.2.yaml new file mode 100644 index 0000000..fd34751 --- /dev/null +++ b/models/z-ai/glm-5.2.yaml @@ -0,0 +1,81 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: z-ai +authType: api_key +model: glm-5.2 +params: + - path: max_tokens + type: integer + label: Max tokens + description: Maximum number of tokens to generate in the response. + default: 65536 + range: + min: 1 + max: 131072 + group: generation_length + - path: temperature + type: number + label: Temperature + description: Controls randomness. Lower values make outputs more focused; higher values make them more varied. + default: 1 + range: + min: 0 + max: 1 + step: 0.1 + group: sampling + applicability: + except: + do_sample: false + - path: top_p + type: number + label: Top P + description: Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. + default: 0.95 + range: + min: 0.01 + max: 1 + step: 0.01 + group: sampling + applicability: + except: + do_sample: false + - path: do_sample + type: boolean + label: Do sample + description: When false, the model uses greedy decoding and ignores temperature and top_p. + default: true + group: sampling + - path: thinking.type + type: enum + label: Thinking mode + description: Toggles the model's extended reasoning before it produces the final answer. + default: enabled + values: + - enabled + - disabled + group: reasoning + - path: reasoning_effort + type: enum + label: Reasoning effort + description: Controls how much reasoning effort GLM-5.2 spends when thinking is enabled. + default: max + values: + - none + - minimal + - low + - medium + - high + - xhigh + - max + group: reasoning + applicability: + only: + thinking.type: enabled + - path: response_format.type + type: enum + label: Response format + description: Forces the response into plain text or a JSON object. + default: text + values: + - text + - json_object + group: output_format diff --git a/packages/modelparams/src/generated/data.ts b/packages/modelparams/src/generated/data.ts index ad50dfc..21b9c99 100644 --- a/packages/modelparams/src/generated/data.ts +++ b/packages/modelparams/src/generated/data.ts @@ -408,6 +408,231 @@ export const CATALOG = [ } ] }, + { + "provider": "alibaba", + "authType": "api_key", + "model": "qwen3.6-flash", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate, including both reasoning and the final answer.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "extra_body.top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens. Values above 100 disable top-k sampling.", + "group": "sampling", + "type": "integer", + "default": 20, + "range": { + "min": 0 + } + }, + { + "path": "extra_body.enable_thinking", + "label": "Enable thinking", + "description": "Toggles the model's hybrid thinking mode, sent as a provider-specific extra body field on OpenAI-compatible clients.", + "group": "reasoning", + "type": "boolean", + "default": true + }, + { + "path": "extra_body.thinking_budget", + "label": "Thinking budget", + "description": "Maximum number of tokens the model may spend on reasoning before it starts the final answer; defaults to the model's maximum reasoning length.", + "group": "reasoning", + "applicability": { + "only": { + "extra_body.enable_thinking": true + } + }, + "type": "integer", + "range": { + "min": 1 + } + } + ] + }, + { + "provider": "alibaba", + "authType": "api_key", + "model": "qwen3.7-max", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate, including both reasoning and the final answer.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "extra_body.top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens. Values above 100 disable top-k sampling.", + "group": "sampling", + "type": "integer", + "default": 20, + "range": { + "min": 0 + } + }, + { + "path": "extra_body.enable_thinking", + "label": "Enable thinking", + "description": "Toggles the model's hybrid thinking mode, sent as a provider-specific extra body field on OpenAI-compatible clients.", + "group": "reasoning", + "type": "boolean", + "default": true + }, + { + "path": "extra_body.thinking_budget", + "label": "Thinking budget", + "description": "Maximum number of tokens the model may spend on reasoning before it starts the final answer; defaults to the model's maximum reasoning length.", + "group": "reasoning", + "applicability": { + "only": { + "extra_body.enable_thinking": true + } + }, + "type": "integer", + "range": { + "min": 1 + } + } + ] + }, + { + "provider": "alibaba", + "authType": "api_key", + "model": "qwen3.7-plus", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate, including both reasoning and the final answer.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "extra_body.top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens. Values above 100 disable top-k sampling.", + "group": "sampling", + "type": "integer", + "default": 20, + "range": { + "min": 0 + } + }, + { + "path": "extra_body.enable_thinking", + "label": "Enable thinking", + "description": "Toggles the model's hybrid thinking mode, sent as a provider-specific extra body field on OpenAI-compatible clients.", + "group": "reasoning", + "type": "boolean", + "default": true + }, + { + "path": "extra_body.thinking_budget", + "label": "Thinking budget", + "description": "Maximum number of tokens the model may spend on reasoning before it starts the final answer; defaults to the model's maximum reasoning length.", + "group": "reasoning", + "applicability": { + "only": { + "extra_body.enable_thinking": true + } + }, + "type": "integer", + "range": { + "min": 1 + } + } + ] + }, { "provider": "alibaba", "authType": "api_key", @@ -6899,8 +7124,8 @@ export const CATALOG = [ }, { "provider": "google", - "authType": "subscription", - "model": "gemini-3.1-flash-lite-preview", + "authType": "api_key", + "model": "gemini-3.1-flash-lite", "params": [ { "path": "generationConfig.maxOutputTokens", @@ -6963,7 +7188,7 @@ export const CATALOG = [ "description": "Controls Gemini 3.1 Flash-Lite reasoning effort.", "group": "reasoning", "type": "enum", - "default": "high", + "default": "minimal", "values": [ "minimal", "low", @@ -6996,7 +7221,7 @@ export const CATALOG = [ { "provider": "google", "authType": "subscription", - "model": "gemini-3.1-flash-lite", + "model": "gemini-3.1-flash-lite-preview", "params": [ { "path": "generationConfig.maxOutputTokens", @@ -7092,7 +7317,7 @@ export const CATALOG = [ { "provider": "google", "authType": "subscription", - "model": "gemini-3.1-pro-preview", + "model": "gemini-3.1-flash-lite", "params": [ { "path": "generationConfig.maxOutputTokens", @@ -7152,12 +7377,14 @@ export const CATALOG = [ { "path": "generationConfig.thinkingConfig.thinkingLevel", "label": "Thinking level", - "description": "Controls Gemini 3 Pro reasoning effort.", + "description": "Controls Gemini 3.1 Flash-Lite reasoning effort.", "group": "reasoning", "type": "enum", - "default": "high", + "default": "minimal", "values": [ + "minimal", "low", + "medium", "high" ] }, @@ -7185,8 +7412,8 @@ export const CATALOG = [ }, { "provider": "google", - "authType": "api_key", - "model": "gemini-3.5-flash", + "authType": "subscription", + "model": "gemini-3.1-pro-preview", "params": [ { "path": "generationConfig.maxOutputTokens", @@ -7246,14 +7473,12 @@ export const CATALOG = [ { "path": "generationConfig.thinkingConfig.thinkingLevel", "label": "Thinking level", - "description": "Controls Gemini 3.5 Flash reasoning effort.", + "description": "Controls Gemini 3 Pro reasoning effort.", "group": "reasoning", "type": "enum", - "default": "medium", + "default": "high", "values": [ - "minimal", "low", - "medium", "high" ] }, @@ -7282,7 +7507,7 @@ export const CATALOG = [ { "provider": "google", "authType": "api_key", - "model": "gemini-flash-latest", + "model": "gemini-3.5-flash", "params": [ { "path": "generationConfig.maxOutputTokens", @@ -7340,12 +7565,18 @@ export const CATALOG = [ "type": "integer" }, { - "path": "generationConfig.thinkingConfig.thinkingBudget", - "label": "Thinking budget", - "description": "Number of thinking tokens Gemini should use; -1 uses dynamic thinking, 0 disables thinking, and fixed budgets start at 512 tokens.", + "path": "generationConfig.thinkingConfig.thinkingLevel", + "label": "Thinking level", + "description": "Controls Gemini 3.5 Flash reasoning effort.", "group": "reasoning", - "type": "integer", - "default": 0 + "type": "enum", + "default": "medium", + "values": [ + "minimal", + "low", + "medium", + "high" + ] }, { "path": "generationConfig.thinkingConfig.includeThoughts", @@ -7372,7 +7603,7 @@ export const CATALOG = [ { "provider": "google", "authType": "api_key", - "model": "gemma-4-26b-a4b-it", + "model": "gemini-flash-latest", "params": [ { "path": "generationConfig.maxOutputTokens", @@ -7437,17 +7668,449 @@ export const CATALOG = [ "type": "integer", "default": 0 }, - { - "path": "generationConfig.thinkingConfig.thinkingLevel", - "label": "Thinking level", - "description": "Toggles Gemma 4 reasoning; high enables thinking and minimal disables it.", - "group": "reasoning", - "type": "enum", - "values": [ - "minimal", - "high" - ] - }, + { + "path": "generationConfig.thinkingConfig.includeThoughts", + "label": "Include thoughts", + "description": "Controls whether Gemini returns available thought summaries in the response parts.", + "group": "reasoning", + "type": "boolean", + "default": false + }, + { + "path": "generationConfig.responseMimeType", + "label": "Response MIME type", + "description": "MIME type for generated text candidates.", + "group": "output_format", + "type": "enum", + "default": "text/plain", + "values": [ + "text/plain", + "application/json" + ] + } + ] + }, + { + "provider": "google", + "authType": "api_key", + "model": "gemma-3-12b-it", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate; output shares the 128K context window with the input.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1, + "max": 131072 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 1 + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens.", + "group": "sampling", + "type": "integer", + "default": 64, + "range": { + "min": 0 + } + } + ] + }, + { + "provider": "google", + "authType": "api_key", + "model": "gemma-3-1b-it", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate; output shares the 32K context window with the input.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1, + "max": 32768 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 1 + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens.", + "group": "sampling", + "type": "integer", + "default": 64, + "range": { + "min": 0 + } + } + ] + }, + { + "provider": "google", + "authType": "api_key", + "model": "gemma-3-27b-it", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate; output shares the 128K context window with the input.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1, + "max": 131072 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 1 + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens.", + "group": "sampling", + "type": "integer", + "default": 64, + "range": { + "min": 0 + } + } + ] + }, + { + "provider": "google", + "authType": "api_key", + "model": "gemma-3-4b-it", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate; output shares the 128K context window with the input.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1, + "max": 131072 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 1 + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens.", + "group": "sampling", + "type": "integer", + "default": 64, + "range": { + "min": 0 + } + } + ] + }, + { + "provider": "google", + "authType": "api_key", + "model": "gemma-3n-E2B-it", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate; output shares the 32K context window with the input.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1, + "max": 32768 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 1 + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens.", + "group": "sampling", + "type": "integer", + "default": 64, + "range": { + "min": 0 + } + } + ] + }, + { + "provider": "google", + "authType": "api_key", + "model": "gemma-3n-E4B-it", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate; output shares the 32K context window with the input.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1, + "max": 32768 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 1 + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens.", + "group": "sampling", + "type": "integer", + "default": 64, + "range": { + "min": 0 + } + } + ] + }, + { + "provider": "google", + "authType": "api_key", + "model": "gemma-4-12B-it", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Google's standardized Gemma 4 sampling uses 1.0.", + "group": "sampling", + "type": "number", + "default": 1 + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens.", + "group": "sampling", + "type": "integer", + "default": 64, + "range": { + "min": 0 + } + } + ] + }, + { + "provider": "google", + "authType": "api_key", + "model": "gemma-4-26b-a4b-it", + "params": [ + { + "path": "generationConfig.maxOutputTokens", + "label": "Max output tokens", + "description": "Maximum number of tokens to include in a response candidate.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1, + "max": 65536 + } + }, + { + "path": "generationConfig.temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "generationConfig.topP", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "generationConfig.topK", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "type": "integer", + "default": 64, + "range": { + "min": 0 + } + }, + { + "path": "generationConfig.seed", + "label": "Seed", + "description": "Optional seed used for decoding when reproducible sampling is desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "generationConfig.thinkingConfig.thinkingBudget", + "label": "Thinking budget", + "description": "Number of thinking tokens Gemini should use; -1 uses dynamic thinking, 0 disables thinking, and fixed budgets start at 512 tokens.", + "group": "reasoning", + "type": "integer", + "default": 0 + }, + { + "path": "generationConfig.thinkingConfig.thinkingLevel", + "label": "Thinking level", + "description": "Toggles Gemma 4 reasoning; high enables thinking and minimal disables it.", + "group": "reasoning", + "type": "enum", + "values": [ + "minimal", + "high" + ] + }, { "path": "generationConfig.thinkingConfig.includeThoughts", "label": "Include thoughts", @@ -7571,6 +8234,102 @@ export const CATALOG = [ } ] }, + { + "provider": "google", + "authType": "api_key", + "model": "gemma-4-E2B-it", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Google's standardized Gemma 4 sampling uses 1.0.", + "group": "sampling", + "type": "number", + "default": 1 + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens.", + "group": "sampling", + "type": "integer", + "default": 64, + "range": { + "min": 0 + } + } + ] + }, + { + "provider": "google", + "authType": "api_key", + "model": "gemma-4-E4B-it", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Google's standardized Gemma 4 sampling uses 1.0.", + "group": "sampling", + "type": "number", + "default": 1 + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens.", + "group": "sampling", + "type": "integer", + "default": 64, + "range": { + "min": 0 + } + } + ] + }, { "provider": "meta", "authType": "api_key", @@ -10026,7 +10785,48 @@ export const CATALOG = [ }, { "provider": "moonshot", - "authType": "api_key", + "authType": "api_key", + "model": "kimi-k2.6", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the chat completion.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls whether Kimi reasons step by step before answering. Thinking is enabled by default; set disabled to respond directly.", + "group": "reasoning", + "type": "enum", + "default": "enabled", + "values": [ + "enabled", + "disabled" + ] + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Forces the response into plain text or a JSON object.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + } + ] + }, + { + "provider": "moonshot", + "authType": "subscription", "model": "kimi-k2.6", "params": [ { @@ -10067,41 +10867,62 @@ export const CATALOG = [ }, { "provider": "moonshot", - "authType": "subscription", - "model": "kimi-k2.6", + "authType": "api_key", + "model": "kimi-k2.7-code", "params": [ { "path": "max_completion_tokens", "label": "Max tokens", - "description": "Maximum number of tokens to generate in the chat completion.", + "description": "Maximum number of tokens to generate in the chat completion, including reasoning tokens.", "group": "generation_length", "type": "integer", + "default": 32768, "range": { "min": 1 } }, { - "path": "thinking.type", - "label": "Thinking mode", - "description": "Controls whether Kimi reasons step by step before answering. Thinking is enabled by default; set disabled to respond directly.", - "group": "reasoning", + "path": "response_format.type", + "label": "Response format", + "description": "Forces the response into plain text, a JSON object, or JSON matching a provided schema.", + "group": "output_format", "type": "enum", - "default": "enabled", + "default": "text", "values": [ - "enabled", - "disabled" + "text", + "json_object", + "json_schema" ] + } + ] + }, + { + "provider": "moonshot", + "authType": "api_key", + "model": "kimi-k2.7-code-highspeed", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the chat completion, including reasoning tokens.", + "group": "generation_length", + "type": "integer", + "default": 32768, + "range": { + "min": 1 + } }, { "path": "response_format.type", "label": "Response format", - "description": "Forces the response into plain text or a JSON object.", + "description": "Forces the response into plain text, a JSON object, or JSON matching a provided schema.", "group": "output_format", "type": "enum", "default": "text", "values": [ "text", - "json_object" + "json_object", + "json_schema" ] } ] @@ -16848,6 +17669,224 @@ export const CATALOG = [ ] } ] + }, + { + "provider": "z-ai", + "authType": "api_key", + "model": "glm-5.2", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "group": "generation_length", + "type": "integer", + "default": 65536, + "range": { + "min": 1, + "max": 131072 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "do_sample": false + } + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "applicability": { + "except": { + "do_sample": false + } + }, + "type": "number", + "default": 0.95, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "path": "do_sample", + "label": "Do sample", + "description": "When false, the model uses greedy decoding and ignores temperature and top_p.", + "group": "sampling", + "type": "boolean", + "default": true + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Toggles the model's extended reasoning before it produces the final answer.", + "group": "reasoning", + "type": "enum", + "default": "enabled", + "values": [ + "enabled", + "disabled" + ] + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning effort GLM-5.2 spends when thinking is enabled.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "enum", + "default": "max", + "values": [ + "none", + "minimal", + "low", + "medium", + "high", + "xhigh", + "max" + ] + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Forces the response into plain text or a JSON object.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + } + ] + }, + { + "provider": "z-ai", + "authType": "subscription", + "model": "glm-5.2", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "group": "generation_length", + "type": "integer", + "default": 65536, + "range": { + "min": 1, + "max": 131072 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "do_sample": false + } + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "applicability": { + "except": { + "do_sample": false + } + }, + "type": "number", + "default": 0.95, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "path": "do_sample", + "label": "Do sample", + "description": "When false, the model uses greedy decoding and ignores temperature and top_p.", + "group": "sampling", + "type": "boolean", + "default": true + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Toggles the model's extended reasoning before it produces the final answer.", + "group": "reasoning", + "type": "enum", + "default": "enabled", + "values": [ + "enabled", + "disabled" + ] + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning effort GLM-5.2 spends when thinking is enabled.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "enum", + "default": "max", + "values": [ + "none", + "minimal", + "low", + "medium", + "high", + "xhigh", + "max" + ] + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Forces the response into plain text or a JSON object.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + } + ] } ] as const; diff --git a/packages/modelparams/src/generated/defaults.ts b/packages/modelparams/src/generated/defaults.ts index deeaa3e..cbd36bb 100644 --- a/packages/modelparams/src/generated/defaults.ts +++ b/packages/modelparams/src/generated/defaults.ts @@ -31,6 +31,18 @@ export const DEFAULTS = { "extra_body.top_k": 20, "extra_body.chat_template_kwargs.enable_thinking": true, }, + "alibaba/qwen3.6-flash": { + "extra_body.top_k": 20, + "extra_body.enable_thinking": true, + }, + "alibaba/qwen3.7-max": { + "extra_body.top_k": 20, + "extra_body.enable_thinking": true, + }, + "alibaba/qwen3.7-plus": { + "extra_body.top_k": 20, + "extra_body.enable_thinking": true, + }, "alibaba/qwq-plus": { "extra_body.top_k": 20, }, @@ -501,6 +513,14 @@ export const DEFAULTS = { "generationConfig.thinkingConfig.includeThoughts": false, "generationConfig.responseMimeType": "text/plain", }, + "google/gemini-3.1-flash-lite": { + "generationConfig.temperature": 1, + "generationConfig.topP": 0.95, + "generationConfig.topK": 64, + "generationConfig.thinkingConfig.thinkingLevel": "minimal", + "generationConfig.thinkingConfig.includeThoughts": false, + "generationConfig.responseMimeType": "text/plain", + }, "google/gemini-3.1-flash-lite-preview-subscription": { "generationConfig.temperature": 1, "generationConfig.topP": 0.95, @@ -513,7 +533,7 @@ export const DEFAULTS = { "generationConfig.temperature": 1, "generationConfig.topP": 0.95, "generationConfig.topK": 64, - "generationConfig.thinkingConfig.thinkingLevel": "high", + "generationConfig.thinkingConfig.thinkingLevel": "minimal", "generationConfig.thinkingConfig.includeThoughts": false, "generationConfig.responseMimeType": "text/plain", }, @@ -541,6 +561,41 @@ export const DEFAULTS = { "generationConfig.thinkingConfig.includeThoughts": false, "generationConfig.responseMimeType": "text/plain", }, + "google/gemma-3-12b-it": { + temperature: 1, + top_p: 0.95, + top_k: 64, + }, + "google/gemma-3-1b-it": { + temperature: 1, + top_p: 0.95, + top_k: 64, + }, + "google/gemma-3-27b-it": { + temperature: 1, + top_p: 0.95, + top_k: 64, + }, + "google/gemma-3-4b-it": { + temperature: 1, + top_p: 0.95, + top_k: 64, + }, + "google/gemma-3n-E2B-it": { + temperature: 1, + top_p: 0.95, + top_k: 64, + }, + "google/gemma-3n-E4B-it": { + temperature: 1, + top_p: 0.95, + top_k: 64, + }, + "google/gemma-4-12B-it": { + temperature: 1, + top_p: 0.95, + top_k: 64, + }, "google/gemma-4-26b-a4b-it": { "generationConfig.temperature": 1, "generationConfig.topP": 0.95, @@ -557,6 +612,16 @@ export const DEFAULTS = { "generationConfig.thinkingConfig.includeThoughts": false, "generationConfig.responseMimeType": "text/plain", }, + "google/gemma-4-E2B-it": { + temperature: 1, + top_p: 0.95, + top_k: 64, + }, + "google/gemma-4-E4B-it": { + temperature: 1, + top_p: 0.95, + top_k: 64, + }, "meta/Llama-3.3-70B-Instruct": { "response_format.type": "text", }, @@ -743,6 +808,14 @@ export const DEFAULTS = { "thinking.type": "enabled", "response_format.type": "text", }, + "moonshot/kimi-k2.7-code": { + max_completion_tokens: 32768, + "response_format.type": "text", + }, + "moonshot/kimi-k2.7-code-highspeed": { + max_completion_tokens: 32768, + "response_format.type": "text", + }, "moonshot/kimi-k2.7-code-highspeed-subscription": { "response_format.type": "text", }, @@ -1350,4 +1423,22 @@ export const DEFAULTS = { "thinking.type": "enabled", "response_format.type": "text", }, + "z-ai/glm-5.2": { + max_tokens: 65536, + temperature: 1, + top_p: 0.95, + do_sample: true, + "thinking.type": "enabled", + reasoning_effort: "max", + "response_format.type": "text", + }, + "z-ai/glm-5.2-subscription": { + max_tokens: 65536, + temperature: 1, + top_p: 0.95, + do_sample: true, + "thinking.type": "enabled", + reasoning_effort: "max", + "response_format.type": "text", + }, } as const satisfies { [K in ModelId]: Partial }; diff --git a/packages/modelparams/src/generated/model-ids.ts b/packages/modelparams/src/generated/model-ids.ts index 4fa6f24..91b724d 100644 --- a/packages/modelparams/src/generated/model-ids.ts +++ b/packages/modelparams/src/generated/model-ids.ts @@ -9,6 +9,9 @@ export const MODEL_IDS = [ "alibaba/qwen3-max", "alibaba/qwen3.5", "alibaba/qwen3.5-flash", + "alibaba/qwen3.6-flash", + "alibaba/qwen3.7-max", + "alibaba/qwen3.7-plus", "alibaba/qwq-plus", "anthropic/claude-3-5-haiku-20241022", "anthropic/claude-3-5-haiku-latest", @@ -68,13 +71,23 @@ export const MODEL_IDS = [ "google/gemini-2.5-pro", "google/gemini-2.5-pro-subscription", "google/gemini-3-flash-preview-subscription", + "google/gemini-3.1-flash-lite", "google/gemini-3.1-flash-lite-preview-subscription", "google/gemini-3.1-flash-lite-subscription", "google/gemini-3.1-pro-preview-subscription", "google/gemini-3.5-flash", "google/gemini-flash-latest", + "google/gemma-3-12b-it", + "google/gemma-3-1b-it", + "google/gemma-3-27b-it", + "google/gemma-3-4b-it", + "google/gemma-3n-E2B-it", + "google/gemma-3n-E4B-it", + "google/gemma-4-12B-it", "google/gemma-4-26b-a4b-it", "google/gemma-4-31b-it", + "google/gemma-4-E2B-it", + "google/gemma-4-E4B-it", "meta/Llama-3.3-70B-Instruct", "meta/Llama-3.3-8B-Instruct", "meta/Llama-4-Maverick-17B-128E-Instruct-FP8", @@ -111,6 +124,8 @@ export const MODEL_IDS = [ "moonshot/kimi-k2.5", "moonshot/kimi-k2.6", "moonshot/kimi-k2.6-subscription", + "moonshot/kimi-k2.7-code", + "moonshot/kimi-k2.7-code-highspeed", "moonshot/kimi-k2.7-code-highspeed-subscription", "moonshot/kimi-k2.7-code-subscription", "moonshot/kimi-k3", @@ -221,7 +236,9 @@ export const MODEL_IDS = [ "z-ai/glm-5-turbo", "z-ai/glm-5-turbo-subscription", "z-ai/glm-5.1", - "z-ai/glm-5.1-subscription" + "z-ai/glm-5.1-subscription", + "z-ai/glm-5.2", + "z-ai/glm-5.2-subscription" ] as const; export type ModelId = (typeof MODEL_IDS)[number]; diff --git a/packages/modelparams/src/generated/params-by-id.ts b/packages/modelparams/src/generated/params-by-id.ts index c7c3456..d941b55 100644 --- a/packages/modelparams/src/generated/params-by-id.ts +++ b/packages/modelparams/src/generated/params-by-id.ts @@ -54,6 +54,30 @@ export type ParamsById = { "extra_body.top_k": number; "extra_body.chat_template_kwargs.enable_thinking": boolean; }; + "alibaba/qwen3.6-flash": { + max_completion_tokens: number; + temperature: number; + top_p: number; + "extra_body.top_k": number; + "extra_body.enable_thinking": boolean; + "extra_body.thinking_budget": number; + }; + "alibaba/qwen3.7-max": { + max_completion_tokens: number; + temperature: number; + top_p: number; + "extra_body.top_k": number; + "extra_body.enable_thinking": boolean; + "extra_body.thinking_budget": number; + }; + "alibaba/qwen3.7-plus": { + max_completion_tokens: number; + temperature: number; + top_p: number; + "extra_body.top_k": number; + "extra_body.enable_thinking": boolean; + "extra_body.thinking_budget": number; + }; "alibaba/qwq-plus": { max_tokens: number; temperature: number; @@ -576,6 +600,16 @@ export type ParamsById = { "generationConfig.thinkingConfig.includeThoughts": boolean; "generationConfig.responseMimeType": "text/plain" | "application/json"; }; + "google/gemini-3.1-flash-lite": { + "generationConfig.maxOutputTokens": number; + "generationConfig.temperature": number; + "generationConfig.topP": number; + "generationConfig.topK": number; + "generationConfig.seed": number; + "generationConfig.thinkingConfig.thinkingLevel": "minimal" | "low" | "medium" | "high"; + "generationConfig.thinkingConfig.includeThoughts": boolean; + "generationConfig.responseMimeType": "text/plain" | "application/json"; + }; "google/gemini-3.1-flash-lite-preview-subscription": { "generationConfig.maxOutputTokens": number; "generationConfig.temperature": number; @@ -626,6 +660,48 @@ export type ParamsById = { "generationConfig.thinkingConfig.includeThoughts": boolean; "generationConfig.responseMimeType": "text/plain" | "application/json"; }; + "google/gemma-3-12b-it": { + max_completion_tokens: number; + temperature: number; + top_p: number; + top_k: number; + }; + "google/gemma-3-1b-it": { + max_completion_tokens: number; + temperature: number; + top_p: number; + top_k: number; + }; + "google/gemma-3-27b-it": { + max_completion_tokens: number; + temperature: number; + top_p: number; + top_k: number; + }; + "google/gemma-3-4b-it": { + max_completion_tokens: number; + temperature: number; + top_p: number; + top_k: number; + }; + "google/gemma-3n-E2B-it": { + max_completion_tokens: number; + temperature: number; + top_p: number; + top_k: number; + }; + "google/gemma-3n-E4B-it": { + max_completion_tokens: number; + temperature: number; + top_p: number; + top_k: number; + }; + "google/gemma-4-12B-it": { + max_completion_tokens: number; + temperature: number; + top_p: number; + top_k: number; + }; "google/gemma-4-26b-a4b-it": { "generationConfig.maxOutputTokens": number; "generationConfig.temperature": number; @@ -648,6 +724,18 @@ export type ParamsById = { "generationConfig.thinkingConfig.includeThoughts": boolean; "generationConfig.responseMimeType": "text/plain" | "application/json"; }; + "google/gemma-4-E2B-it": { + max_completion_tokens: number; + temperature: number; + top_p: number; + top_k: number; + }; + "google/gemma-4-E4B-it": { + max_completion_tokens: number; + temperature: number; + top_p: number; + top_k: number; + }; "meta/Llama-3.3-70B-Instruct": { max_completion_tokens: number; temperature: number; @@ -932,6 +1020,14 @@ export type ParamsById = { "thinking.type": "enabled" | "disabled"; "response_format.type": "text" | "json_object"; }; + "moonshot/kimi-k2.7-code": { + max_completion_tokens: number; + "response_format.type": "text" | "json_object" | "json_schema"; + }; + "moonshot/kimi-k2.7-code-highspeed": { + max_completion_tokens: number; + "response_format.type": "text" | "json_object" | "json_schema"; + }; "moonshot/kimi-k2.7-code-highspeed-subscription": { max_completion_tokens: number; "response_format.type": "text" | "json_object"; @@ -1649,4 +1745,22 @@ export type ParamsById = { "thinking.type": "enabled" | "disabled"; "response_format.type": "text" | "json_object"; }; + "z-ai/glm-5.2": { + max_tokens: number; + temperature: number; + top_p: number; + do_sample: boolean; + "thinking.type": "enabled" | "disabled"; + reasoning_effort: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max"; + "response_format.type": "text" | "json_object"; + }; + "z-ai/glm-5.2-subscription": { + max_tokens: number; + temperature: number; + top_p: number; + do_sample: boolean; + "thinking.type": "enabled" | "disabled"; + reasoning_effort: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max"; + "response_format.type": "text" | "json_object"; + }; }; diff --git a/src/data/display.ts b/src/data/display.ts index 73e4ed4..29fcec2 100644 --- a/src/data/display.ts +++ b/src/data/display.ts @@ -32,6 +32,7 @@ const MODEL_LABEL_OVERRIDES: Record = { "minimax/minimax-m2.5-highspeed": "MiniMax M2.5 Highspeed", "minimax/minimax-m2.7": "MiniMax M2.7", "minimax/minimax-m2.7-highspeed": "MiniMax M2.7 Highspeed", + "z-ai/glm-5.2": "GLM-5.2", "z-ai/glm-5.1": "GLM-5.1", "z-ai/glm-5": "GLM-5", "z-ai/glm-5-turbo": "GLM-5-Turbo",