From 80740fe3787b665a7ba0e65ffca19c2bdf798393 Mon Sep 17 00:00:00 2001 From: Guillaume Gay Date: Sat, 11 Jul 2026 12:08:24 +0000 Subject: [PATCH 01/11] feat: add openai/gpt-5.6-luna --- models/openai/gpt-5.6-luna.yaml | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 models/openai/gpt-5.6-luna.yaml diff --git a/models/openai/gpt-5.6-luna.yaml b/models/openai/gpt-5.6-luna.yaml new file mode 100644 index 0000000..21e0032 --- /dev/null +++ b/models/openai/gpt-5.6-luna.yaml @@ -0,0 +1,24 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: openai +authType: api_key +model: gpt-5.6-luna +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate. + default: 4096 + range: + min: 16 + group: generation_length + - path: reasoning_effort + type: enum + label: Reasoning effort + description: Controls how much reasoning the model should perform before producing an answer. + default: none + values: + - none + - low + - medium + - high + group: reasoning From 8ea337fd1c06783c2adf51030db05f9e18c6a56e Mon Sep 17 00:00:00 2001 From: Guillaume Gay Date: Sat, 11 Jul 2026 18:01:58 +0200 Subject: [PATCH 02/11] chore: commit codegen output for gpt-5.6-luna --- packages/modelparams/src/generated/data.ts | 32 +++++++++++++++++++ .../modelparams/src/generated/defaults.ts | 4 +++ .../modelparams/src/generated/model-ids.ts | 1 + .../modelparams/src/generated/params-by-id.ts | 4 +++ 4 files changed, 41 insertions(+) diff --git a/packages/modelparams/src/generated/data.ts b/packages/modelparams/src/generated/data.ts index 6241116..875f5fb 100644 --- a/packages/modelparams/src/generated/data.ts +++ b/packages/modelparams/src/generated/data.ts @@ -12444,6 +12444,38 @@ export const CATALOG = [ } ] }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5.6-luna", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning the model should perform before producing an answer.", + "group": "reasoning", + "type": "enum", + "default": "none", + "values": [ + "none", + "low", + "medium", + "high" + ] + } + ] + }, { "provider": "openai", "authType": "api_key", diff --git a/packages/modelparams/src/generated/defaults.ts b/packages/modelparams/src/generated/defaults.ts index d71d778..e0deae6 100644 --- a/packages/modelparams/src/generated/defaults.ts +++ b/packages/modelparams/src/generated/defaults.ts @@ -996,6 +996,10 @@ export const DEFAULTS = { "reasoning.summary": "auto", "text.verbosity": "medium", }, + "openai/gpt-5.6-luna": { + max_completion_tokens: 4096, + reasoning_effort: "none", + }, "openai/o1": { max_completion_tokens: 4096, reasoning_effort: "medium", diff --git a/packages/modelparams/src/generated/model-ids.ts b/packages/modelparams/src/generated/model-ids.ts index 50a12e0..b34259d 100644 --- a/packages/modelparams/src/generated/model-ids.ts +++ b/packages/modelparams/src/generated/model-ids.ts @@ -162,6 +162,7 @@ export const MODEL_IDS = [ "openai/gpt-5.5-pro", "openai/gpt-5.5-pro-subscription", "openai/gpt-5.5-subscription", + "openai/gpt-5.6-luna", "openai/o1", "openai/o1-mini", "openai/o1-preview", diff --git a/packages/modelparams/src/generated/params-by-id.ts b/packages/modelparams/src/generated/params-by-id.ts index 064bf9e..097f597 100644 --- a/packages/modelparams/src/generated/params-by-id.ts +++ b/packages/modelparams/src/generated/params-by-id.ts @@ -1198,6 +1198,10 @@ export type ParamsById = { "reasoning.summary": "auto" | "concise" | "detailed" | "none"; "text.verbosity": "low" | "medium" | "high"; }; + "openai/gpt-5.6-luna": { + max_completion_tokens: number; + reasoning_effort: "none" | "low" | "medium" | "high"; + }; "openai/o1": { max_completion_tokens: number; reasoning_effort: "low" | "medium" | "high" | "xhigh"; From 6a3ad3c92acb84eed1707e3fa80cabcb92e541e0 Mon Sep 17 00:00:00 2001 From: Guillaume Gay Date: Tue, 14 Jul 2026 11:34:39 +0200 Subject: [PATCH 03/11] feat: add GPT-OSS 20B parameters (#108) Add the catalog entry for GPT-OSS 20B. --- models/openai/gpt-oss-20b.yaml | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 models/openai/gpt-oss-20b.yaml diff --git a/models/openai/gpt-oss-20b.yaml b/models/openai/gpt-oss-20b.yaml new file mode 100644 index 0000000..2ca5a24 --- /dev/null +++ b/models/openai/gpt-oss-20b.yaml @@ -0,0 +1,22 @@ +# 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: reasoning_effort + type: enum + label: Reasoning effort + description: Controls how much reasoning the model should perform before producing an answer. + values: + - low + - medium + - high + group: reasoning From 975fecea1d10bb7b25b8c8c5f3de8891f116c1c6 Mon Sep 17 00:00:00 2001 From: Guillaume Gay Date: Tue, 14 Jul 2026 11:35:38 +0200 Subject: [PATCH 04/11] feat: add Gemma 4 31B parameters (#112) Add the catalog entry for Gemma 4 31B. --- models/google/gemma-4-31b-it.yaml | 59 +++++++++++++++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 models/google/gemma-4-31b-it.yaml diff --git a/models/google/gemma-4-31b-it.yaml b/models/google/gemma-4-31b-it.yaml new file mode 100644 index 0000000..692fd82 --- /dev/null +++ b/models/google/gemma-4-31b-it.yaml @@ -0,0 +1,59 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: google +authType: api_key +model: gemma-4-31b-it +params: + - path: generationConfig.maxOutputTokens + type: integer + label: Max output tokens + description: Maximum number of tokens to include in a response candidate. + range: + min: 1 + 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. + 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 the selected cumulative probability. + 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. + range: + min: 0 + group: sampling + - path: generationConfig.seed + type: integer + label: Seed + description: Optional seed used in decoding when reproducible sampling is desired. + group: sampling + - path: generationConfig.thinkingConfig.thinkingLevel + type: enum + label: Thinking level + description: Toggles Gemma 4's internal reasoning process. + values: + - minimal + - high + 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 From 747f3a4a9d4717dd37e86078992aee4a7544e099 Mon Sep 17 00:00:00 2001 From: Guillaume Gay Date: Tue, 14 Jul 2026 11:35:47 +0200 Subject: [PATCH 05/11] feat: add Gemma 4 26B parameters (#111) Add the catalog entry for Gemma 4 26B A4B. --- models/google/gemma-4-26b-a4b-it.yaml | 59 +++++++++++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 models/google/gemma-4-26b-a4b-it.yaml diff --git a/models/google/gemma-4-26b-a4b-it.yaml b/models/google/gemma-4-26b-a4b-it.yaml new file mode 100644 index 0000000..67ccff5 --- /dev/null +++ b/models/google/gemma-4-26b-a4b-it.yaml @@ -0,0 +1,59 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: google +authType: api_key +model: gemma-4-26b-a4b-it +params: + - path: generationConfig.maxOutputTokens + type: integer + label: Max output tokens + description: Maximum number of tokens to include in a response candidate. + range: + min: 1 + 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. + 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 the selected cumulative probability. + 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. + range: + min: 0 + group: sampling + - path: generationConfig.seed + type: integer + label: Seed + description: Optional seed used in decoding when reproducible sampling is desired. + group: sampling + - path: generationConfig.thinkingConfig.thinkingLevel + type: enum + label: Thinking level + description: Toggles Gemma 4's internal reasoning process. + values: + - minimal + - high + 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 From 8a61818729bea91d0a20f9d3c50c99a44ab709fa Mon Sep 17 00:00:00 2001 From: Guillaume Gay Date: Tue, 14 Jul 2026 11:35:57 +0200 Subject: [PATCH 06/11] feat: add GLM-5.2 parameters (#110) Add API-key and subscription parameter entries for GLM-5.2. --- models/z-ai/glm-5.2-subscription.yaml | 81 +++++++++++++++++++++++++++ models/z-ai/glm-5.2.yaml | 81 +++++++++++++++++++++++++++ tests/catalog.test.ts | 1 + 3 files changed, 163 insertions(+) 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/z-ai/glm-5.2-subscription.yaml b/models/z-ai/glm-5.2-subscription.yaml new file mode 100644 index 0000000..2c5d9c1 --- /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 the model performs when thinking is enabled. + default: max + values: + - max + - xhigh + - high + - medium + - low + - minimal + - none + 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..52e8de4 --- /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 the model performs when thinking is enabled. + default: max + values: + - max + - xhigh + - high + - medium + - low + - minimal + - none + 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/tests/catalog.test.ts b/tests/catalog.test.ts index ff1af93..1b33192 100644 --- a/tests/catalog.test.ts +++ b/tests/catalog.test.ts @@ -218,6 +218,7 @@ describe("provider catalog rows", () => { const byId = new Map(models.map((model) => [modelId(model), model])); const sharedModels = [ "glm-5.1", + "glm-5.2", "glm-5-turbo", "glm-5", "glm-4.7", From 5e33ba7ed64deb5304a474fd495188d109aacb86 Mon Sep 17 00:00:00 2001 From: Guillaume Gay Date: Tue, 14 Jul 2026 11:36:43 +0200 Subject: [PATCH 07/11] feat: add GPT-OSS 120B parameters (#109) Add the catalog entry for GPT-OSS 120B. --- models/openai/gpt-oss-120b.yaml | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 models/openai/gpt-oss-120b.yaml diff --git a/models/openai/gpt-oss-120b.yaml b/models/openai/gpt-oss-120b.yaml new file mode 100644 index 0000000..1720147 --- /dev/null +++ b/models/openai/gpt-oss-120b.yaml @@ -0,0 +1,22 @@ +# 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: reasoning_effort + type: enum + label: Reasoning effort + description: Controls how much reasoning the model should perform before producing an answer. + values: + - low + - medium + - high + group: reasoning From da7b617b73449da2af71d47103af5935d00337f3 Mon Sep 17 00:00:00 2001 From: Guillaume Gay Date: Tue, 14 Jul 2026 13:40:39 +0200 Subject: [PATCH 08/11] feat: add xAI Grok 4.5 parameters (#113) --- models/xai/grok-4.5-subscription.yaml | 57 +++++++++++++++++++++++++++ models/xai/grok-4.5.yaml | 57 +++++++++++++++++++++++++++ 2 files changed, 114 insertions(+) create mode 100644 models/xai/grok-4.5-subscription.yaml create mode 100644 models/xai/grok-4.5.yaml diff --git a/models/xai/grok-4.5-subscription.yaml b/models/xai/grok-4.5-subscription.yaml new file mode 100644 index 0000000..b6b1b38 --- /dev/null +++ b/models/xai/grok-4.5-subscription.yaml @@ -0,0 +1,57 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: xai +authType: subscription +model: grok-4.5 +params: + - path: max_completion_tokens + type: integer + label: Max completion tokens + description: Upper bound for visible output tokens generated in the chat completion. + 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 + 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. + default: 1 + range: + min: 0 + max: 1 + step: 0.01 + group: sampling + - path: seed + type: integer + label: Seed + description: Optional seed used for decoding when reproducible sampling is desired. + group: sampling + - path: reasoning_effort + type: enum + label: Reasoning effort + description: Controls how much reasoning Grok performs before responding. Reasoning cannot be disabled for this model. + default: high + values: + - low + - medium + - high + group: reasoning + - path: response_format.type + type: enum + label: Response format + description: Controls whether the model returns text, JSON mode output, or structured JSON schema output. + default: text + values: + - text + - json_object + - json_schema + group: output_format diff --git a/models/xai/grok-4.5.yaml b/models/xai/grok-4.5.yaml new file mode 100644 index 0000000..026a63a --- /dev/null +++ b/models/xai/grok-4.5.yaml @@ -0,0 +1,57 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: xai +authType: api_key +model: grok-4.5 +params: + - path: max_completion_tokens + type: integer + label: Max completion tokens + description: Upper bound for visible output tokens generated in the chat completion. + 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 + 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. + default: 1 + range: + min: 0 + max: 1 + step: 0.01 + group: sampling + - path: seed + type: integer + label: Seed + description: Optional seed used for decoding when reproducible sampling is desired. + group: sampling + - path: reasoning_effort + type: enum + label: Reasoning effort + description: Controls how much reasoning Grok performs before responding. Reasoning cannot be disabled for this model. + default: high + values: + - low + - medium + - high + group: reasoning + - path: response_format.type + type: enum + label: Response format + description: Controls whether the model returns text, JSON mode output, or structured JSON schema output. + default: text + values: + - text + - json_object + - json_schema + group: output_format From 6b4e7ffa2324c52fa46952f86af147524e7ed291 Mon Sep 17 00:00:00 2001 From: Guillaume Gay Date: Tue, 14 Jul 2026 15:47:14 +0200 Subject: [PATCH 09/11] feat: add groq/qwen3-32b parameters (#114) --- models/groq/qwen3-32b.yaml | 89 ++++++++++++++++++++++++++++++++++++++ src/data/logos.ts | 1 + 2 files changed, 90 insertions(+) create mode 100644 models/groq/qwen3-32b.yaml diff --git a/models/groq/qwen3-32b.yaml b/models/groq/qwen3-32b.yaml new file mode 100644 index 0000000..0a746d4 --- /dev/null +++ b/models/groq/qwen3-32b.yaml @@ -0,0 +1,89 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: groq +authType: api_key +model: qwen3-32b +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. + default: 1 + 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. + default: 1 + range: + min: 0 + max: 1 + step: 0.01 + group: sampling + - path: frequency_penalty + type: number + label: Frequency penalty + description: Penalizes tokens by how often they have appeared, reducing verbatim repetition. + default: 0 + range: + min: -2 + max: 2 + step: 0.1 + group: sampling + - path: presence_penalty + type: number + label: Presence penalty + description: Penalizes tokens that have already appeared, encouraging the model to introduce new topics. + default: 0 + range: + min: -2 + max: 2 + step: 0.1 + group: sampling + - path: seed + type: integer + label: Seed + description: Seed used for best-effort deterministic sampling when reproducible outputs are desired. + group: sampling + - path: stop + type: string + label: Stop + description: A string or list of strings where the API will stop generating further tokens. Groq accepts up to four stop sequences. + group: generation_length + - path: reasoning_effort + type: enum + label: Reasoning effort + description: Controls whether the model reasons before answering. 'none' disables reasoning; 'default' lets the model reason. + default: default + values: + - none + - default + group: reasoning + - path: reasoning_format + type: enum + label: Reasoning format + description: Controls how reasoning tokens are returned — hidden from the response, raw within the content, or parsed into a separate field. + values: + - hidden + - raw + - parsed + group: reasoning + - 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/src/data/logos.ts b/src/data/logos.ts index d176d0c..dad3658 100644 --- a/src/data/logos.ts +++ b/src/data/logos.ts @@ -28,6 +28,7 @@ const SLUG_TO_LOBE: Record = { moonshot: "moonshot", alibaba: "alibabacloud-color", "z-ai": "zai", + groq: "groq", }; const cache = new Map(); From 3702056229eb90d442b304999619dd7f375fed99 Mon Sep 17 00:00:00 2001 From: Guillaume Gay Date: Tue, 14 Jul 2026 15:52:49 +0200 Subject: [PATCH 10/11] feat: add cerebras/zai-glm-4.7 parameters (#115) --- models/cerebras/zai-glm-4.7.yaml | 85 ++++++++++++++++++++++++++++++++ src/data/logos.ts | 1 + 2 files changed, 86 insertions(+) create mode 100644 models/cerebras/zai-glm-4.7.yaml diff --git a/models/cerebras/zai-glm-4.7.yaml b/models/cerebras/zai-glm-4.7.yaml new file mode 100644 index 0000000..e199c7b --- /dev/null +++ b/models/cerebras/zai-glm-4.7.yaml @@ -0,0 +1,85 @@ +# yaml-language-server: $schema=https://modelparams.dev/api/v1/schema.json +provider: cerebras +authType: api_key +model: zai-glm-4.7 +params: + - path: max_completion_tokens + type: integer + label: Max tokens + description: Maximum number of output tokens the model may generate, including reasoning tokens. + 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. Adjust this or top_p, not both. + 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: frequency_penalty + type: number + label: Frequency penalty + description: Penalizes tokens by how often they have appeared, reducing verbatim repetition. + default: 0 + range: + min: -2 + max: 2 + step: 0.1 + group: sampling + - path: presence_penalty + type: number + label: Presence penalty + description: Penalizes tokens that have already appeared, encouraging the model to introduce new topics. + default: 0 + range: + min: -2 + max: 2 + step: 0.1 + group: sampling + - path: seed + type: integer + label: Seed + description: Seed used for best-effort deterministic sampling when reproducible outputs are desired. + group: sampling + - path: stop + type: string + label: Stop + description: A string or list of strings where the API will stop generating further tokens. Cerebras accepts up to four stop sequences. + group: generation_length + - path: reasoning_effort + type: enum + label: Reasoning effort + description: Controls how much reasoning the model performs before answering. 'none' disables reasoning. + values: + - none + - low + - medium + - high + group: reasoning + - path: clear_thinking + type: boolean + label: Clear thinking + description: When true, the model's thinking from previous turns is excluded from the conversation context; when false, it is preserved, which is useful for agentic workflows. + default: true + group: reasoning + - 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/src/data/logos.ts b/src/data/logos.ts index dad3658..e539d86 100644 --- a/src/data/logos.ts +++ b/src/data/logos.ts @@ -29,6 +29,7 @@ const SLUG_TO_LOBE: Record = { alibaba: "alibabacloud-color", "z-ai": "zai", groq: "groq", + cerebras: "cerebras-color", }; const cache = new Map(); From 9eeb9b45f4908e4251ea74fe95d07232256b10be Mon Sep 17 00:00:00 2001 From: Guillaume Gay Date: Tue, 4 Aug 2026 11:18:10 +0200 Subject: [PATCH 11/11] feat: add typed Python modelparams package (#191) --- .github/workflows/ci.yml | 110 + .../workflows/release-modelparams-python.yml | 140 + .gitignore | 6 + .prettierignore | 2 + README.md | 21 + package.json | 1 + packages/modelparams-python/LICENSE | 21 + packages/modelparams-python/README.md | 74 + packages/modelparams-python/pyproject.toml | 63 + .../modelparams-python/scripts/codegen.ts | 235 + .../scripts/compute-version.ts | 101 + .../modelparams-python/scripts/lib/version.ts | 45 + .../src/modelparams/__init__.py | 60 + .../src/modelparams/_generated/__init__.py | 2 + .../src/modelparams/_generated/catalog.json | 16420 ++++++++++++++++ .../src/modelparams/_generated/model_ids.py | 472 + .../src/modelparams/_generated/registry.py | 238 + .../src/modelparams/catalog.py | 59 + .../src/modelparams/models.py | 62 + .../src/modelparams/py.typed | 1 + .../src/modelparams/types/__init__.py | 4 + .../src/modelparams/types/alibaba.py | 123 + .../src/modelparams/types/anthropic.py | 594 + .../src/modelparams/types/cerebras.py | 33 + .../src/modelparams/types/cohere.py | 182 + .../src/modelparams/types/deepseek.py | 69 + .../src/modelparams/types/google.py | 233 + .../src/modelparams/types/groq.py | 33 + .../src/modelparams/types/meta.py | 78 + .../src/modelparams/types/minimax.py | 214 + .../src/modelparams/types/mistral.py | 250 + .../src/modelparams/types/moonshot.py | 120 + .../src/modelparams/types/nvidia.py | 244 + .../src/modelparams/types/openai.py | 529 + .../src/modelparams/types/perplexity.py | 98 + .../src/modelparams/types/xai.py | 116 + .../src/modelparams/types/xiaomi.py | 59 + .../src/modelparams/types/z_ai.py | 331 + .../src/modelparams/validation.py | 19 + .../modelparams-python/tests/test_catalog.py | 83 + .../tests/test_validation.py | 91 + .../tests/typecheck/params.py | 19 + packages/modelparams-python/uv.lock | 1087 + tests/python-codegen.test.ts | 28 + tests/python-package-version.test.ts | 58 + 45 files changed, 22828 insertions(+) create mode 100644 .github/workflows/release-modelparams-python.yml create mode 100644 packages/modelparams-python/LICENSE create mode 100644 packages/modelparams-python/README.md create mode 100644 packages/modelparams-python/pyproject.toml create mode 100644 packages/modelparams-python/scripts/codegen.ts create mode 100644 packages/modelparams-python/scripts/compute-version.ts create mode 100644 packages/modelparams-python/scripts/lib/version.ts create mode 100644 packages/modelparams-python/src/modelparams/__init__.py create mode 100644 packages/modelparams-python/src/modelparams/_generated/__init__.py create mode 100644 packages/modelparams-python/src/modelparams/_generated/catalog.json create mode 100644 packages/modelparams-python/src/modelparams/_generated/model_ids.py create mode 100644 packages/modelparams-python/src/modelparams/_generated/registry.py create mode 100644 packages/modelparams-python/src/modelparams/catalog.py create mode 100644 packages/modelparams-python/src/modelparams/models.py create mode 100644 packages/modelparams-python/src/modelparams/py.typed create mode 100644 packages/modelparams-python/src/modelparams/types/__init__.py create mode 100644 packages/modelparams-python/src/modelparams/types/alibaba.py create mode 100644 packages/modelparams-python/src/modelparams/types/anthropic.py create mode 100644 packages/modelparams-python/src/modelparams/types/cerebras.py create mode 100644 packages/modelparams-python/src/modelparams/types/cohere.py create mode 100644 packages/modelparams-python/src/modelparams/types/deepseek.py create mode 100644 packages/modelparams-python/src/modelparams/types/google.py create mode 100644 packages/modelparams-python/src/modelparams/types/groq.py create mode 100644 packages/modelparams-python/src/modelparams/types/meta.py create mode 100644 packages/modelparams-python/src/modelparams/types/minimax.py create mode 100644 packages/modelparams-python/src/modelparams/types/mistral.py create mode 100644 packages/modelparams-python/src/modelparams/types/moonshot.py create mode 100644 packages/modelparams-python/src/modelparams/types/nvidia.py create mode 100644 packages/modelparams-python/src/modelparams/types/openai.py create mode 100644 packages/modelparams-python/src/modelparams/types/perplexity.py create mode 100644 packages/modelparams-python/src/modelparams/types/xai.py create mode 100644 packages/modelparams-python/src/modelparams/types/xiaomi.py create mode 100644 packages/modelparams-python/src/modelparams/types/z_ai.py create mode 100644 packages/modelparams-python/src/modelparams/validation.py create mode 100644 packages/modelparams-python/tests/test_catalog.py create mode 100644 packages/modelparams-python/tests/test_validation.py create mode 100644 packages/modelparams-python/tests/typecheck/params.py create mode 100644 packages/modelparams-python/uv.lock create mode 100644 tests/python-codegen.test.ts create mode 100644 tests/python-package-version.test.ts diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 39007d4..0be9498 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -82,3 +82,113 @@ jobs: - name: Type-level tests (tsd) run: npm run test:types --workspace=modelparams + + modelparams-python: + name: modelparams Python package + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Set up Node + uses: actions/setup-node@v4 + with: + node-version: "20" + cache: "npm" + + - name: Install Node dependencies + run: npm ci + + - name: Generate Python catalog and types + run: npm run codegen:python + + - name: Verify Python generated files are in sync + run: | + if [[ -n "$(git status --porcelain -- packages/modelparams-python/src/modelparams/_generated packages/modelparams-python/src/modelparams/types)" ]]; then + echo "::error::Generated Python package files are out of date." + echo "Run \`npm run codegen:python\` locally and commit the result." + git status --short -- packages/modelparams-python/src/modelparams/_generated packages/modelparams-python/src/modelparams/types + exit 1 + fi + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.12" + + - name: Set up uv + uses: astral-sh/setup-uv@v6 + with: + enable-cache: true + + - name: Install Python dependencies + run: uv sync --project packages/modelparams-python --extra dev --locked + + - name: Lint and format check + run: | + uv run --project packages/modelparams-python ruff check packages/modelparams-python + uv run --project packages/modelparams-python ruff format --check packages/modelparams-python/src packages/modelparams-python/tests + + - name: Typecheck + run: uv run --project packages/modelparams-python mypy --config-file packages/modelparams-python/pyproject.toml packages/modelparams-python/src/modelparams packages/modelparams-python/tests/typecheck + + - name: Test + run: uv run --project packages/modelparams-python pytest packages/modelparams-python/tests + + - name: Build and verify distributions + run: | + uv build --project packages/modelparams-python + uv run --project packages/modelparams-python twine check packages/modelparams-python/dist/* + + - name: Smoke-test installed wheel + run: | + smoke_dir="$(mktemp -d)" + python -m venv "$smoke_dir/venv" + "$smoke_dir/venv/bin/pip" install packages/modelparams-python/dist/*.whl + cd "$smoke_dir" + "$smoke_dir/venv/bin/python" -c 'import modelparams; assert len(modelparams.MODEL_IDS) > 0; assert modelparams.validate_params("openai/gpt-4.1", {"temperature": 0.5}) == {"temperature": 0.5}' + + modelparams-python-compat: + name: Python ${{ matrix.python-version }} compatibility + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"] + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + + - uses: astral-sh/setup-uv@v6 + with: + enable-cache: true + + - name: Install + run: uv sync --project packages/modelparams-python --extra dev --locked --python "${{ matrix.python-version }}" + + - name: Test + run: uv run --project packages/modelparams-python --python "${{ matrix.python-version }}" pytest packages/modelparams-python/tests + + modelparams-python-min-pydantic: + name: Python 3.10 + Pydantic 2.10 + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-python@v5 + with: + python-version: "3.10" + + - uses: astral-sh/setup-uv@v6 + + - name: Install minimum Pydantic + run: | + uv sync --project packages/modelparams-python --extra dev --locked --python "3.10" + uv pip install --python packages/modelparams-python/.venv/bin/python "pydantic==2.10.*" + + - name: Test + run: | + packages/modelparams-python/.venv/bin/python -c 'import pydantic; assert pydantic.__version__.startswith("2.10.")' + packages/modelparams-python/.venv/bin/pytest packages/modelparams-python/tests diff --git a/.github/workflows/release-modelparams-python.yml b/.github/workflows/release-modelparams-python.yml new file mode 100644 index 0000000..7db0865 --- /dev/null +++ b/.github/workflows/release-modelparams-python.yml @@ -0,0 +1,140 @@ +name: Release modelparams Python + +on: + push: + branches: [main] + paths: + - "models/**" + - "packages/modelparams-python/**" + - "src/schema/model.ts" + - "src/data/load.ts" + - ".github/workflows/release-modelparams-python.yml" + workflow_dispatch: + inputs: + force_level: + description: "Force bump level (overrides auto-detect)" + required: false + type: choice + options: ["auto", "patch", "major"] + default: "auto" + +concurrency: + group: release-modelparams-python + cancel-in-progress: false + +jobs: + build: + name: Build distributions + runs-on: ubuntu-latest + outputs: + next: ${{ steps.bump.outputs.next }} + steps: + - name: Check out repository + uses: actions/checkout@v4 + with: + fetch-depth: 0 + fetch-tags: true + + - name: Set up Node + uses: actions/setup-node@v4 + with: + node-version: "20" + cache: "npm" + + - name: Install Node dependencies + run: npm ci + + - name: Validate catalog + run: npm run validate + + - name: Generate Python catalog and types + run: npm run codegen:python + + - name: Verify generated files are in sync + run: | + if [[ -n "$(git status --porcelain -- packages/modelparams-python/src/modelparams/_generated packages/modelparams-python/src/modelparams/types)" ]]; then + echo "::error::Generated Python package files are out of date." + git status --short -- packages/modelparams-python/src/modelparams/_generated packages/modelparams-python/src/modelparams/types + exit 1 + fi + + - name: Compute next version + id: bump + run: npx tsx packages/modelparams-python/scripts/compute-version.ts + env: + FORCE_LEVEL: ${{ inputs.force_level }} + + - name: Set up Python + if: steps.bump.outputs.next != '' + uses: actions/setup-python@v5 + with: + python-version: "3.12" + + - name: Set up uv + if: steps.bump.outputs.next != '' + uses: astral-sh/setup-uv@v6 + + - name: Install, test, and build + if: steps.bump.outputs.next != '' + env: + NEXT: ${{ steps.bump.outputs.next }} + run: | + uv sync --project packages/modelparams-python --extra dev --locked + uv version --project packages/modelparams-python "$NEXT" + uv run --project packages/modelparams-python ruff check packages/modelparams-python + uv run --project packages/modelparams-python ruff format --check packages/modelparams-python/src packages/modelparams-python/tests + uv run --project packages/modelparams-python pytest packages/modelparams-python/tests + uv run --project packages/modelparams-python mypy --config-file packages/modelparams-python/pyproject.toml packages/modelparams-python/src/modelparams packages/modelparams-python/tests/typecheck + uv build --project packages/modelparams-python + uv run --project packages/modelparams-python twine check packages/modelparams-python/dist/* + + - name: Smoke-test installed wheel + if: steps.bump.outputs.next != '' + run: | + smoke_dir="$(mktemp -d)" + python -m venv "$smoke_dir/venv" + "$smoke_dir/venv/bin/pip" install packages/modelparams-python/dist/*.whl + cd "$smoke_dir" + "$smoke_dir/venv/bin/python" -c 'import modelparams; assert len(modelparams.MODEL_IDS) > 0; assert modelparams.validate_params("openai/gpt-4.1", {"temperature": 0.5}) == {"temperature": 0.5}' + + - name: Upload distributions + if: steps.bump.outputs.next != '' + uses: actions/upload-artifact@v4 + with: + name: modelparams-python-distributions + path: packages/modelparams-python/dist/ + if-no-files-found: error + + - name: Skip publish + if: steps.bump.outputs.next == '' + run: echo "::notice::No Python package or catalog change since the latest release." + + publish: + name: Publish to PyPI + needs: build + if: needs.build.outputs.next != '' + runs-on: ubuntu-latest + environment: pypi + permissions: + actions: read + contents: write + id-token: write + steps: + - name: Download distributions + uses: actions/download-artifact@v4 + with: + name: modelparams-python-distributions + path: dist/ + + - name: Publish to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + skip-existing: true + + - name: Create GitHub release and tag + uses: softprops/action-gh-release@v2 + with: + tag_name: "modelparams-py@${{ needs.build.outputs.next }}" + name: "modelparams-py@${{ needs.build.outputs.next }}" + target_commitish: ${{ github.sha }} + generate_release_notes: true diff --git a/.gitignore b/.gitignore index 7e6b631..b15779c 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,12 @@ node_modules/ packages/*/dist/ packages/*/*.tsbuildinfo .cache/ +.venv/ +.mypy_cache/ +.pytest_cache/ +.ruff_cache/ +__pycache__/ +*.py[cod] *.log .DS_Store .env diff --git a/.prettierignore b/.prettierignore index 730675a..d8bf1d2 100644 --- a/.prettierignore +++ b/.prettierignore @@ -5,4 +5,6 @@ coverage/ *.min.js *.min.css packages/modelparams/src/generated/ +packages/modelparams-python/src/modelparams/_generated/ +packages/modelparams-python/src/modelparams/types/ packages/*/dist/ diff --git a/README.md b/README.md index 016d4c3..c8a2ddd 100644 --- a/README.md +++ b/README.md @@ -36,6 +36,26 @@ await new OpenAI().chat.completions.create({ model: "gpt-4.1", messages, ...para Defaults, runtime validation, and the helper APIs are in the [package README](packages/modelparams/README.md). +## Python + +```bash +pip install modelparams +``` + +Generated `TypedDict` definitions provide model-specific autocomplete and static checking, while +Pydantic validates untrusted values at runtime: + +```python +from modelparams import validate_params +from modelparams.types.openai import Gpt_4_1Params + +params: Gpt_4_1Params = {"max_tokens": 1024, "temperature": 0.7} +validated = validate_params("openai/gpt-4.1", params) +``` + +Defaults, catalog helpers, and validation details are in the +[Python package README](packages/modelparams-python/README.md). + ## API Prefer raw JSON? @@ -58,6 +78,7 @@ npm install npm run dev # http://localhost:3000 npm run build # → dist/ npm run validate # check every YAML +npm run codegen:python # regenerate the Python package catalog and types npm test ``` diff --git a/package.json b/package.json index 8d10a9d..ce74629 100644 --- a/package.json +++ b/package.json @@ -21,6 +21,7 @@ }, "scripts": { "build": "tsx src/build/build.ts", + "codegen:python": "tsx packages/modelparams-python/scripts/codegen.ts", "dev": "tsx watch src/server/dev.ts", "validate": "tsx src/data/validate.ts", "guard:params": "tsx src/data/check-removals.ts", diff --git a/packages/modelparams-python/LICENSE b/packages/modelparams-python/LICENSE new file mode 100644 index 0000000..ca8c3f8 --- /dev/null +++ b/packages/modelparams-python/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 modelparams.dev contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packages/modelparams-python/README.md b/packages/modelparams-python/README.md new file mode 100644 index 0000000..cb0887c --- /dev/null +++ b/packages/modelparams-python/README.md @@ -0,0 +1,74 @@ +# modelparams + +Typed model parameters for Python, generated from the open +[modelparams.dev](https://modelparams.dev) catalog. + +```bash +pip install modelparams +``` + +## Typed request parameters + +Generated `TypedDict` definitions provide autocomplete and static errors for unsupported keys, +incorrect value types, and invalid enum values: + +```python +from modelparams import validate_params +from modelparams.types.openai import Gpt_4_1Params + +params: Gpt_4_1Params = { + "max_tokens": 1024, + "temperature": 0.7, +} + +validated = validate_params("openai/gpt-4.1", params) +``` + +`validate_params` uses a cached strict Pydantic adapter. It returns a provider-keyed dictionary or +raises `pydantic.ValidationError` for unknown parameters, coercions, invalid enum values, or values +outside the catalog range. + +```python +from openai import OpenAI + +OpenAI().chat.completions.create(model="gpt-4.1", messages=messages, **validated) +``` + +Provider-specific dot paths remain literal dictionary keys: + +```python +from modelparams.types.anthropic import Claude_Haiku_4_5_20251001Params + +params: Claude_Haiku_4_5_20251001Params = { + "thinking.type": "enabled", + "thinking.budget_tokens": 4096, +} +``` + +## Catalog helpers + +```python +from modelparams import get_defaults, get_model, get_param, list_models + +model = get_model("anthropic/claude-haiku-4-5-20251001") +print(model.auth_type, model.params) + +defaults = get_defaults("anthropic/claude-haiku-4-5-20251001") +thinking = get_param("anthropic/claude-haiku-4-5-20251001", "thinking.type") +anthropic_models = list_models("anthropic") +``` + +The catalog is bundled with the package. No network request is made at runtime. + +## Development + +From the repository root: + +```bash +npm run codegen:python +uv sync --project packages/modelparams-python --extra dev +uv run --project packages/modelparams-python pytest packages/modelparams-python/tests +``` + +Generated catalog and type files are committed and verified in CI. Python releases use independent +`modelparams-py@x.y.z` tags and publish to PyPI through the repository's trusted-publisher workflow. diff --git a/packages/modelparams-python/pyproject.toml b/packages/modelparams-python/pyproject.toml new file mode 100644 index 0000000..f3d6eef --- /dev/null +++ b/packages/modelparams-python/pyproject.toml @@ -0,0 +1,63 @@ +[build-system] +requires = ["hatchling>=1.27"] +build-backend = "hatchling.build" + +[project] +name = "modelparams" +version = "0.0.1" +description = "Typed model parameters for Python, generated from the modelparams.dev catalog." +readme = "README.md" +requires-python = ">=3.10" +license = "MIT" +license-files = ["LICENSE"] +authors = [{ name = "modelparams.dev contributors" }] +keywords = ["ai", "llm", "model-parameters", "pydantic", "typing"] +classifiers = [ + "Development Status :: 3 - Alpha", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", + "Typing :: Typed", +] +dependencies = ["pydantic>=2.10,<3", "typing-extensions>=4.12"] + +[project.urls] +Homepage = "https://modelparams.dev" +Repository = "https://github.com/mnfst/modelparameters.dev" +Issues = "https://github.com/mnfst/modelparameters.dev/issues" + +[project.optional-dependencies] +dev = [ + "build>=1.2", + "mypy>=1.13", + "pytest>=8.3", + "ruff>=0.9", + "twine>=6.0", +] + +[tool.hatch.build.targets.wheel] +packages = ["src/modelparams"] + +[tool.hatch.build.targets.sdist] +include = ["/LICENSE", "/README.md", "/pyproject.toml", "/src"] + +[tool.pytest.ini_options] +addopts = "-q" +testpaths = ["tests"] + +[tool.ruff] +target-version = "py310" +line-length = 100 +extend-exclude = ["src/modelparams/_generated", "src/modelparams/types"] + +[tool.ruff.lint] +select = ["B", "E", "F", "I", "UP"] + +[tool.mypy] +python_version = "3.10" +strict = true +warn_unused_ignores = true +files = ["src/modelparams", "tests/typecheck"] diff --git a/packages/modelparams-python/scripts/codegen.ts b/packages/modelparams-python/scripts/codegen.ts new file mode 100644 index 0000000..1f870d0 --- /dev/null +++ b/packages/modelparams-python/scripts/codegen.ts @@ -0,0 +1,235 @@ +import fs from "node:fs/promises"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; +import { loadAllModels } from "../../../src/data/load.js"; +import { modelId, type Model, type Parameter } from "../../../src/schema/model.js"; + +const here = path.dirname(fileURLToPath(import.meta.url)); +const PACKAGE_DIR = path.resolve(here, ".."); +const PYTHON_PACKAGE_DIR = path.join(PACKAGE_DIR, "src", "modelparams"); +const GENERATED_DIR = path.join(PYTHON_PACKAGE_DIR, "_generated"); +const TYPES_DIR = path.join(PYTHON_PACKAGE_DIR, "types"); + +const HEADER = + "# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts.\n" + + "# Do not edit by hand; the YAML catalog under /models is the source of truth.\n\n"; + +function pythonString(value: string): string { + return JSON.stringify(value); +} + +function pythonLiteral(value: string | number | boolean | null): string { + if (value === null) return "None"; + if (value === true) return "True"; + if (value === false) return "False"; + if (typeof value === "number" && !Number.isInteger(value)) { + throw new Error( + `Python typing.Literal cannot represent the non-integer enum value ${JSON.stringify(value)}`, + ); + } + return typeof value === "string" ? pythonString(value) : String(value); +} + +function moduleName(provider: string): string { + return provider.replace(/-/g, "_"); +} + +function typeName(model: Pick): string { + const suffix = model.authType === "subscription" ? "-subscription" : ""; + const words = `${model.model}${suffix}`.split(/[^A-Za-z0-9]+/).filter(Boolean); + const base = words + .map((word) => `${word[0]!.toUpperCase()}${word.slice(1).toLowerCase()}`) + .join("_"); + return `${/^\d/.test(base) ? "Model_" : ""}${base}Params`; +} + +function numericType(base: "int" | "float", parameter: Parameter): string { + if (parameter.type !== "integer" && parameter.type !== "number") return base; + const constraints: string[] = []; + if (parameter.range?.min !== undefined) constraints.push(`ge=${parameter.range.min}`); + if (parameter.range?.max !== undefined) constraints.push(`le=${parameter.range.max}`); + return constraints.length > 0 ? `Annotated[${base}, Field(${constraints.join(", ")})]` : base; +} + +function pythonType(parameter: Parameter): string { + switch (parameter.type) { + case "boolean": + return "bool"; + case "integer": + return numericType("int", parameter); + case "number": + return numericType("float", parameter); + case "string": + return "str"; + case "enum": + return `Literal[${parameter.values.map(pythonLiteral).join(", ")}]`; + } +} + +function emitProviderTypes(provider: string, models: Model[]): string { + const entries = models.map((model) => { + const name = typeName(model); + const fields = model.params + .map((parameter) => ` ${pythonString(parameter.path)}: ${pythonType(parameter)},`) + .join("\n"); + return ( + `${name} = TypedDict(\n` + + ` ${pythonString(name)},\n` + + ` {\n${fields}\n },\n` + + ` total=False,\n` + + `)\n` + + `setattr(${name}, "__pydantic_config__", _PARAMS_CONFIG)\n` + ); + }); + + return ( + HEADER + + `# ruff: noqa: F401\n\n` + + `from typing import Annotated, Literal\n\n` + + `from pydantic import ConfigDict, Field\n` + + `from typing_extensions import TypedDict\n\n` + + `_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid")\n\n` + + entries.join("\n") + + `\n__all__ = [\n${models.map((model) => ` ${pythonString(typeName(model))},`).join("\n")}\n]\n` + ); +} + +function emitLiteralType(name: string, values: string[]): string { + return `${name} = Literal[\n${values.map((value) => ` ${pythonString(value)},`).join("\n")}\n]\n`; +} + +function emitModelIds(models: Model[]): string { + const ids = models.map(modelId); + const providers = [...new Set(models.map((model) => model.provider))].sort(); + return ( + HEADER + + `from typing import Literal\n\n` + + emitLiteralType("ModelId", ids) + + `\nMODEL_IDS: tuple[ModelId, ...] = (\n${ids.map((id) => ` ${pythonString(id)},`).join("\n")}\n)\n\n` + + emitLiteralType("Provider", providers) + + `\nPROVIDERS: tuple[Provider, ...] = (\n${providers.map((provider) => ` ${pythonString(provider)},`).join("\n")}\n)\n` + ); +} + +function emitRegistry(models: Model[]): string { + const providers = [...new Set(models.map((model) => model.provider))].sort(); + const imports = providers + .map((provider) => `from modelparams.types import ${moduleName(provider)}`) + .join("\n"); + const entries = models + .map( + (model) => + ` ${pythonString(modelId(model))}: ${moduleName(model.provider)}.${typeName(model)},`, + ) + .join("\n"); + return ( + HEADER + + `from typing import Any\n\n` + + `${imports}\n\n` + + `from .model_ids import ModelId\n\n` + + `PARAM_TYPES: dict[ModelId, Any] = {\n${entries}\n}\n` + ); +} + +function assertUniqueNames(models: Model[]): void { + const modules = new Map(); + const types = new Map(); + for (const model of models) { + const module = moduleName(model.provider); + const previousProvider = modules.get(module); + if (previousProvider && previousProvider !== model.provider) { + throw new Error( + `provider module collision: ${JSON.stringify(previousProvider)} and ${JSON.stringify(model.provider)} both map to ${JSON.stringify(module)}`, + ); + } + modules.set(module, model.provider); + + const key = `${module}.${typeName(model)}`; + const id = modelId(model); + const previousId = types.get(key); + if (previousId) { + throw new Error( + `generated type collision: ${JSON.stringify(previousId)} and ${JSON.stringify(id)} both map to ${key}`, + ); + } + types.set(key, id); + } +} + +async function removeStaleTypeModules(expected: Set): Promise { + let entries: string[] = []; + try { + entries = await fs.readdir(TYPES_DIR); + } catch (error) { + if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error; + } + await Promise.all( + entries + .filter((entry) => entry.endsWith(".py") && !expected.has(entry)) + .map((entry) => fs.unlink(path.join(TYPES_DIR, entry))), + ); +} + +async function main(): Promise { + const { models, issues } = await loadAllModels(); + if (issues.length > 0) { + console.error(`Catalog has ${issues.length} validation issue(s); refusing to codegen:`); + for (const issue of issues) console.error(` ${issue.file}: ${issue.message}`); + process.exit(1); + } + + assertUniqueNames(models); + await fs.mkdir(GENERATED_DIR, { recursive: true }); + await fs.mkdir(TYPES_DIR, { recursive: true }); + + const byProvider = new Map(); + for (const model of models) { + const providerModels = byProvider.get(model.provider) ?? []; + providerModels.push(model); + byProvider.set(model.provider, providerModels); + } + + const typeFiles = new Set(["__init__.py"]); + for (const [provider, providerModels] of byProvider) { + const filename = `${moduleName(provider)}.py`; + typeFiles.add(filename); + await fs.writeFile( + path.join(TYPES_DIR, filename), + emitProviderTypes(provider, providerModels), + "utf8", + ); + } + await removeStaleTypeModules(typeFiles); + + const modules = [...byProvider.keys()].sort().map(moduleName); + await Promise.all([ + fs.writeFile( + path.join(GENERATED_DIR, "catalog.json"), + `${JSON.stringify(models, null, 2)}\n`, + "utf8", + ), + fs.writeFile(path.join(GENERATED_DIR, "model_ids.py"), emitModelIds(models), "utf8"), + fs.writeFile(path.join(GENERATED_DIR, "registry.py"), emitRegistry(models), "utf8"), + fs.writeFile(path.join(GENERATED_DIR, "__init__.py"), `${HEADER.trimEnd()}\n`, "utf8"), + fs.writeFile( + path.join(TYPES_DIR, "__init__.py"), + `${HEADER}__all__ = [${modules.map(pythonString).join(", ")}]\n`, + "utf8", + ), + ]); + + console.log( + `python codegen: wrote catalog and request types for ${models.length} models across ${byProvider.size} providers`, + ); +} + +const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url); + +if (isMain) { + main().catch((error) => { + console.error("python codegen crashed:", error); + process.exit(1); + }); +} + +export { pythonLiteral, typeName }; diff --git a/packages/modelparams-python/scripts/compute-version.ts b/packages/modelparams-python/scripts/compute-version.ts new file mode 100644 index 0000000..47604e4 --- /dev/null +++ b/packages/modelparams-python/scripts/compute-version.ts @@ -0,0 +1,101 @@ +import fs from "node:fs"; +import path from "node:path"; +import { execFileSync, spawnSync } from "node:child_process"; +import { fileURLToPath } from "node:url"; +import { loadModelsAtRef } from "../../../src/data/git-baseline.js"; +import { loadAllModels } from "../../../src/data/load.js"; +import { findRemovedParams } from "../../../src/data/removals.js"; +import { canonicalCatalog, type BumpLevel } from "../../modelparams/scripts/lib/version.js"; +import { compareVersions, decidePythonRelease } from "./lib/version.js"; + +const here = path.dirname(fileURLToPath(import.meta.url)); +const PACKAGE_DIR = path.resolve(here, ".."); +const TAG_PREFIX = "modelparams-py@"; + +function readLatestTag(): { tag: string; version: string } | null { + const output = execFileSync("git", ["tag", "--list", `${TAG_PREFIX}*`], { + encoding: "utf8", + }); + const versions = output + .split("\n") + .map((line) => line.trim()) + .filter((line) => line.startsWith(TAG_PREFIX)) + .map((tag) => ({ tag, version: tag.slice(TAG_PREFIX.length) })) + .filter(({ version }) => /^\d+\.\d+\.\d+$/.test(version)) + .sort((a, b) => compareVersions(b.version, a.version)); + return versions[0] ?? null; +} + +function readSeedVersion(): string { + const pyproject = fs.readFileSync(path.join(PACKAGE_DIR, "pyproject.toml"), "utf8"); + const match = /^version\s*=\s*"(\d+\.\d+\.\d+)"\s*$/m.exec(pyproject); + if (!match) throw new Error("could not read project.version from pyproject.toml"); + return match[1]!; +} + +function readForcedLevel(): BumpLevel | null { + const forced = (process.env.FORCE_LEVEL ?? "").trim(); + return forced === "major" || forced === "patch" ? forced : null; +} + +function packageChangedSince(ref: string): boolean { + const result = spawnSync("git", ["diff", "--quiet", `${ref}..HEAD`, "--", PACKAGE_DIR]); + if (result.status === 0) return false; + if (result.status === 1) return true; + throw new Error(result.stderr.toString() || "git diff failed"); +} + +function emit(name: string, value: string): void { + const line = `${name}=${value}\n`; + if (process.env.GITHUB_OUTPUT) fs.appendFileSync(process.env.GITHUB_OUTPUT, line); + process.stdout.write(line); +} + +async function main(): Promise { + const { models: current, issues } = await loadAllModels(); + if (issues.length > 0) { + for (const issue of issues) console.error(`${issue.file}: ${issue.message}`); + throw new Error(`catalog has ${issues.length} validation issue(s)`); + } + + const latest = readLatestTag(); + let catalogChanged = true; + let packageChanged = true; + let hasParamRemovals = false; + + if (latest) { + const base = await loadModelsAtRef(latest.tag); + catalogChanged = canonicalCatalog(base) !== canonicalCatalog(current); + hasParamRemovals = findRemovedParams(base, current).length > 0; + packageChanged = packageChangedSince(latest.tag); + } + + const decision = decidePythonRelease({ + seedVersion: readSeedVersion(), + latestVersion: latest?.version ?? null, + forcedLevel: readForcedLevel(), + catalogChanged, + packageChanged, + hasParamRemovals, + }); + + if (decision.nextVersion === null) { + console.error("No Python package or catalog change since the latest Python release."); + emit("level", ""); + emit("next", ""); + return; + } + + console.error( + latest + ? `Python release: ${latest.version} -> ${decision.nextVersion} (${decision.level})` + : `First Python release: ${decision.nextVersion}`, + ); + emit("level", decision.level ?? "patch"); + emit("next", decision.nextVersion); +} + +main().catch((error) => { + console.error("Python version computation failed:", error); + process.exit(1); +}); diff --git a/packages/modelparams-python/scripts/lib/version.ts b/packages/modelparams-python/scripts/lib/version.ts new file mode 100644 index 0000000..7a52c42 --- /dev/null +++ b/packages/modelparams-python/scripts/lib/version.ts @@ -0,0 +1,45 @@ +import { bumpVersion, type BumpLevel } from "../../../modelparams/scripts/lib/version.js"; + +export interface PythonReleaseInput { + seedVersion: string; + latestVersion: string | null; + forcedLevel: BumpLevel | null; + catalogChanged: boolean; + packageChanged: boolean; + hasParamRemovals: boolean; +} + +export interface PythonReleaseDecision { + level: BumpLevel | null; + nextVersion: string | null; +} + +export function compareVersions(left: string, right: string): number { + const leftParts = left.split(".").map(Number); + const rightParts = right.split(".").map(Number); + for (let index = 0; index < 3; index += 1) { + const leftPart = leftParts[index] ?? 0; + const rightPart = rightParts[index] ?? 0; + if (leftPart < rightPart) return -1; + if (leftPart > rightPart) return 1; + } + return 0; +} + +export function decidePythonRelease(input: PythonReleaseInput): PythonReleaseDecision { + if (input.latestVersion === null) { + return { level: input.forcedLevel ?? "patch", nextVersion: input.seedVersion }; + } + + const level = + input.forcedLevel ?? + (input.hasParamRemovals + ? "major" + : input.catalogChanged || input.packageChanged + ? "patch" + : null); + return { + level, + nextVersion: level === null ? null : bumpVersion(input.latestVersion, level), + }; +} diff --git a/packages/modelparams-python/src/modelparams/__init__.py b/packages/modelparams-python/src/modelparams/__init__.py new file mode 100644 index 0000000..7c97668 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/__init__.py @@ -0,0 +1,60 @@ +from importlib import metadata + +from ._generated.model_ids import MODEL_IDS, PROVIDERS, ModelId, Provider +from .catalog import ( + BY_ID, + CATALOG, + DEFAULTS, + get_defaults, + get_model, + get_param, + list_all_models, + list_models, +) +from .models import ( + Applicability, + ApplicabilityCondition, + CatalogEntry, + JsonPrimitive, + Parameter, + ParamGroup, + ParamRange, + ParamType, +) +from .validation import params_adapter, validate_params + + +def _package_version() -> str: + try: + return metadata.version("modelparams") + except metadata.PackageNotFoundError: + return "0+unknown" + + +__version__ = _package_version() + +__all__ = [ + "BY_ID", + "CATALOG", + "DEFAULTS", + "MODEL_IDS", + "PROVIDERS", + "Applicability", + "ApplicabilityCondition", + "CatalogEntry", + "JsonPrimitive", + "ModelId", + "Parameter", + "ParamGroup", + "ParamRange", + "ParamType", + "Provider", + "__version__", + "get_defaults", + "get_model", + "get_param", + "list_all_models", + "list_models", + "params_adapter", + "validate_params", +] diff --git a/packages/modelparams-python/src/modelparams/_generated/__init__.py b/packages/modelparams-python/src/modelparams/_generated/__init__.py new file mode 100644 index 0000000..8dbaf30 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/_generated/__init__.py @@ -0,0 +1,2 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. diff --git a/packages/modelparams-python/src/modelparams/_generated/catalog.json b/packages/modelparams-python/src/modelparams/_generated/catalog.json new file mode 100644 index 0000000..48f4c21 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/_generated/catalog.json @@ -0,0 +1,16420 @@ +[ + { + "provider": "alibaba", + "authType": "api_key", + "model": "qwen-flash", + "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", + "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.", + "group": "sampling", + "type": "integer", + "default": 20, + "range": { + "min": 1 + } + }, + { + "path": "extra_body.chat_template_kwargs.enable_thinking", + "label": "Enable thinking", + "description": "Controls Qwen3 thinking mode when using OpenAI-compatible clients that pass provider-specific extra body fields.", + "group": "reasoning", + "type": "boolean", + "default": true + } + ] + }, + { + "provider": "alibaba", + "authType": "api_key", + "model": "qwen-plus", + "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", + "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.", + "group": "sampling", + "type": "integer", + "default": 20, + "range": { + "min": 1 + } + }, + { + "path": "extra_body.chat_template_kwargs.enable_thinking", + "label": "Enable thinking", + "description": "Controls Qwen3 thinking mode when using OpenAI-compatible clients that pass provider-specific extra body fields.", + "group": "reasoning", + "type": "boolean", + "default": true + } + ] + }, + { + "provider": "alibaba", + "authType": "api_key", + "model": "qwen3-coder-flash", + "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", + "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.", + "group": "sampling", + "type": "integer", + "default": 20, + "range": { + "min": 1 + } + } + ] + }, + { + "provider": "alibaba", + "authType": "api_key", + "model": "qwen3-coder-plus", + "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", + "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.", + "group": "sampling", + "type": "integer", + "default": 20, + "range": { + "min": 1 + } + } + ] + }, + { + "provider": "alibaba", + "authType": "api_key", + "model": "qwen3-max", + "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", + "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.", + "group": "sampling", + "type": "integer", + "default": 20, + "range": { + "min": 1 + } + }, + { + "path": "extra_body.chat_template_kwargs.enable_thinking", + "label": "Enable thinking", + "description": "Controls Qwen3 thinking mode when using OpenAI-compatible clients that pass provider-specific extra body fields.", + "group": "reasoning", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "alibaba", + "authType": "api_key", + "model": "qwen3.5", + "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", + "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.", + "group": "sampling", + "type": "integer", + "default": 20, + "range": { + "min": 1 + } + }, + { + "path": "extra_body.chat_template_kwargs.enable_thinking", + "label": "Enable thinking", + "description": "Controls Qwen3 thinking mode when using OpenAI-compatible clients that pass provider-specific extra body fields.", + "group": "reasoning", + "type": "boolean", + "default": true + } + ] + }, + { + "provider": "alibaba", + "authType": "api_key", + "model": "qwen3.5-flash", + "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", + "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.", + "group": "sampling", + "type": "integer", + "default": 20, + "range": { + "min": 1 + } + }, + { + "path": "extra_body.chat_template_kwargs.enable_thinking", + "label": "Enable thinking", + "description": "Controls Qwen3 thinking mode when using OpenAI-compatible clients that pass provider-specific extra body fields.", + "group": "reasoning", + "type": "boolean", + "default": true + } + ] + }, + { + "provider": "alibaba", + "authType": "api_key", + "model": "qwq-plus", + "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", + "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.", + "group": "sampling", + "type": "integer", + "default": 20, + "range": { + "min": 1 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-3-5-haiku-20241022", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-3-5-haiku-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-3-5-sonnet-20241022", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-3-5-sonnet-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-3-7-sonnet-20250219", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-3-7-sonnet-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-3-opus-20240229", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-3-opus-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-fable-5", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Only adaptive thinking is supported; omit the parameter entirely to run without thinking (an explicit disabled value is rejected).", + "group": "reasoning", + "type": "enum", + "values": [ + "adaptive" + ] + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "adaptive" + ] + } + }, + "type": "enum", + "default": "omitted", + "values": [ + "summarized", + "omitted" + ] + }, + { + "path": "output_config.effort", + "label": "Effort", + "description": "Controls Anthropic response thoroughness and token spend.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high", + "xhigh", + "max" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-fable-5", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Only adaptive thinking is supported; omit the parameter entirely to run without thinking (an explicit disabled value is rejected).", + "group": "reasoning", + "type": "enum", + "values": [ + "adaptive" + ] + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "adaptive" + ] + } + }, + "type": "enum", + "default": "omitted", + "values": [ + "summarized", + "omitted" + ] + }, + { + "path": "output_config.effort", + "label": "Effort", + "description": "Controls Anthropic response thoroughness and token spend.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high", + "xhigh", + "max" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-haiku-4", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-haiku-4-5", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-haiku-4-5-20251001", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "top_p": { + "not": null + } + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "temperature": { + "not": null + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-haiku-4-5-20251001", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "top_p": { + "not": null + } + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "temperature": { + "not": null + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-haiku-4-5", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-haiku-4", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-opus-4-1-20250805", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "top_p": { + "not": null + } + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "temperature": { + "not": null + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "enum", + "default": "summarized", + "values": [ + "summarized", + "omitted" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-opus-4-1-20250805", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "top_p": { + "not": null + } + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "temperature": { + "not": null + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "enum", + "default": "summarized", + "values": [ + "summarized", + "omitted" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-opus-4-20250514", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "enum", + "default": "summarized", + "values": [ + "summarized", + "omitted" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-opus-4-20250514", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "enum", + "default": "summarized", + "values": [ + "summarized", + "omitted" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-opus-4-5-20251101", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "top_p": { + "not": null + } + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "temperature": { + "not": null + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "enum", + "default": "summarized", + "values": [ + "summarized", + "omitted" + ] + }, + { + "path": "output_config.effort", + "label": "Effort", + "description": "Controls Anthropic response thoroughness and token spend.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-opus-4-5-20251101", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "top_p": { + "not": null + } + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "temperature": { + "not": null + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "enum", + "default": "summarized", + "values": [ + "summarized", + "omitted" + ] + }, + { + "path": "output_config.effort", + "label": "Effort", + "description": "Controls Anthropic response thoroughness and token spend.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-opus-4-6", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled", + "adaptive" + ] + }, + { + "top_p": { + "not": null + } + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled", + "adaptive" + ] + }, + { + "temperature": { + "not": null + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled", + "adaptive" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "adaptive", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "enum", + "default": "summarized", + "values": [ + "summarized", + "omitted" + ] + }, + { + "path": "output_config.effort", + "label": "Effort", + "description": "Controls Anthropic response thoroughness and token spend.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high", + "max" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-opus-4-6", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled", + "adaptive" + ] + }, + { + "top_p": { + "not": null + } + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled", + "adaptive" + ] + }, + { + "temperature": { + "not": null + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled", + "adaptive" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "adaptive", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "enum", + "default": "summarized", + "values": [ + "summarized", + "omitted" + ] + }, + { + "path": "output_config.effort", + "label": "Effort", + "description": "Controls Anthropic response thoroughness and token spend.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high", + "max" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-opus-4-7", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "adaptive" + ] + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "adaptive" + ] + } + }, + "type": "enum", + "default": "omitted", + "values": [ + "summarized", + "omitted" + ] + }, + { + "path": "output_config.effort", + "label": "Effort", + "description": "Controls Anthropic response thoroughness and token spend.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high", + "xhigh", + "max" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-opus-4-7", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "adaptive" + ] + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "adaptive" + ] + } + }, + "type": "enum", + "default": "omitted", + "values": [ + "summarized", + "omitted" + ] + }, + { + "path": "output_config.effort", + "label": "Effort", + "description": "Controls Anthropic response thoroughness and token spend.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high", + "xhigh", + "max" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-opus-4-8", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "adaptive" + ] + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "adaptive" + ] + } + }, + "type": "enum", + "default": "omitted", + "values": [ + "summarized", + "omitted" + ] + }, + { + "path": "output_config.effort", + "label": "Effort", + "description": "Controls Anthropic response thoroughness and token spend.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high", + "xhigh", + "max" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-opus-4-8", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "adaptive" + ] + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "adaptive" + ] + } + }, + "type": "enum", + "default": "omitted", + "values": [ + "summarized", + "omitted" + ] + }, + { + "path": "output_config.effort", + "label": "Effort", + "description": "Controls Anthropic response thoroughness and token spend.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high", + "xhigh", + "max" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-opus-4", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "adaptive", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-sonnet-4-20250514", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "enum", + "default": "summarized", + "values": [ + "summarized", + "omitted" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-sonnet-4-20250514", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "enum", + "default": "summarized", + "values": [ + "summarized", + "omitted" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-sonnet-4-5", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "adaptive", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-sonnet-4-5-20250929", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "top_p": { + "not": null + } + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "temperature": { + "not": null + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-sonnet-4-5-20250929", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "top_p": { + "not": null + } + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled" + ] + }, + { + "temperature": { + "not": null + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-sonnet-4-5", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "adaptive", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-sonnet-4-6", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled", + "adaptive" + ] + }, + { + "top_p": { + "not": null + } + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled", + "adaptive" + ] + }, + { + "temperature": { + "not": null + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled", + "adaptive" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "adaptive", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "enum", + "default": "summarized", + "values": [ + "summarized", + "omitted" + ] + }, + { + "path": "output_config.effort", + "label": "Effort", + "description": "Controls Anthropic response thoroughness and token spend.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high", + "max" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-sonnet-4-6", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled", + "adaptive" + ] + }, + { + "top_p": { + "not": null + } + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "enabled", + "adaptive" + ] + }, + { + "temperature": { + "not": null + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled", + "adaptive" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "adaptive", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "enum", + "default": "summarized", + "values": [ + "summarized", + "omitted" + ] + }, + { + "path": "output_config.effort", + "label": "Effort", + "description": "Controls Anthropic response thoroughness and token spend.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high", + "max" + ] + } + ] + }, + { + "provider": "anthropic", + "authType": "subscription", + "model": "claude-sonnet-4", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive", + "enabled" + ] + }, + { + "temperature": { + "not": 1 + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive", + "enabled" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "adaptive", + "enabled" + ] + }, + { + "path": "thinking.budget_tokens", + "label": "Budget tokens", + "description": "Maximum token budget Anthropic may use for extended thinking before producing the final answer.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "default": 4096, + "range": { + "min": 1024 + } + } + ] + }, + { + "provider": "anthropic", + "authType": "api_key", + "model": "claude-sonnet-5", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive" + ] + }, + { + "top_p": { + "not": null + } + } + ] + }, + "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 whose cumulative probability reaches this value.", + "group": "sampling", + "applicability": { + "except": [ + { + "thinking.type": [ + "adaptive" + ] + }, + { + "temperature": { + "not": null + } + } + ] + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits token sampling to the top K most likely next tokens.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "adaptive" + ] + } + }, + "type": "integer", + "default": 0, + "range": { + "min": 0 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls the Anthropic thinking mode values supported by this model.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "adaptive" + ] + }, + { + "path": "thinking.display", + "label": "Thinking display", + "description": "Controls whether Anthropic returns summarized or omitted thinking content.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": [ + "adaptive" + ] + } + }, + "type": "enum", + "default": "summarized", + "values": [ + "summarized", + "omitted" + ] + }, + { + "path": "output_config.effort", + "label": "Effort", + "description": "Controls Anthropic response thoroughness and token spend.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high", + "max" + ] + } + ] + }, + { + "provider": "cerebras", + "authType": "api_key", + "model": "zai-glm-4.7", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate, including reasoning tokens.", + "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. Adjust this or top_p, not both.", + "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": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes tokens by how often they have appeared, reducing verbatim repetition.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes tokens that have already appeared, encouraging the model to introduce new topics.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Seed used for best-effort deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "stop", + "label": "Stop", + "description": "A string or list of strings where the API will stop generating further tokens. Cerebras accepts up to four stop sequences.", + "group": "generation_length", + "type": "string" + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning the model performs before answering. 'none' disables reasoning.", + "group": "reasoning", + "type": "enum", + "values": [ + "none", + "low", + "medium", + "high" + ] + }, + { + "path": "clear_thinking", + "label": "Clear thinking", + "description": "When true, the model's thinking from previous turns is excluded from the conversation context; when false, it is preserved, which is useful for agentic workflows.", + "group": "reasoning", + "type": "boolean", + "default": true + }, + { + "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": "cohere", + "authType": "api_key", + "model": "command-a-03-2025", + "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": "stop_sequences", + "label": "Stop sequences", + "description": "Stops generation when one of these sequences is detected; up to five are allowed.", + "group": "generation_length", + "type": "string" + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 0.3, + "range": { + "min": 0, + "step": 0.1 + } + }, + { + "path": "p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.75, + "range": { + "min": 0.01, + "max": 0.99, + "step": 0.01 + } + }, + { + "path": "k", + "label": "Top K", + "description": "Limits sampling to the K most likely tokens; 0 disables top-k sampling.", + "group": "sampling", + "type": "integer", + "default": 0, + "range": { + "min": 0, + "max": 500 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes tokens proportional to how often they have already appeared to reduce repetition.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes tokens that have already appeared to encourage a wider variety of content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Seed used for best-effort deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON object output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "logprobs", + "label": "Log probabilities", + "description": "Controls whether the response includes log probabilities for the generated tokens.", + "group": "observability", + "type": "boolean", + "default": false + }, + { + "path": "tool_choice", + "label": "Tool choice", + "description": "Forces the model to either call a tool or skip tool calls for this request.", + "group": "tooling", + "type": "enum", + "values": [ + "REQUIRED", + "NONE" + ] + }, + { + "path": "safety_mode", + "label": "Safety mode", + "description": "Controls Cohere's built-in safety instructions applied to the generation.", + "group": "provider_metadata", + "type": "enum", + "default": "CONTEXTUAL", + "values": [ + "CONTEXTUAL", + "STRICT" + ] + } + ] + }, + { + "provider": "cohere", + "authType": "api_key", + "model": "command-a-plus-05-2026", + "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": "stop_sequences", + "label": "Stop sequences", + "description": "Stops generation when one of these sequences is detected; up to five are allowed.", + "group": "generation_length", + "type": "string" + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 0.3, + "range": { + "min": 0, + "step": 0.1 + } + }, + { + "path": "p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.75, + "range": { + "min": 0.01, + "max": 0.99, + "step": 0.01 + } + }, + { + "path": "k", + "label": "Top K", + "description": "Limits sampling to the K most likely tokens; 0 disables top-k sampling.", + "group": "sampling", + "type": "integer", + "default": 0, + "range": { + "min": 0, + "max": 500 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes tokens proportional to how often they have already appeared to reduce repetition.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes tokens that have already appeared to encourage a wider variety of content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Seed used for best-effort deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON object output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "logprobs", + "label": "Log probabilities", + "description": "Controls whether the response includes log probabilities for the generated tokens.", + "group": "observability", + "type": "boolean", + "default": false + }, + { + "path": "tool_choice", + "label": "Tool choice", + "description": "Forces the model to either call a tool or skip tool calls for this request.", + "group": "tooling", + "type": "enum", + "values": [ + "REQUIRED", + "NONE" + ] + }, + { + "path": "safety_mode", + "label": "Safety mode", + "description": "Controls Cohere's built-in safety instructions applied to the generation.", + "group": "provider_metadata", + "type": "enum", + "default": "CONTEXTUAL", + "values": [ + "CONTEXTUAL", + "STRICT" + ] + } + ] + }, + { + "provider": "cohere", + "authType": "api_key", + "model": "command-a-reasoning-08-2025", + "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": "stop_sequences", + "label": "Stop sequences", + "description": "Stops generation when one of these sequences is detected; up to five are allowed.", + "group": "generation_length", + "type": "string" + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 0.3, + "range": { + "min": 0, + "step": 0.1 + } + }, + { + "path": "p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.75, + "range": { + "min": 0.01, + "max": 0.99, + "step": 0.01 + } + }, + { + "path": "k", + "label": "Top K", + "description": "Limits sampling to the K most likely tokens; 0 disables top-k sampling.", + "group": "sampling", + "type": "integer", + "default": 0, + "range": { + "min": 0, + "max": 500 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes tokens proportional to how often they have already appeared to reduce repetition.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes tokens that have already appeared to encourage a wider variety of content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Seed used for best-effort deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls whether the model reasons step by step before producing its final answer.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "enabled", + "disabled" + ] + }, + { + "path": "thinking.token_budget", + "label": "Thinking token budget", + "description": "Maximum number of tokens the model may spend on reasoning before answering.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON object output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "logprobs", + "label": "Log probabilities", + "description": "Controls whether the response includes log probabilities for the generated tokens.", + "group": "observability", + "type": "boolean", + "default": false + }, + { + "path": "tool_choice", + "label": "Tool choice", + "description": "Forces the model to either call a tool or skip tool calls for this request.", + "group": "tooling", + "type": "enum", + "values": [ + "REQUIRED", + "NONE" + ] + }, + { + "path": "safety_mode", + "label": "Safety mode", + "description": "Controls Cohere's built-in safety instructions applied to the generation.", + "group": "provider_metadata", + "type": "enum", + "default": "CONTEXTUAL", + "values": [ + "CONTEXTUAL", + "STRICT" + ] + } + ] + }, + { + "provider": "cohere", + "authType": "api_key", + "model": "command-a-translate-08-2025", + "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": "stop_sequences", + "label": "Stop sequences", + "description": "Stops generation when one of these sequences is detected; up to five are allowed.", + "group": "generation_length", + "type": "string" + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 0.3, + "range": { + "min": 0, + "step": 0.1 + } + }, + { + "path": "p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.75, + "range": { + "min": 0.01, + "max": 0.99, + "step": 0.01 + } + }, + { + "path": "k", + "label": "Top K", + "description": "Limits sampling to the K most likely tokens; 0 disables top-k sampling.", + "group": "sampling", + "type": "integer", + "default": 0, + "range": { + "min": 0, + "max": 500 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes tokens proportional to how often they have already appeared to reduce repetition.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes tokens that have already appeared to encourage a wider variety of content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Seed used for best-effort deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON object output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "logprobs", + "label": "Log probabilities", + "description": "Controls whether the response includes log probabilities for the generated tokens.", + "group": "observability", + "type": "boolean", + "default": false + }, + { + "path": "tool_choice", + "label": "Tool choice", + "description": "Forces the model to either call a tool or skip tool calls for this request.", + "group": "tooling", + "type": "enum", + "values": [ + "REQUIRED", + "NONE" + ] + }, + { + "path": "safety_mode", + "label": "Safety mode", + "description": "Controls Cohere's built-in safety instructions applied to the generation.", + "group": "provider_metadata", + "type": "enum", + "default": "CONTEXTUAL", + "values": [ + "CONTEXTUAL", + "STRICT" + ] + } + ] + }, + { + "provider": "cohere", + "authType": "api_key", + "model": "command-a-vision-07-2025", + "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": "stop_sequences", + "label": "Stop sequences", + "description": "Stops generation when one of these sequences is detected; up to five are allowed.", + "group": "generation_length", + "type": "string" + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 0.3, + "range": { + "min": 0, + "step": 0.1 + } + }, + { + "path": "p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.75, + "range": { + "min": 0.01, + "max": 0.99, + "step": 0.01 + } + }, + { + "path": "k", + "label": "Top K", + "description": "Limits sampling to the K most likely tokens; 0 disables top-k sampling.", + "group": "sampling", + "type": "integer", + "default": 0, + "range": { + "min": 0, + "max": 500 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes tokens proportional to how often they have already appeared to reduce repetition.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes tokens that have already appeared to encourage a wider variety of content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Seed used for best-effort deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON object output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "logprobs", + "label": "Log probabilities", + "description": "Controls whether the response includes log probabilities for the generated tokens.", + "group": "observability", + "type": "boolean", + "default": false + }, + { + "path": "tool_choice", + "label": "Tool choice", + "description": "Forces the model to either call a tool or skip tool calls for this request.", + "group": "tooling", + "type": "enum", + "values": [ + "REQUIRED", + "NONE" + ] + }, + { + "path": "safety_mode", + "label": "Safety mode", + "description": "Controls Cohere's built-in safety instructions applied to the generation.", + "group": "provider_metadata", + "type": "enum", + "default": "CONTEXTUAL", + "values": [ + "CONTEXTUAL", + "STRICT" + ] + } + ] + }, + { + "provider": "cohere", + "authType": "api_key", + "model": "command-r-08-2024", + "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": "stop_sequences", + "label": "Stop sequences", + "description": "Stops generation when one of these sequences is detected; up to five are allowed.", + "group": "generation_length", + "type": "string" + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 0.3, + "range": { + "min": 0, + "step": 0.1 + } + }, + { + "path": "p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.75, + "range": { + "min": 0.01, + "max": 0.99, + "step": 0.01 + } + }, + { + "path": "k", + "label": "Top K", + "description": "Limits sampling to the K most likely tokens; 0 disables top-k sampling.", + "group": "sampling", + "type": "integer", + "default": 0, + "range": { + "min": 0, + "max": 500 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes tokens proportional to how often they have already appeared to reduce repetition.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes tokens that have already appeared to encourage a wider variety of content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Seed used for best-effort deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON object output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "logprobs", + "label": "Log probabilities", + "description": "Controls whether the response includes log probabilities for the generated tokens.", + "group": "observability", + "type": "boolean", + "default": false + }, + { + "path": "safety_mode", + "label": "Safety mode", + "description": "Controls Cohere's built-in safety instructions applied to the generation.", + "group": "provider_metadata", + "type": "enum", + "default": "CONTEXTUAL", + "values": [ + "CONTEXTUAL", + "STRICT", + "OFF" + ] + } + ] + }, + { + "provider": "cohere", + "authType": "api_key", + "model": "command-r-plus-08-2024", + "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": "stop_sequences", + "label": "Stop sequences", + "description": "Stops generation when one of these sequences is detected; up to five are allowed.", + "group": "generation_length", + "type": "string" + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 0.3, + "range": { + "min": 0, + "step": 0.1 + } + }, + { + "path": "p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.75, + "range": { + "min": 0.01, + "max": 0.99, + "step": 0.01 + } + }, + { + "path": "k", + "label": "Top K", + "description": "Limits sampling to the K most likely tokens; 0 disables top-k sampling.", + "group": "sampling", + "type": "integer", + "default": 0, + "range": { + "min": 0, + "max": 500 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes tokens proportional to how often they have already appeared to reduce repetition.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes tokens that have already appeared to encourage a wider variety of content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Seed used for best-effort deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON object output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "logprobs", + "label": "Log probabilities", + "description": "Controls whether the response includes log probabilities for the generated tokens.", + "group": "observability", + "type": "boolean", + "default": false + }, + { + "path": "safety_mode", + "label": "Safety mode", + "description": "Controls Cohere's built-in safety instructions applied to the generation.", + "group": "provider_metadata", + "type": "enum", + "default": "CONTEXTUAL", + "values": [ + "CONTEXTUAL", + "STRICT", + "OFF" + ] + } + ] + }, + { + "provider": "cohere", + "authType": "api_key", + "model": "command-r7b-12-2024", + "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": "stop_sequences", + "label": "Stop sequences", + "description": "Stops generation when one of these sequences is detected; up to five are allowed.", + "group": "generation_length", + "type": "string" + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 0.3, + "range": { + "min": 0, + "step": 0.1 + } + }, + { + "path": "p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number", + "default": 0.75, + "range": { + "min": 0.01, + "max": 0.99, + "step": 0.01 + } + }, + { + "path": "k", + "label": "Top K", + "description": "Limits sampling to the K most likely tokens; 0 disables top-k sampling.", + "group": "sampling", + "type": "integer", + "default": 0, + "range": { + "min": 0, + "max": 500 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes tokens proportional to how often they have already appeared to reduce repetition.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes tokens that have already appeared to encourage a wider variety of content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1, + "step": 0.1 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Seed used for best-effort deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON object output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "logprobs", + "label": "Log probabilities", + "description": "Controls whether the response includes log probabilities for the generated tokens.", + "group": "observability", + "type": "boolean", + "default": false + }, + { + "path": "tool_choice", + "label": "Tool choice", + "description": "Forces the model to either call a tool or skip tool calls for this request.", + "group": "tooling", + "type": "enum", + "values": [ + "REQUIRED", + "NONE" + ] + }, + { + "path": "safety_mode", + "label": "Safety mode", + "description": "Controls Cohere's built-in safety instructions applied to the generation.", + "group": "provider_metadata", + "type": "enum", + "default": "CONTEXTUAL", + "values": [ + "CONTEXTUAL", + "STRICT" + ] + } + ] + }, + { + "provider": "deepseek", + "authType": "api_key", + "model": "deepseek-chat", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. In DeepSeek thinking mode this parameter is accepted for compatibility but has no effect.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling. In DeepSeek thinking mode this parameter is accepted for compatibility but has no effect.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls whether DeepSeek uses thinking mode before producing the final answer.", + "group": "reasoning", + "type": "enum", + "default": "disabled", + "values": [ + "disabled", + "enabled" + ] + } + ] + }, + { + "provider": "deepseek", + "authType": "api_key", + "model": "deepseek-reasoner", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. In DeepSeek thinking mode this parameter is accepted for compatibility but has no effect.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling. In DeepSeek thinking mode this parameter is accepted for compatibility but has no effect.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls whether DeepSeek uses thinking mode before producing the final answer.", + "group": "reasoning", + "type": "enum", + "default": "enabled", + "values": [ + "enabled", + "disabled" + ] + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls DeepSeek thinking effort when thinking mode is enabled.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "enum", + "default": "high", + "values": [ + "high", + "max" + ] + } + ] + }, + { + "provider": "deepseek", + "authType": "api_key", + "model": "deepseek-v4-flash", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. In DeepSeek thinking mode this parameter is accepted for compatibility but has no effect.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling. In DeepSeek thinking mode this parameter is accepted for compatibility but has no effect.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls whether DeepSeek uses thinking mode before producing the final answer.", + "group": "reasoning", + "type": "enum", + "default": "enabled", + "values": [ + "enabled", + "disabled" + ] + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls DeepSeek thinking effort when thinking mode is enabled.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "enum", + "default": "high", + "values": [ + "high", + "max" + ] + } + ] + }, + { + "provider": "deepseek", + "authType": "api_key", + "model": "deepseek-v4-pro", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1 + } + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. In DeepSeek thinking mode this parameter is accepted for compatibility but has no effect.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling. In DeepSeek thinking mode this parameter is accepted for compatibility but has no effect.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": [ + "enabled" + ] + } + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls whether DeepSeek uses thinking mode before producing the final answer.", + "group": "reasoning", + "type": "enum", + "default": "enabled", + "values": [ + "enabled", + "disabled" + ] + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls DeepSeek thinking effort when thinking mode is enabled.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "enum", + "default": "high", + "values": [ + "high", + "max" + ] + } + ] + }, + { + "provider": "google", + "authType": "api_key", + "model": "gemini-2.5-flash", + "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; 0 disables thinking and -1 uses dynamic thinking.", + "group": "reasoning", + "type": "integer", + "default": -1, + "range": { + "min": -1, + "max": 24576 + } + }, + { + "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": "gemini-2.5-flash-lite", + "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.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": "subscription", + "model": "gemini-2.5-flash-lite", + "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.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": "subscription", + "model": "gemini-2.5-flash", + "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; 0 disables thinking and -1 uses dynamic thinking.", + "group": "reasoning", + "type": "integer", + "default": -1, + "range": { + "min": -1, + "max": 24576 + } + }, + { + "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": "gemini-2.5-pro", + "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": "Maximum number of thinking tokens Gemini should use before producing the final answer.", + "group": "reasoning", + "type": "integer", + "range": { + "min": 128, + "max": 32768 + } + }, + { + "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": "subscription", + "model": "gemini-2.5-pro", + "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": "Maximum number of thinking tokens Gemini should use before producing the final answer.", + "group": "reasoning", + "type": "integer", + "range": { + "min": 128, + "max": 32768 + } + }, + { + "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": "subscription", + "model": "gemini-3-flash-preview", + "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.thinkingLevel", + "label": "Thinking level", + "description": "Controls Gemini 3 Flash reasoning effort.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "minimal", + "low", + "medium", + "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": "subscription", + "model": "gemini-3.1-flash-lite-preview", + "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.thinkingLevel", + "label": "Thinking level", + "description": "Controls Gemini 3.1 Flash-Lite reasoning effort.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "minimal", + "low", + "medium", + "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": "subscription", + "model": "gemini-3.1-flash-lite", + "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.thinkingLevel", + "label": "Thinking level", + "description": "Controls Gemini 3.1 Flash-Lite reasoning effort.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "minimal", + "low", + "medium", + "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": "subscription", + "model": "gemini-3.1-pro-preview", + "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.thinkingLevel", + "label": "Thinking level", + "description": "Controls Gemini 3 Pro reasoning effort.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "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": "gemini-3.5-flash", + "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.thinkingLevel", + "label": "Thinking level", + "description": "Controls Gemini 3.5 Flash reasoning effort.", + "group": "reasoning", + "type": "enum", + "default": "medium", + "values": [ + "minimal", + "low", + "medium", + "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-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 + } + }, + { + "path": "generationConfig.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": "generationConfig.topP", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to the selected cumulative probability.", + "group": "sampling", + "type": "number", + "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", + "range": { + "min": 0 + } + }, + { + "path": "generationConfig.seed", + "label": "Seed", + "description": "Optional seed used in decoding when reproducible sampling is desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "generationConfig.thinkingConfig.thinkingLevel", + "label": "Thinking level", + "description": "Toggles Gemma 4's internal reasoning process.", + "group": "reasoning", + "type": "enum", + "values": [ + "minimal", + "high" + ] + }, + { + "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-4-31b-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 + } + }, + { + "path": "generationConfig.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": "generationConfig.topP", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to the selected cumulative probability.", + "group": "sampling", + "type": "number", + "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", + "range": { + "min": 0 + } + }, + { + "path": "generationConfig.seed", + "label": "Seed", + "description": "Optional seed used in decoding when reproducible sampling is desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "generationConfig.thinkingConfig.thinkingLevel", + "label": "Thinking level", + "description": "Toggles Gemma 4's internal reasoning process.", + "group": "reasoning", + "type": "enum", + "values": [ + "minimal", + "high" + ] + }, + { + "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": "groq", + "authType": "api_key", + "model": "qwen3-32b", + "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.", + "group": "sampling", + "type": "number", + "default": 1, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes tokens by how often they have appeared, reducing verbatim repetition.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes tokens that have already appeared, encouraging the model to introduce new topics.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Seed used for best-effort deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "stop", + "label": "Stop", + "description": "A string or list of strings where the API will stop generating further tokens. Groq accepts up to four stop sequences.", + "group": "generation_length", + "type": "string" + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls whether the model reasons before answering. 'none' disables reasoning; 'default' lets the model reason.", + "group": "reasoning", + "type": "enum", + "default": "default", + "values": [ + "none", + "default" + ] + }, + { + "path": "reasoning_format", + "label": "Reasoning format", + "description": "Controls how reasoning tokens are returned — hidden from the response, raw within the content, or parsed into a separate field.", + "group": "reasoning", + "type": "enum", + "values": [ + "hidden", + "raw", + "parsed" + ] + }, + { + "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": "meta", + "authType": "api_key", + "model": "Llama-3.3-70B-Instruct", + "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.", + "group": "sampling", + "type": "number" + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number" + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens.", + "group": "sampling", + "type": "integer" + }, + { + "path": "repetition_penalty", + "label": "Repetition penalty", + "description": "Penalizes tokens that have already appeared to reduce repetition in the output.", + "group": "sampling", + "type": "number" + }, + { + "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": "meta", + "authType": "api_key", + "model": "Llama-3.3-8B-Instruct", + "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.", + "group": "sampling", + "type": "number" + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number" + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens.", + "group": "sampling", + "type": "integer" + }, + { + "path": "repetition_penalty", + "label": "Repetition penalty", + "description": "Penalizes tokens that have already appeared to reduce repetition in the output.", + "group": "sampling", + "type": "number" + }, + { + "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": "meta", + "authType": "api_key", + "model": "Llama-4-Maverick-17B-128E-Instruct-FP8", + "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.", + "group": "sampling", + "type": "number" + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number" + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens.", + "group": "sampling", + "type": "integer" + }, + { + "path": "repetition_penalty", + "label": "Repetition penalty", + "description": "Penalizes tokens that have already appeared to reduce repetition in the output.", + "group": "sampling", + "type": "number" + }, + { + "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": "meta", + "authType": "api_key", + "model": "Llama-4-Scout-17B-16E-Instruct-FP8", + "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.", + "group": "sampling", + "type": "number" + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability.", + "group": "sampling", + "type": "number" + }, + { + "path": "top_k", + "label": "Top K", + "description": "Limits generation to the selected number of highest-probability tokens.", + "group": "sampling", + "type": "integer" + }, + { + "path": "repetition_penalty", + "label": "Repetition penalty", + "description": "Penalizes tokens that have already appeared to reduce repetition in the output.", + "group": "sampling", + "type": "number" + }, + { + "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": "minimax", + "authType": "api_key", + "model": "minimax-m2", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max completion tokens", + "description": "Maximum number of tokens to generate in the completion.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + }, + { + "path": "reasoning_split", + "label": "Split reasoning", + "description": "Returns the model's reasoning in a separate reasoning_details field instead of inline with the response.", + "group": "reasoning", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "minimax", + "authType": "subscription", + "model": "MiniMax-M2", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "minimax", + "authType": "api_key", + "model": "minimax-m2.1", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max completion tokens", + "description": "Maximum number of tokens to generate in the completion.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + }, + { + "path": "reasoning_split", + "label": "Split reasoning", + "description": "Returns the model's reasoning in a separate reasoning_details field instead of inline with the response.", + "group": "reasoning", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "minimax", + "authType": "api_key", + "model": "minimax-m2.1-highspeed", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max completion tokens", + "description": "Maximum number of tokens to generate in the completion.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + }, + { + "path": "reasoning_split", + "label": "Split reasoning", + "description": "Returns the model's reasoning in a separate reasoning_details field instead of inline with the response.", + "group": "reasoning", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "minimax", + "authType": "subscription", + "model": "MiniMax-M2.1-highspeed", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "minimax", + "authType": "subscription", + "model": "MiniMax-M2.1", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "minimax", + "authType": "api_key", + "model": "minimax-m2.5", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max completion tokens", + "description": "Maximum number of tokens to generate in the completion.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + }, + { + "path": "reasoning_split", + "label": "Split reasoning", + "description": "Returns the model's reasoning in a separate reasoning_details field instead of inline with the response.", + "group": "reasoning", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "minimax", + "authType": "api_key", + "model": "minimax-m2.5-highspeed", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max completion tokens", + "description": "Maximum number of tokens to generate in the completion.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + }, + { + "path": "reasoning_split", + "label": "Split reasoning", + "description": "Returns the model's reasoning in a separate reasoning_details field instead of inline with the response.", + "group": "reasoning", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "minimax", + "authType": "subscription", + "model": "MiniMax-M2.5-highspeed", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "minimax", + "authType": "subscription", + "model": "MiniMax-M2.5", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "minimax", + "authType": "api_key", + "model": "minimax-m2.7", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max completion tokens", + "description": "Maximum number of tokens to generate in the completion.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + }, + { + "path": "reasoning_split", + "label": "Split reasoning", + "description": "Returns the model's reasoning in a separate reasoning_details field instead of inline with the response.", + "group": "reasoning", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "minimax", + "authType": "api_key", + "model": "minimax-m2.7-highspeed", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max completion tokens", + "description": "Maximum number of tokens to generate in the completion.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + }, + { + "path": "reasoning_split", + "label": "Split reasoning", + "description": "Returns the model's reasoning in a separate reasoning_details field instead of inline with the response.", + "group": "reasoning", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "minimax", + "authType": "subscription", + "model": "MiniMax-M2.7-highspeed", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "minimax", + "authType": "subscription", + "model": "MiniMax-M2.7", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "minimax", + "authType": "api_key", + "model": "minimax-m3", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max completion tokens", + "description": "Maximum number of tokens to generate in the completion.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + }, + { + "path": "reasoning_split", + "label": "Split reasoning", + "description": "Returns the model's reasoning in a separate reasoning_details field instead of inline with the response.", + "group": "reasoning", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "minimax", + "authType": "subscription", + "model": "MiniMax-M3", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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. Values must be greater than 0 and at most 1.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0.01, + "max": 1, + "step": 0.01 + } + }, + { + "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.01, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "mistral", + "authType": "api_key", + "model": "codestral-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the completion.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "stop", + "label": "Stop sequence", + "description": "Stops generation when this string is detected.", + "group": "generation_length", + "type": "string" + }, + { + "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": 1.5, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "random_seed", + "label": "Random seed", + "description": "Seed used for deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes repeated words or phrases to encourage a wider variety of generated content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes words based on how often they already appear in the generated text.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON mode output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "safe_prompt", + "label": "Safe prompt", + "description": "Controls whether Mistral injects its safety prompt before the conversation.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "mistral", + "authType": "api_key", + "model": "devstral-2512", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the completion.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "stop", + "label": "Stop sequence", + "description": "Stops generation when this string is detected.", + "group": "generation_length", + "type": "string" + }, + { + "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": 1.5, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "random_seed", + "label": "Random seed", + "description": "Seed used for deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes repeated words or phrases to encourage a wider variety of generated content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes words based on how often they already appear in the generated text.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON mode output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "safe_prompt", + "label": "Safe prompt", + "description": "Controls whether Mistral injects its safety prompt before the conversation.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "mistral", + "authType": "api_key", + "model": "devstral-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the completion.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "stop", + "label": "Stop sequence", + "description": "Stops generation when this string is detected.", + "group": "generation_length", + "type": "string" + }, + { + "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": 1.5, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "random_seed", + "label": "Random seed", + "description": "Seed used for deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes repeated words or phrases to encourage a wider variety of generated content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes words based on how often they already appear in the generated text.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON mode output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "safe_prompt", + "label": "Safe prompt", + "description": "Controls whether Mistral injects its safety prompt before the conversation.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "mistral", + "authType": "api_key", + "model": "magistral-medium-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the completion.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "stop", + "label": "Stop sequence", + "description": "Stops generation when this string is detected.", + "group": "generation_length", + "type": "string" + }, + { + "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": 1.5, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "random_seed", + "label": "Random seed", + "description": "Seed used for deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes repeated words or phrases to encourage a wider variety of generated content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes words based on how often they already appear in the generated text.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "prompt_mode", + "label": "Prompt mode", + "description": "Enables Mistral's reasoning system prompt; leave unset to disable the default reasoning behavior.", + "group": "reasoning", + "type": "enum", + "values": [ + "reasoning" + ] + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON mode output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "safe_prompt", + "label": "Safe prompt", + "description": "Controls whether Mistral injects its safety prompt before the conversation.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "mistral", + "authType": "api_key", + "model": "magistral-small-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the completion.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "stop", + "label": "Stop sequence", + "description": "Stops generation when this string is detected.", + "group": "generation_length", + "type": "string" + }, + { + "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": 1.5, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "random_seed", + "label": "Random seed", + "description": "Seed used for deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes repeated words or phrases to encourage a wider variety of generated content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes words based on how often they already appear in the generated text.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "prompt_mode", + "label": "Prompt mode", + "description": "Enables Mistral's reasoning system prompt; leave unset to disable the default reasoning behavior.", + "group": "reasoning", + "type": "enum", + "values": [ + "reasoning" + ] + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON mode output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "safe_prompt", + "label": "Safe prompt", + "description": "Controls whether Mistral injects its safety prompt before the conversation.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "mistral", + "authType": "api_key", + "model": "ministral-14b-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the completion.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "stop", + "label": "Stop sequence", + "description": "Stops generation when this string is detected.", + "group": "generation_length", + "type": "string" + }, + { + "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": 1.5, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "random_seed", + "label": "Random seed", + "description": "Seed used for deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes repeated words or phrases to encourage a wider variety of generated content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes words based on how often they already appear in the generated text.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON mode output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "safe_prompt", + "label": "Safe prompt", + "description": "Controls whether Mistral injects its safety prompt before the conversation.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "mistral", + "authType": "api_key", + "model": "ministral-3b-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the completion.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "stop", + "label": "Stop sequence", + "description": "Stops generation when this string is detected.", + "group": "generation_length", + "type": "string" + }, + { + "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": 1.5, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "random_seed", + "label": "Random seed", + "description": "Seed used for deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes repeated words or phrases to encourage a wider variety of generated content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes words based on how often they already appear in the generated text.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON mode output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "safe_prompt", + "label": "Safe prompt", + "description": "Controls whether Mistral injects its safety prompt before the conversation.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "mistral", + "authType": "api_key", + "model": "ministral-8b-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the completion.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "stop", + "label": "Stop sequence", + "description": "Stops generation when this string is detected.", + "group": "generation_length", + "type": "string" + }, + { + "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": 1.5, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "random_seed", + "label": "Random seed", + "description": "Seed used for deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes repeated words or phrases to encourage a wider variety of generated content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes words based on how often they already appear in the generated text.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON mode output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "safe_prompt", + "label": "Safe prompt", + "description": "Controls whether Mistral injects its safety prompt before the conversation.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "mistral", + "authType": "api_key", + "model": "mistral-large-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the completion.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "stop", + "label": "Stop sequence", + "description": "Stops generation when this string is detected.", + "group": "generation_length", + "type": "string" + }, + { + "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": 1.5, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "random_seed", + "label": "Random seed", + "description": "Seed used for deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes repeated words or phrases to encourage a wider variety of generated content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes words based on how often they already appear in the generated text.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON mode output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "safe_prompt", + "label": "Safe prompt", + "description": "Controls whether Mistral injects its safety prompt before the conversation.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "mistral", + "authType": "api_key", + "model": "mistral-medium-3.5", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the completion.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "stop", + "label": "Stop sequence", + "description": "Stops generation when this string is detected.", + "group": "generation_length", + "type": "string" + }, + { + "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": 1.5, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "random_seed", + "label": "Random seed", + "description": "Seed used for deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes repeated words or phrases to encourage a wider variety of generated content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes words based on how often they already appear in the generated text.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON mode output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "safe_prompt", + "label": "Safe prompt", + "description": "Controls whether Mistral injects its safety prompt before the conversation.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "mistral", + "authType": "api_key", + "model": "mistral-medium-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the completion.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "stop", + "label": "Stop sequence", + "description": "Stops generation when this string is detected.", + "group": "generation_length", + "type": "string" + }, + { + "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": 1.5, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "random_seed", + "label": "Random seed", + "description": "Seed used for deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes repeated words or phrases to encourage a wider variety of generated content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes words based on how often they already appear in the generated text.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON mode output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "safe_prompt", + "label": "Safe prompt", + "description": "Controls whether Mistral injects its safety prompt before the conversation.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "mistral", + "authType": "api_key", + "model": "mistral-small-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the completion.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "stop", + "label": "Stop sequence", + "description": "Stops generation when this string is detected.", + "group": "generation_length", + "type": "string" + }, + { + "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": 1.5, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "random_seed", + "label": "Random seed", + "description": "Seed used for deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes repeated words or phrases to encourage a wider variety of generated content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes words based on how often they already appear in the generated text.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON mode output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "safe_prompt", + "label": "Safe prompt", + "description": "Controls whether Mistral injects its safety prompt before the conversation.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "mistral", + "authType": "api_key", + "model": "open-mistral-nemo", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the completion.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "stop", + "label": "Stop sequence", + "description": "Stops generation when this string is detected.", + "group": "generation_length", + "type": "string" + }, + { + "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": 1.5, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "random_seed", + "label": "Random seed", + "description": "Seed used for deterministic sampling when reproducible outputs are desired.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes repeated words or phrases to encourage a wider variety of generated content.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes words based on how often they already appear in the generated text.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns normal text or JSON mode output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object" + ] + }, + { + "path": "safe_prompt", + "label": "Safe prompt", + "description": "Controls whether Mistral injects its safety prompt before the conversation.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "moonshot", + "authType": "api_key", + "model": "kimi-k2.5", + "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, or responds directly when set to disabled.", + "group": "reasoning", + "type": "enum", + "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": "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": [ + { + "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.7-code-highspeed", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the chat completion, covering both thinking and the final answer.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "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.7-code", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the chat completion, covering both thinking and the final answer.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "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": "api_key", + "model": "moonshot-v1-128k", + "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": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 0.3, + "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", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "n", + "label": "Number of completions", + "description": "How many chat completion choices to generate for the request.", + "group": "generation_length", + "type": "integer", + "default": 1, + "range": { + "min": 1, + "max": 5 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes tokens that have already appeared, encouraging the model to talk about new topics.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes tokens by how often they have appeared, reducing verbatim repetition.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "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": "api_key", + "model": "moonshot-v1-32k", + "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": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 0.3, + "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", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "n", + "label": "Number of completions", + "description": "How many chat completion choices to generate for the request.", + "group": "generation_length", + "type": "integer", + "default": 1, + "range": { + "min": 1, + "max": 5 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes tokens that have already appeared, encouraging the model to talk about new topics.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes tokens by how often they have appeared, reducing verbatim repetition.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "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": "api_key", + "model": "moonshot-v1-8k", + "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": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 0.3, + "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", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "n", + "label": "Number of completions", + "description": "How many chat completion choices to generate for the request.", + "group": "generation_length", + "type": "integer", + "default": 1, + "range": { + "min": 1, + "max": 5 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes tokens that have already appeared, encouraging the model to talk about new topics.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes tokens by how often they have appeared, reducing verbatim repetition.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "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": "nvidia", + "authType": "api_key", + "model": "gliner-pii", + "params": [ + { + "path": "threshold", + "label": "Threshold", + "description": "Confidence threshold for entity detection. Lower values detect more entities but may include false positives.", + "group": "sampling", + "type": "number", + "default": 0.5, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "chunk_length", + "label": "Chunk length", + "description": "Context window size for processing. Longer texts are automatically split into chunks with overlap for complete coverage. Must be greater than overlap.", + "group": "provider_metadata", + "type": "integer", + "default": 384, + "range": { + "min": 1, + "max": 2048 + } + }, + { + "path": "overlap", + "label": "Overlap", + "description": "Token overlap between chunks to prevent entity clipping. Must be less than chunk_length.", + "group": "provider_metadata", + "type": "integer", + "default": 128, + "range": { + "min": 0, + "max": 512 + } + }, + { + "path": "flat_ner", + "label": "Flat NER", + "description": "When true, prevents overlapping entity spans. When false, may return nested entities such as both a full name and its constituent first name.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "nvidia", + "authType": "api_key", + "model": "llama-3.1-nemoguard-8b-topic-control", + "params": [ + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.5, + "range": { + "min": 0, + "max": 2 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "max": 1 + } + }, + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate. Generation stops when this limit is reached.", + "group": "generation_length", + "type": "integer", + "default": 1024, + "range": { + "min": 1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2 + } + }, + { + "path": "stop", + "label": "Stop", + "description": "A string or list of strings where the API will stop generating further tokens. The returned text will not contain the stop sequence.", + "group": "generation_length", + "type": "string" + } + ] + }, + { + "provider": "nvidia", + "authType": "api_key", + "model": "llama-3.1-nemotron-nano-8b-v1", + "params": [ + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.6, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "max": 1 + } + }, + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate. Generation stops when this limit is reached.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1, + "max": 16384 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Best-effort deterministic sampling seed. Changing the seed produces a different response with similar characteristics. Fix the seed to reproduce results.", + "group": "sampling", + "type": "integer", + "default": 0, + "range": { + "min": 0, + "max": 18446744073709552000 + } + }, + { + "path": "stop", + "label": "Stop", + "description": "A string or list of strings where the API will stop generating further tokens. The returned text will not contain the stop sequence.", + "group": "generation_length", + "type": "string" + } + ] + }, + { + "provider": "nvidia", + "authType": "api_key", + "model": "llama-3.1-nemotron-safety-guard-8b-v3", + "params": [ + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1 + } + } + ] + }, + { + "provider": "nvidia", + "authType": "api_key", + "model": "llama-3.1-nemotron-ultra-253b-v1", + "params": [ + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.6, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "max": 1 + } + }, + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate. Generation stops when this limit is reached.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1, + "max": 16384 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Best-effort deterministic sampling seed. Changing the seed produces a different response with similar characteristics. Fix the seed to reproduce results.", + "group": "sampling", + "type": "integer", + "default": 0, + "range": { + "min": 0, + "max": 18446744073709552000 + } + }, + { + "path": "stop", + "label": "Stop", + "description": "A string or list of strings where the API will stop generating further tokens. The returned text will not contain the stop sequence.", + "group": "generation_length", + "type": "string" + } + ] + }, + { + "provider": "nvidia", + "authType": "api_key", + "model": "llama-3.3-nemotron-super-49b-v1", + "params": [ + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.6, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "max": 1 + } + }, + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate. Generation stops when this limit is reached.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 1, + "max": 16384 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Best-effort deterministic sampling seed. Changing the seed produces a different response with similar characteristics. Fix the seed to reproduce results.", + "group": "sampling", + "type": "integer", + "default": 0, + "range": { + "min": 0, + "max": 18446744073709552000 + } + }, + { + "path": "stop", + "label": "Stop", + "description": "A string or list of strings where the API will stop generating further tokens. The returned text will not contain the stop sequence.", + "group": "generation_length", + "type": "string" + } + ] + }, + { + "provider": "nvidia", + "authType": "api_key", + "model": "llama-3.3-nemotron-super-49b-v1.5", + "params": [ + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.6, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "max": 1 + } + }, + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate. Generation stops when this limit is reached.", + "group": "generation_length", + "type": "integer", + "default": 65536, + "range": { + "min": 1, + "max": 65536 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Best-effort deterministic sampling seed. Changing the seed produces a different response with similar characteristics. Fix the seed to reproduce results.", + "group": "sampling", + "type": "integer", + "default": 0, + "range": { + "min": 0, + "max": 18446744073709552000 + } + }, + { + "path": "stop", + "label": "Stop", + "description": "A string or list of strings where the API will stop generating further tokens. The returned text will not contain the stop sequence.", + "group": "generation_length", + "type": "string" + } + ] + }, + { + "provider": "nvidia", + "authType": "api_key", + "model": "nemoguard-jailbreak-detect", + "params": [] + }, + { + "provider": "nvidia", + "authType": "api_key", + "model": "nemotron-3-nano-30b-a3b", + "params": [ + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "max": 1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "max": 1 + } + }, + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate. Generation stops when this limit is reached.", + "group": "generation_length", + "type": "integer", + "default": 16384, + "range": { + "min": 1, + "max": 32768 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Best-effort deterministic sampling seed. Repeated requests with the same seed and parameters should return the same result.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0, + "max": 18446744073709552000 + } + }, + { + "path": "stop", + "label": "Stop", + "description": "A string or list of strings where the API will stop generating further tokens. The returned text will not contain the stop sequence.", + "group": "generation_length", + "type": "string" + } + ] + }, + { + "provider": "nvidia", + "authType": "api_key", + "model": "nemotron-3-super-120b-a12b", + "params": [ + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "max": 1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "max": 1 + } + }, + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate. Generation stops when this limit is reached.", + "group": "generation_length", + "type": "integer", + "default": 16384, + "range": { + "min": 1, + "max": 32768 + } + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls the reasoning mode. 'none' disables reasoning tokens, 'low' enables low-effort reasoning, and 'high' enables full reasoning.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "none", + "low", + "high" + ] + }, + { + "path": "reasoning_budget", + "label": "Reasoning budget", + "description": "Maximum number of tokens the model may use for internal reasoning before being forced to end the reasoning trace. Use -1 to disable budget enforcement.", + "group": "reasoning", + "type": "integer", + "default": 16384, + "range": { + "min": -1, + "max": 32768 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Best-effort deterministic sampling seed. Repeated requests with the same seed and parameters should return the same result.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0, + "max": 18446744073709552000 + } + }, + { + "path": "stop", + "label": "Stop", + "description": "A string or list of strings where the API will stop generating further tokens. The returned text will not contain the stop sequence.", + "group": "generation_length", + "type": "string" + } + ] + }, + { + "provider": "nvidia", + "authType": "api_key", + "model": "nemotron-3-ultra-550b-a55b", + "params": [ + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "max": 1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "max": 1 + } + }, + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate. Generation stops when this limit is reached.", + "group": "generation_length", + "type": "integer", + "default": 16384, + "range": { + "min": 1, + "max": 32768 + } + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls the reasoning mode. 'none' disables reasoning tokens, 'medium' enables efficient reasoning, and 'high' enables full reasoning.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "none", + "medium", + "high" + ] + }, + { + "path": "reasoning_budget", + "label": "Reasoning budget", + "description": "Maximum number of tokens the model may use for internal reasoning before being forced to end the reasoning trace. Use -1 to disable budget enforcement.", + "group": "reasoning", + "type": "integer", + "default": 16384, + "range": { + "min": -1, + "max": 32768 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Best-effort deterministic sampling seed. Repeated requests with the same seed and parameters should return the same result.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0, + "max": 18446744073709552000 + } + }, + { + "path": "stop", + "label": "Stop", + "description": "A string or list of strings where the API will stop generating further tokens. The returned text will not contain the stop sequence.", + "group": "generation_length", + "type": "string" + } + ] + }, + { + "provider": "nvidia", + "authType": "subscription", + "model": "nemotron-3-ultra", + "params": [ + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "max": 1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.95, + "range": { + "max": 1 + } + }, + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate. Generation stops when this limit is reached.", + "group": "generation_length", + "type": "integer", + "default": 16384, + "range": { + "min": 1, + "max": 32768 + } + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls the reasoning mode. 'none' disables reasoning tokens, 'medium' enables efficient reasoning, and 'high' enables full reasoning.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "none", + "medium", + "high" + ] + }, + { + "path": "reasoning_budget", + "label": "Reasoning budget", + "description": "Maximum number of tokens the model may use for internal reasoning before being forced to end the reasoning trace. Use -1 to disable budget enforcement.", + "group": "reasoning", + "type": "integer", + "default": 16384, + "range": { + "min": -1, + "max": 32768 + } + }, + { + "path": "stop", + "label": "Stop", + "description": "A string or list of strings where the API will stop generating further tokens. The returned text will not contain the stop sequence.", + "group": "generation_length", + "type": "string" + } + ] + }, + { + "provider": "nvidia", + "authType": "api_key", + "model": "nemotron-content-safety-reasoning-4b", + "params": [ + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "max": 1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "max": 1 + } + }, + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate. Generation stops when this limit is reached.", + "group": "generation_length", + "type": "integer", + "default": 16384, + "range": { + "min": 1, + "max": 32768 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Best-effort deterministic sampling seed. Repeated requests with the same seed and parameters should return the same result.", + "group": "sampling", + "type": "integer", + "range": { + "min": 0, + "max": 18446744073709552000 + } + }, + { + "path": "stop", + "label": "Stop", + "description": "A string or list of strings where the API will stop generating further tokens. The returned text will not contain the stop sequence.", + "group": "generation_length", + "type": "string" + } + ] + }, + { + "provider": "nvidia", + "authType": "api_key", + "model": "nemotron-mini-4b-instruct", + "params": [ + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.2, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.7, + "range": { + "max": 1 + } + }, + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate. Generation stops when this limit is reached.", + "group": "generation_length", + "type": "integer", + "default": 1024, + "range": { + "min": 1, + "max": 4096 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2 + } + }, + { + "path": "stop", + "label": "Stop", + "description": "A string or list of strings where the API will stop generating further tokens. The returned text will not contain the stop sequence.", + "group": "generation_length", + "type": "string" + } + ] + }, + { + "provider": "nvidia", + "authType": "api_key", + "model": "riva-translate-4b-instruct-v1.1", + "params": [ + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.9, + "range": { + "max": 1 + } + }, + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate. Generation stops when this limit is reached.", + "group": "generation_length", + "type": "integer", + "default": 512, + "range": { + "min": 1, + "max": 4096 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2 + } + }, + { + "path": "stop", + "label": "Stop", + "description": "A string or list of strings where the API will stop generating further tokens. The returned text will not contain the stop sequence.", + "group": "generation_length", + "type": "string" + } + ] + }, + { + "provider": "nvidia", + "authType": "api_key", + "model": "usdcode-llama-3.1-70b-instruct", + "params": [ + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values make outputs more focused; higher values make them more varied. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 0.1, + "range": { + "min": 0, + "max": 1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens within the selected cumulative probability. Not recommended to modify both temperature and top_p in the same call.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "max": 1 + } + }, + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate. Generation stops when this limit is reached.", + "group": "generation_length", + "type": "integer", + "default": 1024, + "range": { + "min": 1, + "max": 2048 + } + }, + { + "path": "expert_type", + "label": "Expert type", + "description": "The type of expert to use. 'knowledge' answers with USD knowledge, 'code' responds with vanilla OpenUSD code, 'helperfunction' uses high-level helper functions, and 'auto' lets the LLM determine which expert to use.", + "group": "provider_metadata", + "type": "enum", + "default": "auto", + "values": [ + "auto", + "code", + "knowledge", + "helperfunction" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "chatgpt-4o-latest", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "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, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens whose cumulative probability reaches this value.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-3.5-turbo", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "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, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens whose cumulative probability reaches this value.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-4-turbo", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "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, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens whose cumulative probability reaches this value.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-4-turbo-2024-04-09", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "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, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens whose cumulative probability reaches this value.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-4.1", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "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, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens whose cumulative probability reaches this value.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-4.1-mini", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "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, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens whose cumulative probability reaches this value.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-4.1-nano", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "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, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens whose cumulative probability reaches this value.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-4o", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "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, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens whose cumulative probability reaches this value.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-4o-2024-11-20", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "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, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens whose cumulative probability reaches this value.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-4o-mini", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "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, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Controls nucleus sampling by limiting generation to tokens whose cumulative probability reaches this value.", + "group": "sampling", + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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": [ + "minimal", + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5-chat-latest", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5-mini", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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": [ + "minimal", + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5-nano", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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": [ + "minimal", + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5.1", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning the model should perform before producing an answer.", + "group": "reasoning", + "type": "enum", + "default": "none", + "values": [ + "none", + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "subscription", + "model": "gpt-5.1-codex-max", + "params": [ + { + "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": [ + "minimal", + "low", + "medium", + "high", + "xhigh" + ] + }, + { + "path": "reasoning.summary", + "label": "Reasoning summary", + "description": "Controls the level of reasoning summary returned with the response.", + "group": "reasoning", + "type": "enum", + "default": "auto", + "values": [ + "auto", + "concise", + "detailed", + "none" + ] + }, + { + "path": "text.verbosity", + "label": "Verbosity", + "description": "Controls how concise or detailed the model's final text response should be.", + "group": "output_format", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "subscription", + "model": "gpt-5.1-codex", + "params": [ + { + "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": [ + "minimal", + "low", + "medium", + "high" + ] + }, + { + "path": "reasoning.summary", + "label": "Reasoning summary", + "description": "Controls the level of reasoning summary returned with the response.", + "group": "reasoning", + "type": "enum", + "default": "auto", + "values": [ + "auto", + "concise", + "detailed", + "none" + ] + }, + { + "path": "text.verbosity", + "label": "Verbosity", + "description": "Controls how concise or detailed the model's final text response should be.", + "group": "output_format", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5.2", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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": [ + "none", + "low", + "medium", + "high", + "xhigh" + ] + } + ] + }, + { + "provider": "openai", + "authType": "subscription", + "model": "gpt-5.2-codex", + "params": [ + { + "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": [ + "minimal", + "low", + "medium", + "high", + "xhigh" + ] + }, + { + "path": "reasoning.summary", + "label": "Reasoning summary", + "description": "Controls the level of reasoning summary returned with the response.", + "group": "reasoning", + "type": "enum", + "default": "auto", + "values": [ + "auto", + "concise", + "detailed", + "none" + ] + }, + { + "path": "text.verbosity", + "label": "Verbosity", + "description": "Controls how concise or detailed the model's final text response should be.", + "group": "output_format", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "subscription", + "model": "gpt-5.2", + "params": [ + { + "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": [ + "minimal", + "low", + "medium", + "high", + "xhigh" + ] + }, + { + "path": "reasoning.summary", + "label": "Reasoning summary", + "description": "Controls the level of reasoning summary returned with the response.", + "group": "reasoning", + "type": "enum", + "default": "auto", + "values": [ + "auto", + "concise", + "detailed", + "none" + ] + }, + { + "path": "text.verbosity", + "label": "Verbosity", + "description": "Controls how concise or detailed the model's final text response should be.", + "group": "output_format", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5.3-codex", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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", + "xhigh" + ] + } + ] + }, + { + "provider": "openai", + "authType": "subscription", + "model": "gpt-5.3-codex-spark", + "params": [ + { + "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": [ + "minimal", + "low", + "medium", + "high", + "xhigh" + ] + }, + { + "path": "reasoning.summary", + "label": "Reasoning summary", + "description": "Controls the level of reasoning summary returned with the response.", + "group": "reasoning", + "type": "enum", + "default": "auto", + "values": [ + "auto", + "concise", + "detailed", + "none" + ] + }, + { + "path": "text.verbosity", + "label": "Verbosity", + "description": "Controls how concise or detailed the model's final text response should be.", + "group": "output_format", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "subscription", + "model": "gpt-5.3-codex", + "params": [ + { + "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": [ + "minimal", + "low", + "medium", + "high", + "xhigh" + ] + }, + { + "path": "reasoning.summary", + "label": "Reasoning summary", + "description": "Controls the level of reasoning summary returned with the response.", + "group": "reasoning", + "type": "enum", + "default": "auto", + "values": [ + "auto", + "concise", + "detailed", + "none" + ] + }, + { + "path": "text.verbosity", + "label": "Verbosity", + "description": "Controls how concise or detailed the model's final text response should be.", + "group": "output_format", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5.4", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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": [ + "none", + "low", + "medium", + "high", + "xhigh" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5.4-mini", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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": [ + "none", + "low", + "medium", + "high", + "xhigh" + ] + } + ] + }, + { + "provider": "openai", + "authType": "subscription", + "model": "gpt-5.4-mini", + "params": [ + { + "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": [ + "minimal", + "low", + "medium", + "high", + "xhigh" + ] + }, + { + "path": "reasoning.summary", + "label": "Reasoning summary", + "description": "Controls the level of reasoning summary returned with the response.", + "group": "reasoning", + "type": "enum", + "default": "auto", + "values": [ + "auto", + "concise", + "detailed", + "none" + ] + }, + { + "path": "text.verbosity", + "label": "Verbosity", + "description": "Controls how concise or detailed the model's final text response should be.", + "group": "output_format", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5.4-nano", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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": [ + "none", + "low", + "medium", + "high", + "xhigh" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5.4-pro", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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": [ + "medium", + "high", + "xhigh" + ] + } + ] + }, + { + "provider": "openai", + "authType": "subscription", + "model": "gpt-5.4-pro", + "params": [ + { + "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": [ + "medium", + "high", + "xhigh" + ] + }, + { + "path": "reasoning.summary", + "label": "Reasoning summary", + "description": "Controls the level of reasoning summary returned with the response.", + "group": "reasoning", + "type": "enum", + "default": "auto", + "values": [ + "auto", + "concise", + "detailed", + "none" + ] + }, + { + "path": "text.verbosity", + "label": "Verbosity", + "description": "Controls how concise or detailed the model's final text response should be.", + "group": "output_format", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "subscription", + "model": "gpt-5.4", + "params": [ + { + "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": [ + "minimal", + "low", + "medium", + "high", + "xhigh" + ] + }, + { + "path": "reasoning.summary", + "label": "Reasoning summary", + "description": "Controls the level of reasoning summary returned with the response.", + "group": "reasoning", + "type": "enum", + "default": "auto", + "values": [ + "auto", + "concise", + "detailed", + "none" + ] + }, + { + "path": "text.verbosity", + "label": "Verbosity", + "description": "Controls how concise or detailed the model's final text response should be.", + "group": "output_format", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5.5", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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": [ + "none", + "low", + "medium", + "high", + "xhigh" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5.5-pro", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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": [ + "medium", + "high", + "xhigh" + ] + } + ] + }, + { + "provider": "openai", + "authType": "subscription", + "model": "gpt-5.5-pro", + "params": [ + { + "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": [ + "medium", + "high", + "xhigh" + ] + }, + { + "path": "reasoning.summary", + "label": "Reasoning summary", + "description": "Controls the level of reasoning summary returned with the response.", + "group": "reasoning", + "type": "enum", + "default": "auto", + "values": [ + "auto", + "concise", + "detailed", + "none" + ] + }, + { + "path": "text.verbosity", + "label": "Verbosity", + "description": "Controls how concise or detailed the model's final text response should be.", + "group": "output_format", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "subscription", + "model": "gpt-5.5", + "params": [ + { + "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": [ + "minimal", + "low", + "medium", + "high", + "xhigh" + ] + }, + { + "path": "reasoning.summary", + "label": "Reasoning summary", + "description": "Controls the level of reasoning summary returned with the response.", + "group": "reasoning", + "type": "enum", + "default": "auto", + "values": [ + "auto", + "concise", + "detailed", + "none" + ] + }, + { + "path": "text.verbosity", + "label": "Verbosity", + "description": "Controls how concise or detailed the model's final text response should be.", + "group": "output_format", + "type": "enum", + "default": "medium", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5.6-luna", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning the model should perform before producing an answer.", + "group": "reasoning", + "type": "enum", + "default": "none", + "values": [ + "none", + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "gpt-5.6-sol", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning the model should perform before producing an answer.", + "group": "reasoning", + "type": "enum", + "default": "none", + "values": [ + "none", + "low", + "medium", + "high" + ] + } + ] + }, + { + "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": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning the model should perform before producing an answer.", + "group": "reasoning", + "type": "enum", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "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": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning the model should perform before producing an answer.", + "group": "reasoning", + "type": "enum", + "values": [ + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "o1", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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", + "xhigh" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "o1-mini", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 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": [ + "minimal", + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "o1-preview", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 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": [ + "minimal", + "low", + "medium", + "high" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "o3", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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", + "xhigh" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "o3-mini", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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", + "xhigh" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "o3-pro", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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", + "xhigh" + ] + } + ] + }, + { + "provider": "openai", + "authType": "api_key", + "model": "o4-mini", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of output tokens the model may generate.", + "group": "generation_length", + "type": "integer", + "default": 4096, + "range": { + "min": 16 + } + }, + { + "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", + "xhigh" + ] + } + ] + }, + { + "provider": "perplexity", + "authType": "api_key", + "model": "sonar", + "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, + "max": 128000 + } + }, + { + "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": "search_mode", + "label": "Search mode", + "description": "Selects the corpus the model searches when grounding its answer.", + "group": "provider_metadata", + "type": "enum", + "values": [ + "web", + "academic", + "sec" + ] + }, + { + "path": "search_recency_filter", + "label": "Search recency filter", + "description": "Restricts web search results to a recent time window.", + "group": "provider_metadata", + "type": "enum", + "values": [ + "hour", + "day", + "week", + "month", + "year" + ] + }, + { + "path": "search_domain_filter", + "label": "Search domain filter", + "description": "Limits search to, or excludes, specific domains.", + "group": "provider_metadata", + "type": "string" + }, + { + "path": "search_after_date_filter", + "label": "Search after date", + "description": "Restricts search results to content published after this date (MM/DD/YYYY).", + "group": "provider_metadata", + "type": "string" + }, + { + "path": "search_before_date_filter", + "label": "Search before date", + "description": "Restricts search results to content published before this date (MM/DD/YYYY).", + "group": "provider_metadata", + "type": "string" + }, + { + "path": "web_search_options.search_context_size", + "label": "Search context size", + "description": "Controls how much web search context is retrieved before generating the answer.", + "group": "provider_metadata", + "type": "enum", + "default": "low", + "values": [ + "low", + "medium", + "high" + ] + }, + { + "path": "return_images", + "label": "Return images", + "description": "Controls whether the response may include related images from the search.", + "group": "provider_metadata", + "type": "boolean", + "default": false + }, + { + "path": "return_related_questions", + "label": "Return related questions", + "description": "Controls whether the response includes suggested follow-up questions.", + "group": "provider_metadata", + "type": "boolean", + "default": false + }, + { + "path": "disable_search", + "label": "Disable search", + "description": "Turns off web search so the model answers from its own knowledge only.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "perplexity", + "authType": "api_key", + "model": "sonar-deep-research", + "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, + "max": 128000 + } + }, + { + "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": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning and searching the model performs before producing the report.", + "group": "reasoning", + "type": "enum", + "values": [ + "minimal", + "low", + "medium", + "high" + ] + }, + { + "path": "search_mode", + "label": "Search mode", + "description": "Selects the corpus the model searches when grounding its answer.", + "group": "provider_metadata", + "type": "enum", + "values": [ + "web", + "academic", + "sec" + ] + }, + { + "path": "search_recency_filter", + "label": "Search recency filter", + "description": "Restricts web search results to a recent time window.", + "group": "provider_metadata", + "type": "enum", + "values": [ + "hour", + "day", + "week", + "month", + "year" + ] + }, + { + "path": "search_domain_filter", + "label": "Search domain filter", + "description": "Limits search to, or excludes, specific domains.", + "group": "provider_metadata", + "type": "string" + }, + { + "path": "search_after_date_filter", + "label": "Search after date", + "description": "Restricts search results to content published after this date (MM/DD/YYYY).", + "group": "provider_metadata", + "type": "string" + }, + { + "path": "search_before_date_filter", + "label": "Search before date", + "description": "Restricts search results to content published before this date (MM/DD/YYYY).", + "group": "provider_metadata", + "type": "string" + }, + { + "path": "web_search_options.search_context_size", + "label": "Search context size", + "description": "Controls how much web search context is retrieved before generating the answer.", + "group": "provider_metadata", + "type": "enum", + "default": "low", + "values": [ + "low", + "medium", + "high" + ] + }, + { + "path": "return_images", + "label": "Return images", + "description": "Controls whether the response may include related images from the search.", + "group": "provider_metadata", + "type": "boolean", + "default": false + }, + { + "path": "return_related_questions", + "label": "Return related questions", + "description": "Controls whether the response includes suggested follow-up questions.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "perplexity", + "authType": "api_key", + "model": "sonar-pro", + "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, + "max": 128000 + } + }, + { + "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": "search_mode", + "label": "Search mode", + "description": "Selects the corpus the model searches when grounding its answer.", + "group": "provider_metadata", + "type": "enum", + "values": [ + "web", + "academic", + "sec" + ] + }, + { + "path": "search_recency_filter", + "label": "Search recency filter", + "description": "Restricts web search results to a recent time window.", + "group": "provider_metadata", + "type": "enum", + "values": [ + "hour", + "day", + "week", + "month", + "year" + ] + }, + { + "path": "search_domain_filter", + "label": "Search domain filter", + "description": "Limits search to, or excludes, specific domains.", + "group": "provider_metadata", + "type": "string" + }, + { + "path": "search_after_date_filter", + "label": "Search after date", + "description": "Restricts search results to content published after this date (MM/DD/YYYY).", + "group": "provider_metadata", + "type": "string" + }, + { + "path": "search_before_date_filter", + "label": "Search before date", + "description": "Restricts search results to content published before this date (MM/DD/YYYY).", + "group": "provider_metadata", + "type": "string" + }, + { + "path": "web_search_options.search_context_size", + "label": "Search context size", + "description": "Controls how much web search context is retrieved before generating the answer.", + "group": "provider_metadata", + "type": "enum", + "default": "low", + "values": [ + "low", + "medium", + "high" + ] + }, + { + "path": "return_images", + "label": "Return images", + "description": "Controls whether the response may include related images from the search.", + "group": "provider_metadata", + "type": "boolean", + "default": false + }, + { + "path": "return_related_questions", + "label": "Return related questions", + "description": "Controls whether the response includes suggested follow-up questions.", + "group": "provider_metadata", + "type": "boolean", + "default": false + }, + { + "path": "disable_search", + "label": "Disable search", + "description": "Turns off web search so the model answers from its own knowledge only.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "perplexity", + "authType": "api_key", + "model": "sonar-reasoning-pro", + "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, + "max": 128000 + } + }, + { + "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": "search_mode", + "label": "Search mode", + "description": "Selects the corpus the model searches when grounding its answer.", + "group": "provider_metadata", + "type": "enum", + "values": [ + "web", + "academic", + "sec" + ] + }, + { + "path": "search_recency_filter", + "label": "Search recency filter", + "description": "Restricts web search results to a recent time window.", + "group": "provider_metadata", + "type": "enum", + "values": [ + "hour", + "day", + "week", + "month", + "year" + ] + }, + { + "path": "search_domain_filter", + "label": "Search domain filter", + "description": "Limits search to, or excludes, specific domains.", + "group": "provider_metadata", + "type": "string" + }, + { + "path": "search_after_date_filter", + "label": "Search after date", + "description": "Restricts search results to content published after this date (MM/DD/YYYY).", + "group": "provider_metadata", + "type": "string" + }, + { + "path": "search_before_date_filter", + "label": "Search before date", + "description": "Restricts search results to content published before this date (MM/DD/YYYY).", + "group": "provider_metadata", + "type": "string" + }, + { + "path": "web_search_options.search_context_size", + "label": "Search context size", + "description": "Controls how much web search context is retrieved before generating the answer.", + "group": "provider_metadata", + "type": "enum", + "default": "low", + "values": [ + "low", + "medium", + "high" + ] + }, + { + "path": "return_images", + "label": "Return images", + "description": "Controls whether the response may include related images from the search.", + "group": "provider_metadata", + "type": "boolean", + "default": false + }, + { + "path": "return_related_questions", + "label": "Return related questions", + "description": "Controls whether the response includes suggested follow-up questions.", + "group": "provider_metadata", + "type": "boolean", + "default": false + }, + { + "path": "disable_search", + "label": "Disable search", + "description": "Turns off web search so the model answers from its own knowledge only.", + "group": "provider_metadata", + "type": "boolean", + "default": false + } + ] + }, + { + "provider": "xai", + "authType": "api_key", + "model": "grok-4.20-0309-non-reasoning", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max completion tokens", + "description": "Upper bound for visible output tokens generated in the chat completion.", + "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, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Optional seed used for decoding when reproducible sampling is desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "stop", + "label": "Stop sequence", + "description": "Stops generation when this sequence is produced. xAI accepts up to four stop sequences.", + "group": "generation_length", + "type": "string" + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns text, JSON mode output, or structured JSON schema output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object", + "json_schema" + ] + } + ] + }, + { + "provider": "xai", + "authType": "api_key", + "model": "grok-4.20-0309-reasoning", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max completion tokens", + "description": "Upper bound for visible output tokens generated in the chat completion.", + "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, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Optional seed used for decoding when reproducible sampling is desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns text, JSON mode output, or structured JSON schema output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object", + "json_schema" + ] + } + ] + }, + { + "provider": "xai", + "authType": "api_key", + "model": "grok-4.20-multi-agent-0309", + "params": [ + { + "path": "max_output_tokens", + "label": "Max output tokens", + "description": "Upper bound for output tokens generated in the Responses API response.", + "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": 0.7, + "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", + "default": 0.95, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "reasoning.effort", + "label": "Reasoning effort", + "description": "Controls whether the Responses API request uses the 4-agent or 16-agent multi-agent setup.", + "group": "reasoning", + "type": "enum", + "values": [ + "low", + "medium", + "high", + "xhigh" + ] + }, + { + "path": "text.format.type", + "label": "Text format", + "description": "Controls whether the Responses API returns free-form text, JSON mode output, or structured JSON schema output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object", + "json_schema" + ] + } + ] + }, + { + "provider": "xai", + "authType": "api_key", + "model": "grok-4.3", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max completion tokens", + "description": "Upper bound for visible output tokens generated in the chat completion.", + "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, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Optional seed used for decoding when reproducible sampling is desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning Grok performs before responding. Set to none for non-reasoning requests.", + "group": "reasoning", + "type": "enum", + "default": "low", + "values": [ + "none", + "low", + "medium", + "high" + ] + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns text, JSON mode output, or structured JSON schema output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object", + "json_schema" + ] + } + ] + }, + { + "provider": "xai", + "authType": "api_key", + "model": "grok-4.5", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max completion tokens", + "description": "Upper bound for visible output tokens generated in the chat completion.", + "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, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Optional seed used for decoding when reproducible sampling is desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning Grok performs before responding. Reasoning cannot be disabled for this model.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high" + ] + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns text, JSON mode output, or structured JSON schema output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object", + "json_schema" + ] + } + ] + }, + { + "provider": "xai", + "authType": "subscription", + "model": "grok-4.5", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max completion tokens", + "description": "Upper bound for visible output tokens generated in the chat completion.", + "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, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Optional seed used for decoding when reproducible sampling is desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "reasoning_effort", + "label": "Reasoning effort", + "description": "Controls how much reasoning Grok performs before responding. Reasoning cannot be disabled for this model.", + "group": "reasoning", + "type": "enum", + "default": "high", + "values": [ + "low", + "medium", + "high" + ] + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns text, JSON mode output, or structured JSON schema output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object", + "json_schema" + ] + } + ] + }, + { + "provider": "xai", + "authType": "api_key", + "model": "grok-build-0.1", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max completion tokens", + "description": "Upper bound for visible output tokens generated in the chat completion.", + "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, + "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", + "default": 1, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "seed", + "label": "Seed", + "description": "Optional seed used for decoding when reproducible sampling is desired.", + "group": "sampling", + "type": "integer" + }, + { + "path": "response_format.type", + "label": "Response format", + "description": "Controls whether the model returns text, JSON mode output, or structured JSON schema output.", + "group": "output_format", + "type": "enum", + "default": "text", + "values": [ + "text", + "json_object", + "json_schema" + ] + } + ] + }, + { + "provider": "xiaomi", + "authType": "api_key", + "model": "mimo-v2.5", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate, covering both the thinking trace and the final answer.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls whether MiMo reasons step by step before answering. Enabled by default; set disabled to respond directly.", + "group": "reasoning", + "type": "enum", + "default": "enabled", + "values": [ + "enabled", + "disabled" + ] + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values are more focused; higher values are more varied. Ignored while thinking is enabled, where it is forced to 1.0.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": "enabled" + } + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Nucleus sampling cutoff. Ignored while thinking is enabled, where it is forced to 0.95.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": "enabled" + } + }, + "type": "number", + "default": 0.95, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "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": "xiaomi", + "authType": "api_key", + "model": "mimo-v2.5-pro", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate, covering both the thinking trace and the final answer.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls whether MiMo reasons step by step before answering. Enabled by default; set disabled to respond directly.", + "group": "reasoning", + "type": "enum", + "default": "enabled", + "values": [ + "enabled", + "disabled" + ] + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values are more focused; higher values are more varied. Ignored while thinking is enabled, where it is forced to 1.0.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": "enabled" + } + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Nucleus sampling cutoff. Ignored while thinking is enabled, where it is forced to 0.95.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": "enabled" + } + }, + "type": "number", + "default": 0.95, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "path": "presence_penalty", + "label": "Presence penalty", + "description": "Penalizes tokens that have already appeared, encouraging the model to introduce new topics.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "frequency_penalty", + "label": "Frequency penalty", + "description": "Penalizes tokens in proportion to how often they have appeared, reducing verbatim repetition.", + "group": "sampling", + "type": "number", + "default": 0, + "range": { + "min": -2, + "max": 2, + "step": 0.1 + } + }, + { + "path": "stop", + "label": "Stop sequences", + "description": "Up to a few sequences where generation stops; the stop text is not included in the output.", + "group": "generation_length", + "type": "string" + }, + { + "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": "xiaomi", + "authType": "subscription", + "model": "mimo-v2.5", + "params": [ + { + "path": "max_completion_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate, covering both the thinking trace and the final answer.", + "group": "generation_length", + "type": "integer", + "range": { + "min": 1 + } + }, + { + "path": "thinking.type", + "label": "Thinking mode", + "description": "Controls whether MiMo reasons step by step before answering. Enabled by default; set disabled to respond directly.", + "group": "reasoning", + "type": "enum", + "default": "enabled", + "values": [ + "enabled", + "disabled" + ] + }, + { + "path": "temperature", + "label": "Temperature", + "description": "Controls randomness. Lower values are more focused; higher values are more varied. Ignored while thinking is enabled, where it is forced to 1.0.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": "enabled" + } + }, + "type": "number", + "default": 1, + "range": { + "min": 0, + "max": 2, + "step": 0.1 + } + }, + { + "path": "top_p", + "label": "Top P", + "description": "Nucleus sampling cutoff. Ignored while thinking is enabled, where it is forced to 0.95.", + "group": "sampling", + "applicability": { + "except": { + "thinking.type": "enabled" + } + }, + "type": "number", + "default": 0.95, + "range": { + "min": 0, + "max": 1, + "step": 0.01 + } + }, + { + "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": "api_key", + "model": "glm-4.5", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "applicability": { + "except": { + "do_sample": false + } + }, + "type": "number", + "default": 0.6, + "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": "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": "api_key", + "model": "glm-4.5-air", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "applicability": { + "except": { + "do_sample": false + } + }, + "type": "number", + "default": 0.6, + "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": "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-4.5-air", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "applicability": { + "except": { + "do_sample": false + } + }, + "type": "number", + "default": 0.6, + "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": "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": "api_key", + "model": "glm-4.5-airx", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "applicability": { + "except": { + "do_sample": false + } + }, + "type": "number", + "default": 0.6, + "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": "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": "api_key", + "model": "glm-4.5-flash", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "applicability": { + "except": { + "do_sample": false + } + }, + "type": "number", + "default": 0.6, + "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": "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-4.5", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "applicability": { + "except": { + "do_sample": false + } + }, + "type": "number", + "default": 0.6, + "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": "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": "api_key", + "model": "glm-4.5-x", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "applicability": { + "except": { + "do_sample": false + } + }, + "type": "number", + "default": 0.6, + "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": "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": "api_key", + "model": "glm-4.6", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "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": "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-4.6", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "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": "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": "api_key", + "model": "glm-4.7", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "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": "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": "api_key", + "model": "glm-4.7-flash", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "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": "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": "api_key", + "model": "glm-4.7-flashx", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "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": "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-4.7", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "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": "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": "api_key", + "model": "glm-5", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "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": "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", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "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": "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": "api_key", + "model": "glm-5-turbo", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "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": "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-turbo", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "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": "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": "api_key", + "model": "glm-5.1", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "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": "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.1", + "params": [ + { + "path": "max_tokens", + "label": "Max tokens", + "description": "Maximum number of tokens to generate in the response.", + "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", + "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": "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": "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 the model performs when thinking is enabled.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "enum", + "default": "max", + "values": [ + "max", + "xhigh", + "high", + "medium", + "low", + "minimal", + "none" + ] + }, + { + "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 the model performs when thinking is enabled.", + "group": "reasoning", + "applicability": { + "only": { + "thinking.type": "enabled" + } + }, + "type": "enum", + "default": "max", + "values": [ + "max", + "xhigh", + "high", + "medium", + "low", + "minimal", + "none" + ] + }, + { + "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" + ] + } + ] + } +] diff --git a/packages/modelparams-python/src/modelparams/_generated/model_ids.py b/packages/modelparams-python/src/modelparams/_generated/model_ids.py new file mode 100644 index 0000000..846d1ae --- /dev/null +++ b/packages/modelparams-python/src/modelparams/_generated/model_ids.py @@ -0,0 +1,472 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +from typing import Literal + +ModelId = Literal[ + "alibaba/qwen-flash", + "alibaba/qwen-plus", + "alibaba/qwen3-coder-flash", + "alibaba/qwen3-coder-plus", + "alibaba/qwen3-max", + "alibaba/qwen3.5", + "alibaba/qwen3.5-flash", + "alibaba/qwq-plus", + "anthropic/claude-3-5-haiku-20241022", + "anthropic/claude-3-5-haiku-latest", + "anthropic/claude-3-5-sonnet-20241022", + "anthropic/claude-3-5-sonnet-latest", + "anthropic/claude-3-7-sonnet-20250219", + "anthropic/claude-3-7-sonnet-latest", + "anthropic/claude-3-opus-20240229", + "anthropic/claude-3-opus-latest", + "anthropic/claude-fable-5", + "anthropic/claude-fable-5-subscription", + "anthropic/claude-haiku-4", + "anthropic/claude-haiku-4-5", + "anthropic/claude-haiku-4-5-20251001", + "anthropic/claude-haiku-4-5-20251001-subscription", + "anthropic/claude-haiku-4-5-subscription", + "anthropic/claude-haiku-4-subscription", + "anthropic/claude-opus-4-1-20250805", + "anthropic/claude-opus-4-1-20250805-subscription", + "anthropic/claude-opus-4-20250514", + "anthropic/claude-opus-4-20250514-subscription", + "anthropic/claude-opus-4-5-20251101", + "anthropic/claude-opus-4-5-20251101-subscription", + "anthropic/claude-opus-4-6", + "anthropic/claude-opus-4-6-subscription", + "anthropic/claude-opus-4-7", + "anthropic/claude-opus-4-7-subscription", + "anthropic/claude-opus-4-8", + "anthropic/claude-opus-4-8-subscription", + "anthropic/claude-opus-4-subscription", + "anthropic/claude-sonnet-4-20250514", + "anthropic/claude-sonnet-4-20250514-subscription", + "anthropic/claude-sonnet-4-5", + "anthropic/claude-sonnet-4-5-20250929", + "anthropic/claude-sonnet-4-5-20250929-subscription", + "anthropic/claude-sonnet-4-5-subscription", + "anthropic/claude-sonnet-4-6", + "anthropic/claude-sonnet-4-6-subscription", + "anthropic/claude-sonnet-4-subscription", + "anthropic/claude-sonnet-5", + "cerebras/zai-glm-4.7", + "cohere/command-a-03-2025", + "cohere/command-a-plus-05-2026", + "cohere/command-a-reasoning-08-2025", + "cohere/command-a-translate-08-2025", + "cohere/command-a-vision-07-2025", + "cohere/command-r-08-2024", + "cohere/command-r-plus-08-2024", + "cohere/command-r7b-12-2024", + "deepseek/deepseek-chat", + "deepseek/deepseek-reasoner", + "deepseek/deepseek-v4-flash", + "deepseek/deepseek-v4-pro", + "google/gemini-2.5-flash", + "google/gemini-2.5-flash-lite", + "google/gemini-2.5-flash-lite-subscription", + "google/gemini-2.5-flash-subscription", + "google/gemini-2.5-pro", + "google/gemini-2.5-pro-subscription", + "google/gemini-3-flash-preview-subscription", + "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/gemma-4-26b-a4b-it", + "google/gemma-4-31b-it", + "groq/qwen3-32b", + "meta/Llama-3.3-70B-Instruct", + "meta/Llama-3.3-8B-Instruct", + "meta/Llama-4-Maverick-17B-128E-Instruct-FP8", + "meta/Llama-4-Scout-17B-16E-Instruct-FP8", + "minimax/minimax-m2", + "minimax/MiniMax-M2-subscription", + "minimax/minimax-m2.1", + "minimax/minimax-m2.1-highspeed", + "minimax/MiniMax-M2.1-highspeed-subscription", + "minimax/MiniMax-M2.1-subscription", + "minimax/minimax-m2.5", + "minimax/minimax-m2.5-highspeed", + "minimax/MiniMax-M2.5-highspeed-subscription", + "minimax/MiniMax-M2.5-subscription", + "minimax/minimax-m2.7", + "minimax/minimax-m2.7-highspeed", + "minimax/MiniMax-M2.7-highspeed-subscription", + "minimax/MiniMax-M2.7-subscription", + "minimax/minimax-m3", + "minimax/MiniMax-M3-subscription", + "mistral/codestral-latest", + "mistral/devstral-2512", + "mistral/devstral-latest", + "mistral/magistral-medium-latest", + "mistral/magistral-small-latest", + "mistral/ministral-14b-latest", + "mistral/ministral-3b-latest", + "mistral/ministral-8b-latest", + "mistral/mistral-large-latest", + "mistral/mistral-medium-3.5", + "mistral/mistral-medium-latest", + "mistral/mistral-small-latest", + "mistral/open-mistral-nemo", + "moonshot/kimi-k2.5", + "moonshot/kimi-k2.6", + "moonshot/kimi-k2.6-subscription", + "moonshot/kimi-k2.7-code-highspeed-subscription", + "moonshot/kimi-k2.7-code-subscription", + "moonshot/moonshot-v1-128k", + "moonshot/moonshot-v1-32k", + "moonshot/moonshot-v1-8k", + "nvidia/gliner-pii", + "nvidia/llama-3.1-nemoguard-8b-topic-control", + "nvidia/llama-3.1-nemotron-nano-8b-v1", + "nvidia/llama-3.1-nemotron-safety-guard-8b-v3", + "nvidia/llama-3.1-nemotron-ultra-253b-v1", + "nvidia/llama-3.3-nemotron-super-49b-v1", + "nvidia/llama-3.3-nemotron-super-49b-v1.5", + "nvidia/nemoguard-jailbreak-detect", + "nvidia/nemotron-3-nano-30b-a3b", + "nvidia/nemotron-3-super-120b-a12b", + "nvidia/nemotron-3-ultra-550b-a55b", + "nvidia/nemotron-3-ultra-subscription", + "nvidia/nemotron-content-safety-reasoning-4b", + "nvidia/nemotron-mini-4b-instruct", + "nvidia/riva-translate-4b-instruct-v1.1", + "nvidia/usdcode-llama-3.1-70b-instruct", + "openai/chatgpt-4o-latest", + "openai/gpt-3.5-turbo", + "openai/gpt-4-turbo", + "openai/gpt-4-turbo-2024-04-09", + "openai/gpt-4.1", + "openai/gpt-4.1-mini", + "openai/gpt-4.1-nano", + "openai/gpt-4o", + "openai/gpt-4o-2024-11-20", + "openai/gpt-4o-mini", + "openai/gpt-5", + "openai/gpt-5-chat-latest", + "openai/gpt-5-mini", + "openai/gpt-5-nano", + "openai/gpt-5.1", + "openai/gpt-5.1-codex-max-subscription", + "openai/gpt-5.1-codex-subscription", + "openai/gpt-5.2", + "openai/gpt-5.2-codex-subscription", + "openai/gpt-5.2-subscription", + "openai/gpt-5.3-codex", + "openai/gpt-5.3-codex-spark-subscription", + "openai/gpt-5.3-codex-subscription", + "openai/gpt-5.4", + "openai/gpt-5.4-mini", + "openai/gpt-5.4-mini-subscription", + "openai/gpt-5.4-nano", + "openai/gpt-5.4-pro", + "openai/gpt-5.4-pro-subscription", + "openai/gpt-5.4-subscription", + "openai/gpt-5.5", + "openai/gpt-5.5-pro", + "openai/gpt-5.5-pro-subscription", + "openai/gpt-5.5-subscription", + "openai/gpt-5.6-luna", + "openai/gpt-5.6-sol", + "openai/gpt-oss-120b", + "openai/gpt-oss-20b", + "openai/o1", + "openai/o1-mini", + "openai/o1-preview", + "openai/o3", + "openai/o3-mini", + "openai/o3-pro", + "openai/o4-mini", + "perplexity/sonar", + "perplexity/sonar-deep-research", + "perplexity/sonar-pro", + "perplexity/sonar-reasoning-pro", + "xai/grok-4.20-0309-non-reasoning", + "xai/grok-4.20-0309-reasoning", + "xai/grok-4.20-multi-agent-0309", + "xai/grok-4.3", + "xai/grok-4.5", + "xai/grok-4.5-subscription", + "xai/grok-build-0.1", + "xiaomi/mimo-v2.5", + "xiaomi/mimo-v2.5-pro", + "xiaomi/mimo-v2.5-subscription", + "z-ai/glm-4.5", + "z-ai/glm-4.5-air", + "z-ai/glm-4.5-air-subscription", + "z-ai/glm-4.5-airx", + "z-ai/glm-4.5-flash", + "z-ai/glm-4.5-subscription", + "z-ai/glm-4.5-x", + "z-ai/glm-4.6", + "z-ai/glm-4.6-subscription", + "z-ai/glm-4.7", + "z-ai/glm-4.7-flash", + "z-ai/glm-4.7-flashx", + "z-ai/glm-4.7-subscription", + "z-ai/glm-5", + "z-ai/glm-5-subscription", + "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.2", + "z-ai/glm-5.2-subscription", +] + +MODEL_IDS: tuple[ModelId, ...] = ( + "alibaba/qwen-flash", + "alibaba/qwen-plus", + "alibaba/qwen3-coder-flash", + "alibaba/qwen3-coder-plus", + "alibaba/qwen3-max", + "alibaba/qwen3.5", + "alibaba/qwen3.5-flash", + "alibaba/qwq-plus", + "anthropic/claude-3-5-haiku-20241022", + "anthropic/claude-3-5-haiku-latest", + "anthropic/claude-3-5-sonnet-20241022", + "anthropic/claude-3-5-sonnet-latest", + "anthropic/claude-3-7-sonnet-20250219", + "anthropic/claude-3-7-sonnet-latest", + "anthropic/claude-3-opus-20240229", + "anthropic/claude-3-opus-latest", + "anthropic/claude-fable-5", + "anthropic/claude-fable-5-subscription", + "anthropic/claude-haiku-4", + "anthropic/claude-haiku-4-5", + "anthropic/claude-haiku-4-5-20251001", + "anthropic/claude-haiku-4-5-20251001-subscription", + "anthropic/claude-haiku-4-5-subscription", + "anthropic/claude-haiku-4-subscription", + "anthropic/claude-opus-4-1-20250805", + "anthropic/claude-opus-4-1-20250805-subscription", + "anthropic/claude-opus-4-20250514", + "anthropic/claude-opus-4-20250514-subscription", + "anthropic/claude-opus-4-5-20251101", + "anthropic/claude-opus-4-5-20251101-subscription", + "anthropic/claude-opus-4-6", + "anthropic/claude-opus-4-6-subscription", + "anthropic/claude-opus-4-7", + "anthropic/claude-opus-4-7-subscription", + "anthropic/claude-opus-4-8", + "anthropic/claude-opus-4-8-subscription", + "anthropic/claude-opus-4-subscription", + "anthropic/claude-sonnet-4-20250514", + "anthropic/claude-sonnet-4-20250514-subscription", + "anthropic/claude-sonnet-4-5", + "anthropic/claude-sonnet-4-5-20250929", + "anthropic/claude-sonnet-4-5-20250929-subscription", + "anthropic/claude-sonnet-4-5-subscription", + "anthropic/claude-sonnet-4-6", + "anthropic/claude-sonnet-4-6-subscription", + "anthropic/claude-sonnet-4-subscription", + "anthropic/claude-sonnet-5", + "cerebras/zai-glm-4.7", + "cohere/command-a-03-2025", + "cohere/command-a-plus-05-2026", + "cohere/command-a-reasoning-08-2025", + "cohere/command-a-translate-08-2025", + "cohere/command-a-vision-07-2025", + "cohere/command-r-08-2024", + "cohere/command-r-plus-08-2024", + "cohere/command-r7b-12-2024", + "deepseek/deepseek-chat", + "deepseek/deepseek-reasoner", + "deepseek/deepseek-v4-flash", + "deepseek/deepseek-v4-pro", + "google/gemini-2.5-flash", + "google/gemini-2.5-flash-lite", + "google/gemini-2.5-flash-lite-subscription", + "google/gemini-2.5-flash-subscription", + "google/gemini-2.5-pro", + "google/gemini-2.5-pro-subscription", + "google/gemini-3-flash-preview-subscription", + "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/gemma-4-26b-a4b-it", + "google/gemma-4-31b-it", + "groq/qwen3-32b", + "meta/Llama-3.3-70B-Instruct", + "meta/Llama-3.3-8B-Instruct", + "meta/Llama-4-Maverick-17B-128E-Instruct-FP8", + "meta/Llama-4-Scout-17B-16E-Instruct-FP8", + "minimax/minimax-m2", + "minimax/MiniMax-M2-subscription", + "minimax/minimax-m2.1", + "minimax/minimax-m2.1-highspeed", + "minimax/MiniMax-M2.1-highspeed-subscription", + "minimax/MiniMax-M2.1-subscription", + "minimax/minimax-m2.5", + "minimax/minimax-m2.5-highspeed", + "minimax/MiniMax-M2.5-highspeed-subscription", + "minimax/MiniMax-M2.5-subscription", + "minimax/minimax-m2.7", + "minimax/minimax-m2.7-highspeed", + "minimax/MiniMax-M2.7-highspeed-subscription", + "minimax/MiniMax-M2.7-subscription", + "minimax/minimax-m3", + "minimax/MiniMax-M3-subscription", + "mistral/codestral-latest", + "mistral/devstral-2512", + "mistral/devstral-latest", + "mistral/magistral-medium-latest", + "mistral/magistral-small-latest", + "mistral/ministral-14b-latest", + "mistral/ministral-3b-latest", + "mistral/ministral-8b-latest", + "mistral/mistral-large-latest", + "mistral/mistral-medium-3.5", + "mistral/mistral-medium-latest", + "mistral/mistral-small-latest", + "mistral/open-mistral-nemo", + "moonshot/kimi-k2.5", + "moonshot/kimi-k2.6", + "moonshot/kimi-k2.6-subscription", + "moonshot/kimi-k2.7-code-highspeed-subscription", + "moonshot/kimi-k2.7-code-subscription", + "moonshot/moonshot-v1-128k", + "moonshot/moonshot-v1-32k", + "moonshot/moonshot-v1-8k", + "nvidia/gliner-pii", + "nvidia/llama-3.1-nemoguard-8b-topic-control", + "nvidia/llama-3.1-nemotron-nano-8b-v1", + "nvidia/llama-3.1-nemotron-safety-guard-8b-v3", + "nvidia/llama-3.1-nemotron-ultra-253b-v1", + "nvidia/llama-3.3-nemotron-super-49b-v1", + "nvidia/llama-3.3-nemotron-super-49b-v1.5", + "nvidia/nemoguard-jailbreak-detect", + "nvidia/nemotron-3-nano-30b-a3b", + "nvidia/nemotron-3-super-120b-a12b", + "nvidia/nemotron-3-ultra-550b-a55b", + "nvidia/nemotron-3-ultra-subscription", + "nvidia/nemotron-content-safety-reasoning-4b", + "nvidia/nemotron-mini-4b-instruct", + "nvidia/riva-translate-4b-instruct-v1.1", + "nvidia/usdcode-llama-3.1-70b-instruct", + "openai/chatgpt-4o-latest", + "openai/gpt-3.5-turbo", + "openai/gpt-4-turbo", + "openai/gpt-4-turbo-2024-04-09", + "openai/gpt-4.1", + "openai/gpt-4.1-mini", + "openai/gpt-4.1-nano", + "openai/gpt-4o", + "openai/gpt-4o-2024-11-20", + "openai/gpt-4o-mini", + "openai/gpt-5", + "openai/gpt-5-chat-latest", + "openai/gpt-5-mini", + "openai/gpt-5-nano", + "openai/gpt-5.1", + "openai/gpt-5.1-codex-max-subscription", + "openai/gpt-5.1-codex-subscription", + "openai/gpt-5.2", + "openai/gpt-5.2-codex-subscription", + "openai/gpt-5.2-subscription", + "openai/gpt-5.3-codex", + "openai/gpt-5.3-codex-spark-subscription", + "openai/gpt-5.3-codex-subscription", + "openai/gpt-5.4", + "openai/gpt-5.4-mini", + "openai/gpt-5.4-mini-subscription", + "openai/gpt-5.4-nano", + "openai/gpt-5.4-pro", + "openai/gpt-5.4-pro-subscription", + "openai/gpt-5.4-subscription", + "openai/gpt-5.5", + "openai/gpt-5.5-pro", + "openai/gpt-5.5-pro-subscription", + "openai/gpt-5.5-subscription", + "openai/gpt-5.6-luna", + "openai/gpt-5.6-sol", + "openai/gpt-oss-120b", + "openai/gpt-oss-20b", + "openai/o1", + "openai/o1-mini", + "openai/o1-preview", + "openai/o3", + "openai/o3-mini", + "openai/o3-pro", + "openai/o4-mini", + "perplexity/sonar", + "perplexity/sonar-deep-research", + "perplexity/sonar-pro", + "perplexity/sonar-reasoning-pro", + "xai/grok-4.20-0309-non-reasoning", + "xai/grok-4.20-0309-reasoning", + "xai/grok-4.20-multi-agent-0309", + "xai/grok-4.3", + "xai/grok-4.5", + "xai/grok-4.5-subscription", + "xai/grok-build-0.1", + "xiaomi/mimo-v2.5", + "xiaomi/mimo-v2.5-pro", + "xiaomi/mimo-v2.5-subscription", + "z-ai/glm-4.5", + "z-ai/glm-4.5-air", + "z-ai/glm-4.5-air-subscription", + "z-ai/glm-4.5-airx", + "z-ai/glm-4.5-flash", + "z-ai/glm-4.5-subscription", + "z-ai/glm-4.5-x", + "z-ai/glm-4.6", + "z-ai/glm-4.6-subscription", + "z-ai/glm-4.7", + "z-ai/glm-4.7-flash", + "z-ai/glm-4.7-flashx", + "z-ai/glm-4.7-subscription", + "z-ai/glm-5", + "z-ai/glm-5-subscription", + "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.2", + "z-ai/glm-5.2-subscription", +) + +Provider = Literal[ + "alibaba", + "anthropic", + "cerebras", + "cohere", + "deepseek", + "google", + "groq", + "meta", + "minimax", + "mistral", + "moonshot", + "nvidia", + "openai", + "perplexity", + "xai", + "xiaomi", + "z-ai", +] + +PROVIDERS: tuple[Provider, ...] = ( + "alibaba", + "anthropic", + "cerebras", + "cohere", + "deepseek", + "google", + "groq", + "meta", + "minimax", + "mistral", + "moonshot", + "nvidia", + "openai", + "perplexity", + "xai", + "xiaomi", + "z-ai", +) diff --git a/packages/modelparams-python/src/modelparams/_generated/registry.py b/packages/modelparams-python/src/modelparams/_generated/registry.py new file mode 100644 index 0000000..c9814ba --- /dev/null +++ b/packages/modelparams-python/src/modelparams/_generated/registry.py @@ -0,0 +1,238 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +from typing import Any + +from modelparams.types import alibaba +from modelparams.types import anthropic +from modelparams.types import cerebras +from modelparams.types import cohere +from modelparams.types import deepseek +from modelparams.types import google +from modelparams.types import groq +from modelparams.types import meta +from modelparams.types import minimax +from modelparams.types import mistral +from modelparams.types import moonshot +from modelparams.types import nvidia +from modelparams.types import openai +from modelparams.types import perplexity +from modelparams.types import xai +from modelparams.types import xiaomi +from modelparams.types import z_ai + +from .model_ids import ModelId + +PARAM_TYPES: dict[ModelId, Any] = { + "alibaba/qwen-flash": alibaba.Qwen_FlashParams, + "alibaba/qwen-plus": alibaba.Qwen_PlusParams, + "alibaba/qwen3-coder-flash": alibaba.Qwen3_Coder_FlashParams, + "alibaba/qwen3-coder-plus": alibaba.Qwen3_Coder_PlusParams, + "alibaba/qwen3-max": alibaba.Qwen3_MaxParams, + "alibaba/qwen3.5": alibaba.Qwen3_5Params, + "alibaba/qwen3.5-flash": alibaba.Qwen3_5_FlashParams, + "alibaba/qwq-plus": alibaba.Qwq_PlusParams, + "anthropic/claude-3-5-haiku-20241022": anthropic.Claude_3_5_Haiku_20241022Params, + "anthropic/claude-3-5-haiku-latest": anthropic.Claude_3_5_Haiku_LatestParams, + "anthropic/claude-3-5-sonnet-20241022": anthropic.Claude_3_5_Sonnet_20241022Params, + "anthropic/claude-3-5-sonnet-latest": anthropic.Claude_3_5_Sonnet_LatestParams, + "anthropic/claude-3-7-sonnet-20250219": anthropic.Claude_3_7_Sonnet_20250219Params, + "anthropic/claude-3-7-sonnet-latest": anthropic.Claude_3_7_Sonnet_LatestParams, + "anthropic/claude-3-opus-20240229": anthropic.Claude_3_Opus_20240229Params, + "anthropic/claude-3-opus-latest": anthropic.Claude_3_Opus_LatestParams, + "anthropic/claude-fable-5": anthropic.Claude_Fable_5Params, + "anthropic/claude-fable-5-subscription": anthropic.Claude_Fable_5_SubscriptionParams, + "anthropic/claude-haiku-4": anthropic.Claude_Haiku_4Params, + "anthropic/claude-haiku-4-5": anthropic.Claude_Haiku_4_5Params, + "anthropic/claude-haiku-4-5-20251001": anthropic.Claude_Haiku_4_5_20251001Params, + "anthropic/claude-haiku-4-5-20251001-subscription": anthropic.Claude_Haiku_4_5_20251001_SubscriptionParams, + "anthropic/claude-haiku-4-5-subscription": anthropic.Claude_Haiku_4_5_SubscriptionParams, + "anthropic/claude-haiku-4-subscription": anthropic.Claude_Haiku_4_SubscriptionParams, + "anthropic/claude-opus-4-1-20250805": anthropic.Claude_Opus_4_1_20250805Params, + "anthropic/claude-opus-4-1-20250805-subscription": anthropic.Claude_Opus_4_1_20250805_SubscriptionParams, + "anthropic/claude-opus-4-20250514": anthropic.Claude_Opus_4_20250514Params, + "anthropic/claude-opus-4-20250514-subscription": anthropic.Claude_Opus_4_20250514_SubscriptionParams, + "anthropic/claude-opus-4-5-20251101": anthropic.Claude_Opus_4_5_20251101Params, + "anthropic/claude-opus-4-5-20251101-subscription": anthropic.Claude_Opus_4_5_20251101_SubscriptionParams, + "anthropic/claude-opus-4-6": anthropic.Claude_Opus_4_6Params, + "anthropic/claude-opus-4-6-subscription": anthropic.Claude_Opus_4_6_SubscriptionParams, + "anthropic/claude-opus-4-7": anthropic.Claude_Opus_4_7Params, + "anthropic/claude-opus-4-7-subscription": anthropic.Claude_Opus_4_7_SubscriptionParams, + "anthropic/claude-opus-4-8": anthropic.Claude_Opus_4_8Params, + "anthropic/claude-opus-4-8-subscription": anthropic.Claude_Opus_4_8_SubscriptionParams, + "anthropic/claude-opus-4-subscription": anthropic.Claude_Opus_4_SubscriptionParams, + "anthropic/claude-sonnet-4-20250514": anthropic.Claude_Sonnet_4_20250514Params, + "anthropic/claude-sonnet-4-20250514-subscription": anthropic.Claude_Sonnet_4_20250514_SubscriptionParams, + "anthropic/claude-sonnet-4-5": anthropic.Claude_Sonnet_4_5Params, + "anthropic/claude-sonnet-4-5-20250929": anthropic.Claude_Sonnet_4_5_20250929Params, + "anthropic/claude-sonnet-4-5-20250929-subscription": anthropic.Claude_Sonnet_4_5_20250929_SubscriptionParams, + "anthropic/claude-sonnet-4-5-subscription": anthropic.Claude_Sonnet_4_5_SubscriptionParams, + "anthropic/claude-sonnet-4-6": anthropic.Claude_Sonnet_4_6Params, + "anthropic/claude-sonnet-4-6-subscription": anthropic.Claude_Sonnet_4_6_SubscriptionParams, + "anthropic/claude-sonnet-4-subscription": anthropic.Claude_Sonnet_4_SubscriptionParams, + "anthropic/claude-sonnet-5": anthropic.Claude_Sonnet_5Params, + "cerebras/zai-glm-4.7": cerebras.Zai_Glm_4_7Params, + "cohere/command-a-03-2025": cohere.Command_A_03_2025Params, + "cohere/command-a-plus-05-2026": cohere.Command_A_Plus_05_2026Params, + "cohere/command-a-reasoning-08-2025": cohere.Command_A_Reasoning_08_2025Params, + "cohere/command-a-translate-08-2025": cohere.Command_A_Translate_08_2025Params, + "cohere/command-a-vision-07-2025": cohere.Command_A_Vision_07_2025Params, + "cohere/command-r-08-2024": cohere.Command_R_08_2024Params, + "cohere/command-r-plus-08-2024": cohere.Command_R_Plus_08_2024Params, + "cohere/command-r7b-12-2024": cohere.Command_R7b_12_2024Params, + "deepseek/deepseek-chat": deepseek.Deepseek_ChatParams, + "deepseek/deepseek-reasoner": deepseek.Deepseek_ReasonerParams, + "deepseek/deepseek-v4-flash": deepseek.Deepseek_V4_FlashParams, + "deepseek/deepseek-v4-pro": deepseek.Deepseek_V4_ProParams, + "google/gemini-2.5-flash": google.Gemini_2_5_FlashParams, + "google/gemini-2.5-flash-lite": google.Gemini_2_5_Flash_LiteParams, + "google/gemini-2.5-flash-lite-subscription": google.Gemini_2_5_Flash_Lite_SubscriptionParams, + "google/gemini-2.5-flash-subscription": google.Gemini_2_5_Flash_SubscriptionParams, + "google/gemini-2.5-pro": google.Gemini_2_5_ProParams, + "google/gemini-2.5-pro-subscription": google.Gemini_2_5_Pro_SubscriptionParams, + "google/gemini-3-flash-preview-subscription": google.Gemini_3_Flash_Preview_SubscriptionParams, + "google/gemini-3.1-flash-lite-preview-subscription": google.Gemini_3_1_Flash_Lite_Preview_SubscriptionParams, + "google/gemini-3.1-flash-lite-subscription": google.Gemini_3_1_Flash_Lite_SubscriptionParams, + "google/gemini-3.1-pro-preview-subscription": google.Gemini_3_1_Pro_Preview_SubscriptionParams, + "google/gemini-3.5-flash": google.Gemini_3_5_FlashParams, + "google/gemma-4-26b-a4b-it": google.Gemma_4_26b_A4b_ItParams, + "google/gemma-4-31b-it": google.Gemma_4_31b_ItParams, + "groq/qwen3-32b": groq.Qwen3_32bParams, + "meta/Llama-3.3-70B-Instruct": meta.Llama_3_3_70b_InstructParams, + "meta/Llama-3.3-8B-Instruct": meta.Llama_3_3_8b_InstructParams, + "meta/Llama-4-Maverick-17B-128E-Instruct-FP8": meta.Llama_4_Maverick_17b_128e_Instruct_Fp8Params, + "meta/Llama-4-Scout-17B-16E-Instruct-FP8": meta.Llama_4_Scout_17b_16e_Instruct_Fp8Params, + "minimax/minimax-m2": minimax.Minimax_M2Params, + "minimax/MiniMax-M2-subscription": minimax.Minimax_M2_SubscriptionParams, + "minimax/minimax-m2.1": minimax.Minimax_M2_1Params, + "minimax/minimax-m2.1-highspeed": minimax.Minimax_M2_1_HighspeedParams, + "minimax/MiniMax-M2.1-highspeed-subscription": minimax.Minimax_M2_1_Highspeed_SubscriptionParams, + "minimax/MiniMax-M2.1-subscription": minimax.Minimax_M2_1_SubscriptionParams, + "minimax/minimax-m2.5": minimax.Minimax_M2_5Params, + "minimax/minimax-m2.5-highspeed": minimax.Minimax_M2_5_HighspeedParams, + "minimax/MiniMax-M2.5-highspeed-subscription": minimax.Minimax_M2_5_Highspeed_SubscriptionParams, + "minimax/MiniMax-M2.5-subscription": minimax.Minimax_M2_5_SubscriptionParams, + "minimax/minimax-m2.7": minimax.Minimax_M2_7Params, + "minimax/minimax-m2.7-highspeed": minimax.Minimax_M2_7_HighspeedParams, + "minimax/MiniMax-M2.7-highspeed-subscription": minimax.Minimax_M2_7_Highspeed_SubscriptionParams, + "minimax/MiniMax-M2.7-subscription": minimax.Minimax_M2_7_SubscriptionParams, + "minimax/minimax-m3": minimax.Minimax_M3Params, + "minimax/MiniMax-M3-subscription": minimax.Minimax_M3_SubscriptionParams, + "mistral/codestral-latest": mistral.Codestral_LatestParams, + "mistral/devstral-2512": mistral.Devstral_2512Params, + "mistral/devstral-latest": mistral.Devstral_LatestParams, + "mistral/magistral-medium-latest": mistral.Magistral_Medium_LatestParams, + "mistral/magistral-small-latest": mistral.Magistral_Small_LatestParams, + "mistral/ministral-14b-latest": mistral.Ministral_14b_LatestParams, + "mistral/ministral-3b-latest": mistral.Ministral_3b_LatestParams, + "mistral/ministral-8b-latest": mistral.Ministral_8b_LatestParams, + "mistral/mistral-large-latest": mistral.Mistral_Large_LatestParams, + "mistral/mistral-medium-3.5": mistral.Mistral_Medium_3_5Params, + "mistral/mistral-medium-latest": mistral.Mistral_Medium_LatestParams, + "mistral/mistral-small-latest": mistral.Mistral_Small_LatestParams, + "mistral/open-mistral-nemo": mistral.Open_Mistral_NemoParams, + "moonshot/kimi-k2.5": moonshot.Kimi_K2_5Params, + "moonshot/kimi-k2.6": moonshot.Kimi_K2_6Params, + "moonshot/kimi-k2.6-subscription": moonshot.Kimi_K2_6_SubscriptionParams, + "moonshot/kimi-k2.7-code-highspeed-subscription": moonshot.Kimi_K2_7_Code_Highspeed_SubscriptionParams, + "moonshot/kimi-k2.7-code-subscription": moonshot.Kimi_K2_7_Code_SubscriptionParams, + "moonshot/moonshot-v1-128k": moonshot.Moonshot_V1_128kParams, + "moonshot/moonshot-v1-32k": moonshot.Moonshot_V1_32kParams, + "moonshot/moonshot-v1-8k": moonshot.Moonshot_V1_8kParams, + "nvidia/gliner-pii": nvidia.Gliner_PiiParams, + "nvidia/llama-3.1-nemoguard-8b-topic-control": nvidia.Llama_3_1_Nemoguard_8b_Topic_ControlParams, + "nvidia/llama-3.1-nemotron-nano-8b-v1": nvidia.Llama_3_1_Nemotron_Nano_8b_V1Params, + "nvidia/llama-3.1-nemotron-safety-guard-8b-v3": nvidia.Llama_3_1_Nemotron_Safety_Guard_8b_V3Params, + "nvidia/llama-3.1-nemotron-ultra-253b-v1": nvidia.Llama_3_1_Nemotron_Ultra_253b_V1Params, + "nvidia/llama-3.3-nemotron-super-49b-v1": nvidia.Llama_3_3_Nemotron_Super_49b_V1Params, + "nvidia/llama-3.3-nemotron-super-49b-v1.5": nvidia.Llama_3_3_Nemotron_Super_49b_V1_5Params, + "nvidia/nemoguard-jailbreak-detect": nvidia.Nemoguard_Jailbreak_DetectParams, + "nvidia/nemotron-3-nano-30b-a3b": nvidia.Nemotron_3_Nano_30b_A3bParams, + "nvidia/nemotron-3-super-120b-a12b": nvidia.Nemotron_3_Super_120b_A12bParams, + "nvidia/nemotron-3-ultra-550b-a55b": nvidia.Nemotron_3_Ultra_550b_A55bParams, + "nvidia/nemotron-3-ultra-subscription": nvidia.Nemotron_3_Ultra_SubscriptionParams, + "nvidia/nemotron-content-safety-reasoning-4b": nvidia.Nemotron_Content_Safety_Reasoning_4bParams, + "nvidia/nemotron-mini-4b-instruct": nvidia.Nemotron_Mini_4b_InstructParams, + "nvidia/riva-translate-4b-instruct-v1.1": nvidia.Riva_Translate_4b_Instruct_V1_1Params, + "nvidia/usdcode-llama-3.1-70b-instruct": nvidia.Usdcode_Llama_3_1_70b_InstructParams, + "openai/chatgpt-4o-latest": openai.Chatgpt_4o_LatestParams, + "openai/gpt-3.5-turbo": openai.Gpt_3_5_TurboParams, + "openai/gpt-4-turbo": openai.Gpt_4_TurboParams, + "openai/gpt-4-turbo-2024-04-09": openai.Gpt_4_Turbo_2024_04_09Params, + "openai/gpt-4.1": openai.Gpt_4_1Params, + "openai/gpt-4.1-mini": openai.Gpt_4_1_MiniParams, + "openai/gpt-4.1-nano": openai.Gpt_4_1_NanoParams, + "openai/gpt-4o": openai.Gpt_4oParams, + "openai/gpt-4o-2024-11-20": openai.Gpt_4o_2024_11_20Params, + "openai/gpt-4o-mini": openai.Gpt_4o_MiniParams, + "openai/gpt-5": openai.Gpt_5Params, + "openai/gpt-5-chat-latest": openai.Gpt_5_Chat_LatestParams, + "openai/gpt-5-mini": openai.Gpt_5_MiniParams, + "openai/gpt-5-nano": openai.Gpt_5_NanoParams, + "openai/gpt-5.1": openai.Gpt_5_1Params, + "openai/gpt-5.1-codex-max-subscription": openai.Gpt_5_1_Codex_Max_SubscriptionParams, + "openai/gpt-5.1-codex-subscription": openai.Gpt_5_1_Codex_SubscriptionParams, + "openai/gpt-5.2": openai.Gpt_5_2Params, + "openai/gpt-5.2-codex-subscription": openai.Gpt_5_2_Codex_SubscriptionParams, + "openai/gpt-5.2-subscription": openai.Gpt_5_2_SubscriptionParams, + "openai/gpt-5.3-codex": openai.Gpt_5_3_CodexParams, + "openai/gpt-5.3-codex-spark-subscription": openai.Gpt_5_3_Codex_Spark_SubscriptionParams, + "openai/gpt-5.3-codex-subscription": openai.Gpt_5_3_Codex_SubscriptionParams, + "openai/gpt-5.4": openai.Gpt_5_4Params, + "openai/gpt-5.4-mini": openai.Gpt_5_4_MiniParams, + "openai/gpt-5.4-mini-subscription": openai.Gpt_5_4_Mini_SubscriptionParams, + "openai/gpt-5.4-nano": openai.Gpt_5_4_NanoParams, + "openai/gpt-5.4-pro": openai.Gpt_5_4_ProParams, + "openai/gpt-5.4-pro-subscription": openai.Gpt_5_4_Pro_SubscriptionParams, + "openai/gpt-5.4-subscription": openai.Gpt_5_4_SubscriptionParams, + "openai/gpt-5.5": openai.Gpt_5_5Params, + "openai/gpt-5.5-pro": openai.Gpt_5_5_ProParams, + "openai/gpt-5.5-pro-subscription": openai.Gpt_5_5_Pro_SubscriptionParams, + "openai/gpt-5.5-subscription": openai.Gpt_5_5_SubscriptionParams, + "openai/gpt-5.6-luna": openai.Gpt_5_6_LunaParams, + "openai/gpt-5.6-sol": openai.Gpt_5_6_SolParams, + "openai/gpt-oss-120b": openai.Gpt_Oss_120bParams, + "openai/gpt-oss-20b": openai.Gpt_Oss_20bParams, + "openai/o1": openai.O1Params, + "openai/o1-mini": openai.O1_MiniParams, + "openai/o1-preview": openai.O1_PreviewParams, + "openai/o3": openai.O3Params, + "openai/o3-mini": openai.O3_MiniParams, + "openai/o3-pro": openai.O3_ProParams, + "openai/o4-mini": openai.O4_MiniParams, + "perplexity/sonar": perplexity.SonarParams, + "perplexity/sonar-deep-research": perplexity.Sonar_Deep_ResearchParams, + "perplexity/sonar-pro": perplexity.Sonar_ProParams, + "perplexity/sonar-reasoning-pro": perplexity.Sonar_Reasoning_ProParams, + "xai/grok-4.20-0309-non-reasoning": xai.Grok_4_20_0309_Non_ReasoningParams, + "xai/grok-4.20-0309-reasoning": xai.Grok_4_20_0309_ReasoningParams, + "xai/grok-4.20-multi-agent-0309": xai.Grok_4_20_Multi_Agent_0309Params, + "xai/grok-4.3": xai.Grok_4_3Params, + "xai/grok-4.5": xai.Grok_4_5Params, + "xai/grok-4.5-subscription": xai.Grok_4_5_SubscriptionParams, + "xai/grok-build-0.1": xai.Grok_Build_0_1Params, + "xiaomi/mimo-v2.5": xiaomi.Mimo_V2_5Params, + "xiaomi/mimo-v2.5-pro": xiaomi.Mimo_V2_5_ProParams, + "xiaomi/mimo-v2.5-subscription": xiaomi.Mimo_V2_5_SubscriptionParams, + "z-ai/glm-4.5": z_ai.Glm_4_5Params, + "z-ai/glm-4.5-air": z_ai.Glm_4_5_AirParams, + "z-ai/glm-4.5-air-subscription": z_ai.Glm_4_5_Air_SubscriptionParams, + "z-ai/glm-4.5-airx": z_ai.Glm_4_5_AirxParams, + "z-ai/glm-4.5-flash": z_ai.Glm_4_5_FlashParams, + "z-ai/glm-4.5-subscription": z_ai.Glm_4_5_SubscriptionParams, + "z-ai/glm-4.5-x": z_ai.Glm_4_5_XParams, + "z-ai/glm-4.6": z_ai.Glm_4_6Params, + "z-ai/glm-4.6-subscription": z_ai.Glm_4_6_SubscriptionParams, + "z-ai/glm-4.7": z_ai.Glm_4_7Params, + "z-ai/glm-4.7-flash": z_ai.Glm_4_7_FlashParams, + "z-ai/glm-4.7-flashx": z_ai.Glm_4_7_FlashxParams, + "z-ai/glm-4.7-subscription": z_ai.Glm_4_7_SubscriptionParams, + "z-ai/glm-5": z_ai.Glm_5Params, + "z-ai/glm-5-subscription": z_ai.Glm_5_SubscriptionParams, + "z-ai/glm-5-turbo": z_ai.Glm_5_TurboParams, + "z-ai/glm-5-turbo-subscription": z_ai.Glm_5_Turbo_SubscriptionParams, + "z-ai/glm-5.1": z_ai.Glm_5_1Params, + "z-ai/glm-5.1-subscription": z_ai.Glm_5_1_SubscriptionParams, + "z-ai/glm-5.2": z_ai.Glm_5_2Params, + "z-ai/glm-5.2-subscription": z_ai.Glm_5_2_SubscriptionParams, +} diff --git a/packages/modelparams-python/src/modelparams/catalog.py b/packages/modelparams-python/src/modelparams/catalog.py new file mode 100644 index 0000000..b455145 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/catalog.py @@ -0,0 +1,59 @@ +from __future__ import annotations + +from collections.abc import Mapping +from importlib.resources import files +from types import MappingProxyType +from typing import cast + +from pydantic import TypeAdapter + +from ._generated.model_ids import MODEL_IDS, ModelId, Provider +from .models import CatalogEntry, JsonPrimitive, Parameter + +_catalog_bytes = files("modelparams._generated").joinpath("catalog.json").read_bytes() +CATALOG = TypeAdapter(tuple[CatalogEntry, ...]).validate_json(_catalog_bytes) + + +def _entry_id(entry: CatalogEntry) -> str: + suffix = "" if entry.auth_type == "api_key" else "-subscription" + return f"{entry.provider}/{entry.model}{suffix}" + + +BY_ID: Mapping[ModelId, CatalogEntry] = MappingProxyType( + cast(dict[ModelId, CatalogEntry], {_entry_id(entry): entry for entry in CATALOG}) +) +DEFAULTS: Mapping[ModelId, Mapping[str, JsonPrimitive]] = MappingProxyType( + { + model_id: MappingProxyType( + { + parameter.path: parameter.default + for parameter in entry.params + if "default" in parameter.model_fields_set + } + ) + for model_id, entry in BY_ID.items() + } +) + + +def get_model(model_id: ModelId) -> CatalogEntry: + return BY_ID[model_id] + + +def get_defaults(model_id: ModelId) -> Mapping[str, JsonPrimitive]: + return DEFAULTS[model_id] + + +def list_models(provider: Provider | None = None) -> tuple[ModelId, ...]: + if provider is None: + return MODEL_IDS + prefix = f"{provider}/" + return tuple(model_id for model_id in MODEL_IDS if model_id.startswith(prefix)) + + +def get_param(model_id: ModelId, path: str) -> Parameter | None: + return next((parameter for parameter in BY_ID[model_id].params if parameter.path == path), None) + + +def list_all_models() -> tuple[CatalogEntry, ...]: + return CATALOG diff --git a/packages/modelparams-python/src/modelparams/models.py b/packages/modelparams-python/src/modelparams/models.py new file mode 100644 index 0000000..7c111a8 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/models.py @@ -0,0 +1,62 @@ +from __future__ import annotations + +from typing import Literal, TypeAlias + +from pydantic import BaseModel, ConfigDict, Field + +JsonPrimitive: TypeAlias = str | int | float | bool | None +JsonNumber: TypeAlias = int | float +AuthType: TypeAlias = Literal["api_key", "subscription"] +ParamType: TypeAlias = Literal["boolean", "enum", "integer", "number", "string"] +ParamGroup: TypeAlias = Literal[ + "generation_length", + "sampling", + "reasoning", + "tooling", + "output_format", + "observability", + "provider_metadata", +] + + +class FrozenModel(BaseModel): + model_config = ConfigDict(frozen=True, extra="forbid", populate_by_name=True) + + +class ParamRange(FrozenModel): + min: JsonNumber | None = None + max: JsonNumber | None = None + step: JsonNumber | None = None + + +class ApplicabilityCondition(FrozenModel): + not_: JsonPrimitive | tuple[JsonPrimitive, ...] = Field(alias="not") + + +ApplicabilityValue: TypeAlias = JsonPrimitive | tuple[JsonPrimitive, ...] | ApplicabilityCondition +ApplicabilityRule: TypeAlias = dict[str, ApplicabilityValue] +ApplicabilityRuleSet: TypeAlias = ApplicabilityRule | tuple[ApplicabilityRule, ...] + + +class Applicability(FrozenModel): + only: ApplicabilityRuleSet | None = None + except_: ApplicabilityRuleSet | None = Field(default=None, alias="except") + + +class Parameter(FrozenModel): + path: str + label: str + description: str + group: ParamGroup + type: ParamType + default: JsonPrimitive = None + range: ParamRange | None = None + values: tuple[JsonPrimitive, ...] | None = None + applicability: Applicability | None = None + + +class CatalogEntry(FrozenModel): + provider: str + auth_type: AuthType = Field(alias="authType") + model: str + params: tuple[Parameter, ...] diff --git a/packages/modelparams-python/src/modelparams/py.typed b/packages/modelparams-python/src/modelparams/py.typed new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/py.typed @@ -0,0 +1 @@ + diff --git a/packages/modelparams-python/src/modelparams/types/__init__.py b/packages/modelparams-python/src/modelparams/types/__init__.py new file mode 100644 index 0000000..017366b --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/__init__.py @@ -0,0 +1,4 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +__all__ = ["alibaba", "anthropic", "cerebras", "cohere", "deepseek", "google", "groq", "meta", "minimax", "mistral", "moonshot", "nvidia", "openai", "perplexity", "xai", "xiaomi", "z_ai"] diff --git a/packages/modelparams-python/src/modelparams/types/alibaba.py b/packages/modelparams-python/src/modelparams/types/alibaba.py new file mode 100644 index 0000000..8a17cfd --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/alibaba.py @@ -0,0 +1,123 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Qwen_FlashParams = TypedDict( + "Qwen_FlashParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "extra_body.top_k": Annotated[int, Field(ge=1)], + "extra_body.chat_template_kwargs.enable_thinking": bool, + }, + total=False, +) +setattr(Qwen_FlashParams, "__pydantic_config__", _PARAMS_CONFIG) + +Qwen_PlusParams = TypedDict( + "Qwen_PlusParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "extra_body.top_k": Annotated[int, Field(ge=1)], + "extra_body.chat_template_kwargs.enable_thinking": bool, + }, + total=False, +) +setattr(Qwen_PlusParams, "__pydantic_config__", _PARAMS_CONFIG) + +Qwen3_Coder_FlashParams = TypedDict( + "Qwen3_Coder_FlashParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "extra_body.top_k": Annotated[int, Field(ge=1)], + }, + total=False, +) +setattr(Qwen3_Coder_FlashParams, "__pydantic_config__", _PARAMS_CONFIG) + +Qwen3_Coder_PlusParams = TypedDict( + "Qwen3_Coder_PlusParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "extra_body.top_k": Annotated[int, Field(ge=1)], + }, + total=False, +) +setattr(Qwen3_Coder_PlusParams, "__pydantic_config__", _PARAMS_CONFIG) + +Qwen3_MaxParams = TypedDict( + "Qwen3_MaxParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "extra_body.top_k": Annotated[int, Field(ge=1)], + "extra_body.chat_template_kwargs.enable_thinking": bool, + }, + total=False, +) +setattr(Qwen3_MaxParams, "__pydantic_config__", _PARAMS_CONFIG) + +Qwen3_5Params = TypedDict( + "Qwen3_5Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "extra_body.top_k": Annotated[int, Field(ge=1)], + "extra_body.chat_template_kwargs.enable_thinking": bool, + }, + total=False, +) +setattr(Qwen3_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +Qwen3_5_FlashParams = TypedDict( + "Qwen3_5_FlashParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "extra_body.top_k": Annotated[int, Field(ge=1)], + "extra_body.chat_template_kwargs.enable_thinking": bool, + }, + total=False, +) +setattr(Qwen3_5_FlashParams, "__pydantic_config__", _PARAMS_CONFIG) + +Qwq_PlusParams = TypedDict( + "Qwq_PlusParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "extra_body.top_k": Annotated[int, Field(ge=1)], + }, + total=False, +) +setattr(Qwq_PlusParams, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Qwen_FlashParams", + "Qwen_PlusParams", + "Qwen3_Coder_FlashParams", + "Qwen3_Coder_PlusParams", + "Qwen3_MaxParams", + "Qwen3_5Params", + "Qwen3_5_FlashParams", + "Qwq_PlusParams", +] diff --git a/packages/modelparams-python/src/modelparams/types/anthropic.py b/packages/modelparams-python/src/modelparams/types/anthropic.py new file mode 100644 index 0000000..19cc179 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/anthropic.py @@ -0,0 +1,594 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Claude_3_5_Haiku_20241022Params = TypedDict( + "Claude_3_5_Haiku_20241022Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + }, + total=False, +) +setattr(Claude_3_5_Haiku_20241022Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_3_5_Haiku_LatestParams = TypedDict( + "Claude_3_5_Haiku_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + }, + total=False, +) +setattr(Claude_3_5_Haiku_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_3_5_Sonnet_20241022Params = TypedDict( + "Claude_3_5_Sonnet_20241022Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + }, + total=False, +) +setattr(Claude_3_5_Sonnet_20241022Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_3_5_Sonnet_LatestParams = TypedDict( + "Claude_3_5_Sonnet_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + }, + total=False, +) +setattr(Claude_3_5_Sonnet_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_3_7_Sonnet_20250219Params = TypedDict( + "Claude_3_7_Sonnet_20250219Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + }, + total=False, +) +setattr(Claude_3_7_Sonnet_20250219Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_3_7_Sonnet_LatestParams = TypedDict( + "Claude_3_7_Sonnet_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + }, + total=False, +) +setattr(Claude_3_7_Sonnet_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_3_Opus_20240229Params = TypedDict( + "Claude_3_Opus_20240229Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + }, + total=False, +) +setattr(Claude_3_Opus_20240229Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_3_Opus_LatestParams = TypedDict( + "Claude_3_Opus_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + }, + total=False, +) +setattr(Claude_3_Opus_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Fable_5Params = TypedDict( + "Claude_Fable_5Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "thinking.type": Literal["adaptive"], + "thinking.display": Literal["summarized", "omitted"], + "output_config.effort": Literal["low", "medium", "high", "xhigh", "max"], + }, + total=False, +) +setattr(Claude_Fable_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Fable_5_SubscriptionParams = TypedDict( + "Claude_Fable_5_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "thinking.type": Literal["adaptive"], + "thinking.display": Literal["summarized", "omitted"], + "output_config.effort": Literal["low", "medium", "high", "xhigh", "max"], + }, + total=False, +) +setattr(Claude_Fable_5_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Haiku_4Params = TypedDict( + "Claude_Haiku_4Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + }, + total=False, +) +setattr(Claude_Haiku_4Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Haiku_4_5Params = TypedDict( + "Claude_Haiku_4_5Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + }, + total=False, +) +setattr(Claude_Haiku_4_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Haiku_4_5_20251001Params = TypedDict( + "Claude_Haiku_4_5_20251001Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + }, + total=False, +) +setattr(Claude_Haiku_4_5_20251001Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Haiku_4_5_20251001_SubscriptionParams = TypedDict( + "Claude_Haiku_4_5_20251001_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + }, + total=False, +) +setattr(Claude_Haiku_4_5_20251001_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Haiku_4_5_SubscriptionParams = TypedDict( + "Claude_Haiku_4_5_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + }, + total=False, +) +setattr(Claude_Haiku_4_5_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Haiku_4_SubscriptionParams = TypedDict( + "Claude_Haiku_4_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + }, + total=False, +) +setattr(Claude_Haiku_4_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Opus_4_1_20250805Params = TypedDict( + "Claude_Opus_4_1_20250805Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + "thinking.display": Literal["summarized", "omitted"], + }, + total=False, +) +setattr(Claude_Opus_4_1_20250805Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Opus_4_1_20250805_SubscriptionParams = TypedDict( + "Claude_Opus_4_1_20250805_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + "thinking.display": Literal["summarized", "omitted"], + }, + total=False, +) +setattr(Claude_Opus_4_1_20250805_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Opus_4_20250514Params = TypedDict( + "Claude_Opus_4_20250514Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + "thinking.display": Literal["summarized", "omitted"], + }, + total=False, +) +setattr(Claude_Opus_4_20250514Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Opus_4_20250514_SubscriptionParams = TypedDict( + "Claude_Opus_4_20250514_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + "thinking.display": Literal["summarized", "omitted"], + }, + total=False, +) +setattr(Claude_Opus_4_20250514_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Opus_4_5_20251101Params = TypedDict( + "Claude_Opus_4_5_20251101Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + "thinking.display": Literal["summarized", "omitted"], + "output_config.effort": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Claude_Opus_4_5_20251101Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Opus_4_5_20251101_SubscriptionParams = TypedDict( + "Claude_Opus_4_5_20251101_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + "thinking.display": Literal["summarized", "omitted"], + "output_config.effort": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Claude_Opus_4_5_20251101_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Opus_4_6Params = TypedDict( + "Claude_Opus_4_6Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "adaptive", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + "thinking.display": Literal["summarized", "omitted"], + "output_config.effort": Literal["low", "medium", "high", "max"], + }, + total=False, +) +setattr(Claude_Opus_4_6Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Opus_4_6_SubscriptionParams = TypedDict( + "Claude_Opus_4_6_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "adaptive", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + "thinking.display": Literal["summarized", "omitted"], + "output_config.effort": Literal["low", "medium", "high", "max"], + }, + total=False, +) +setattr(Claude_Opus_4_6_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Opus_4_7Params = TypedDict( + "Claude_Opus_4_7Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "thinking.type": Literal["disabled", "adaptive"], + "thinking.display": Literal["summarized", "omitted"], + "output_config.effort": Literal["low", "medium", "high", "xhigh", "max"], + }, + total=False, +) +setattr(Claude_Opus_4_7Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Opus_4_7_SubscriptionParams = TypedDict( + "Claude_Opus_4_7_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "thinking.type": Literal["disabled", "adaptive"], + "thinking.display": Literal["summarized", "omitted"], + "output_config.effort": Literal["low", "medium", "high", "xhigh", "max"], + }, + total=False, +) +setattr(Claude_Opus_4_7_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Opus_4_8Params = TypedDict( + "Claude_Opus_4_8Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "thinking.type": Literal["disabled", "adaptive"], + "thinking.display": Literal["summarized", "omitted"], + "output_config.effort": Literal["low", "medium", "high", "xhigh", "max"], + }, + total=False, +) +setattr(Claude_Opus_4_8Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Opus_4_8_SubscriptionParams = TypedDict( + "Claude_Opus_4_8_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "thinking.type": Literal["disabled", "adaptive"], + "thinking.display": Literal["summarized", "omitted"], + "output_config.effort": Literal["low", "medium", "high", "xhigh", "max"], + }, + total=False, +) +setattr(Claude_Opus_4_8_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Opus_4_SubscriptionParams = TypedDict( + "Claude_Opus_4_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "adaptive", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + }, + total=False, +) +setattr(Claude_Opus_4_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Sonnet_4_20250514Params = TypedDict( + "Claude_Sonnet_4_20250514Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + "thinking.display": Literal["summarized", "omitted"], + }, + total=False, +) +setattr(Claude_Sonnet_4_20250514Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Sonnet_4_20250514_SubscriptionParams = TypedDict( + "Claude_Sonnet_4_20250514_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + "thinking.display": Literal["summarized", "omitted"], + }, + total=False, +) +setattr(Claude_Sonnet_4_20250514_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Sonnet_4_5Params = TypedDict( + "Claude_Sonnet_4_5Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "adaptive", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + }, + total=False, +) +setattr(Claude_Sonnet_4_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Sonnet_4_5_20250929Params = TypedDict( + "Claude_Sonnet_4_5_20250929Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + }, + total=False, +) +setattr(Claude_Sonnet_4_5_20250929Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Sonnet_4_5_20250929_SubscriptionParams = TypedDict( + "Claude_Sonnet_4_5_20250929_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + }, + total=False, +) +setattr(Claude_Sonnet_4_5_20250929_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Sonnet_4_5_SubscriptionParams = TypedDict( + "Claude_Sonnet_4_5_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "adaptive", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + }, + total=False, +) +setattr(Claude_Sonnet_4_5_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Sonnet_4_6Params = TypedDict( + "Claude_Sonnet_4_6Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "adaptive", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + "thinking.display": Literal["summarized", "omitted"], + "output_config.effort": Literal["low", "medium", "high", "max"], + }, + total=False, +) +setattr(Claude_Sonnet_4_6Params, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Sonnet_4_6_SubscriptionParams = TypedDict( + "Claude_Sonnet_4_6_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "adaptive", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + "thinking.display": Literal["summarized", "omitted"], + "output_config.effort": Literal["low", "medium", "high", "max"], + }, + total=False, +) +setattr(Claude_Sonnet_4_6_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Sonnet_4_SubscriptionParams = TypedDict( + "Claude_Sonnet_4_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "adaptive", "enabled"], + "thinking.budget_tokens": Annotated[int, Field(ge=1024)], + }, + total=False, +) +setattr(Claude_Sonnet_4_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Claude_Sonnet_5Params = TypedDict( + "Claude_Sonnet_5Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "top_k": Annotated[int, Field(ge=0)], + "thinking.type": Literal["disabled", "adaptive"], + "thinking.display": Literal["summarized", "omitted"], + "output_config.effort": Literal["low", "medium", "high", "max"], + }, + total=False, +) +setattr(Claude_Sonnet_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Claude_3_5_Haiku_20241022Params", + "Claude_3_5_Haiku_LatestParams", + "Claude_3_5_Sonnet_20241022Params", + "Claude_3_5_Sonnet_LatestParams", + "Claude_3_7_Sonnet_20250219Params", + "Claude_3_7_Sonnet_LatestParams", + "Claude_3_Opus_20240229Params", + "Claude_3_Opus_LatestParams", + "Claude_Fable_5Params", + "Claude_Fable_5_SubscriptionParams", + "Claude_Haiku_4Params", + "Claude_Haiku_4_5Params", + "Claude_Haiku_4_5_20251001Params", + "Claude_Haiku_4_5_20251001_SubscriptionParams", + "Claude_Haiku_4_5_SubscriptionParams", + "Claude_Haiku_4_SubscriptionParams", + "Claude_Opus_4_1_20250805Params", + "Claude_Opus_4_1_20250805_SubscriptionParams", + "Claude_Opus_4_20250514Params", + "Claude_Opus_4_20250514_SubscriptionParams", + "Claude_Opus_4_5_20251101Params", + "Claude_Opus_4_5_20251101_SubscriptionParams", + "Claude_Opus_4_6Params", + "Claude_Opus_4_6_SubscriptionParams", + "Claude_Opus_4_7Params", + "Claude_Opus_4_7_SubscriptionParams", + "Claude_Opus_4_8Params", + "Claude_Opus_4_8_SubscriptionParams", + "Claude_Opus_4_SubscriptionParams", + "Claude_Sonnet_4_20250514Params", + "Claude_Sonnet_4_20250514_SubscriptionParams", + "Claude_Sonnet_4_5Params", + "Claude_Sonnet_4_5_20250929Params", + "Claude_Sonnet_4_5_20250929_SubscriptionParams", + "Claude_Sonnet_4_5_SubscriptionParams", + "Claude_Sonnet_4_6Params", + "Claude_Sonnet_4_6_SubscriptionParams", + "Claude_Sonnet_4_SubscriptionParams", + "Claude_Sonnet_5Params", +] diff --git a/packages/modelparams-python/src/modelparams/types/cerebras.py b/packages/modelparams-python/src/modelparams/types/cerebras.py new file mode 100644 index 0000000..8b0d4eb --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/cerebras.py @@ -0,0 +1,33 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Zai_Glm_4_7Params = TypedDict( + "Zai_Glm_4_7Params", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "seed": int, + "stop": str, + "reasoning_effort": Literal["none", "low", "medium", "high"], + "clear_thinking": bool, + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Zai_Glm_4_7Params, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Zai_Glm_4_7Params", +] diff --git a/packages/modelparams-python/src/modelparams/types/cohere.py b/packages/modelparams-python/src/modelparams/types/cohere.py new file mode 100644 index 0000000..a731045 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/cohere.py @@ -0,0 +1,182 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Command_A_03_2025Params = TypedDict( + "Command_A_03_2025Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop_sequences": str, + "temperature": Annotated[float, Field(ge=0)], + "p": Annotated[float, Field(ge=0.01, le=0.99)], + "k": Annotated[int, Field(ge=0, le=500)], + "frequency_penalty": Annotated[float, Field(ge=0, le=1)], + "presence_penalty": Annotated[float, Field(ge=0, le=1)], + "seed": int, + "response_format.type": Literal["text", "json_object"], + "logprobs": bool, + "tool_choice": Literal["REQUIRED", "NONE"], + "safety_mode": Literal["CONTEXTUAL", "STRICT"], + }, + total=False, +) +setattr(Command_A_03_2025Params, "__pydantic_config__", _PARAMS_CONFIG) + +Command_A_Plus_05_2026Params = TypedDict( + "Command_A_Plus_05_2026Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop_sequences": str, + "temperature": Annotated[float, Field(ge=0)], + "p": Annotated[float, Field(ge=0.01, le=0.99)], + "k": Annotated[int, Field(ge=0, le=500)], + "frequency_penalty": Annotated[float, Field(ge=0, le=1)], + "presence_penalty": Annotated[float, Field(ge=0, le=1)], + "seed": int, + "response_format.type": Literal["text", "json_object"], + "logprobs": bool, + "tool_choice": Literal["REQUIRED", "NONE"], + "safety_mode": Literal["CONTEXTUAL", "STRICT"], + }, + total=False, +) +setattr(Command_A_Plus_05_2026Params, "__pydantic_config__", _PARAMS_CONFIG) + +Command_A_Reasoning_08_2025Params = TypedDict( + "Command_A_Reasoning_08_2025Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop_sequences": str, + "temperature": Annotated[float, Field(ge=0)], + "p": Annotated[float, Field(ge=0.01, le=0.99)], + "k": Annotated[int, Field(ge=0, le=500)], + "frequency_penalty": Annotated[float, Field(ge=0, le=1)], + "presence_penalty": Annotated[float, Field(ge=0, le=1)], + "seed": int, + "thinking.type": Literal["enabled", "disabled"], + "thinking.token_budget": Annotated[int, Field(ge=1)], + "response_format.type": Literal["text", "json_object"], + "logprobs": bool, + "tool_choice": Literal["REQUIRED", "NONE"], + "safety_mode": Literal["CONTEXTUAL", "STRICT"], + }, + total=False, +) +setattr(Command_A_Reasoning_08_2025Params, "__pydantic_config__", _PARAMS_CONFIG) + +Command_A_Translate_08_2025Params = TypedDict( + "Command_A_Translate_08_2025Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop_sequences": str, + "temperature": Annotated[float, Field(ge=0)], + "p": Annotated[float, Field(ge=0.01, le=0.99)], + "k": Annotated[int, Field(ge=0, le=500)], + "frequency_penalty": Annotated[float, Field(ge=0, le=1)], + "presence_penalty": Annotated[float, Field(ge=0, le=1)], + "seed": int, + "response_format.type": Literal["text", "json_object"], + "logprobs": bool, + "tool_choice": Literal["REQUIRED", "NONE"], + "safety_mode": Literal["CONTEXTUAL", "STRICT"], + }, + total=False, +) +setattr(Command_A_Translate_08_2025Params, "__pydantic_config__", _PARAMS_CONFIG) + +Command_A_Vision_07_2025Params = TypedDict( + "Command_A_Vision_07_2025Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop_sequences": str, + "temperature": Annotated[float, Field(ge=0)], + "p": Annotated[float, Field(ge=0.01, le=0.99)], + "k": Annotated[int, Field(ge=0, le=500)], + "frequency_penalty": Annotated[float, Field(ge=0, le=1)], + "presence_penalty": Annotated[float, Field(ge=0, le=1)], + "seed": int, + "response_format.type": Literal["text", "json_object"], + "logprobs": bool, + "tool_choice": Literal["REQUIRED", "NONE"], + "safety_mode": Literal["CONTEXTUAL", "STRICT"], + }, + total=False, +) +setattr(Command_A_Vision_07_2025Params, "__pydantic_config__", _PARAMS_CONFIG) + +Command_R_08_2024Params = TypedDict( + "Command_R_08_2024Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop_sequences": str, + "temperature": Annotated[float, Field(ge=0)], + "p": Annotated[float, Field(ge=0.01, le=0.99)], + "k": Annotated[int, Field(ge=0, le=500)], + "frequency_penalty": Annotated[float, Field(ge=0, le=1)], + "presence_penalty": Annotated[float, Field(ge=0, le=1)], + "seed": int, + "response_format.type": Literal["text", "json_object"], + "logprobs": bool, + "safety_mode": Literal["CONTEXTUAL", "STRICT", "OFF"], + }, + total=False, +) +setattr(Command_R_08_2024Params, "__pydantic_config__", _PARAMS_CONFIG) + +Command_R_Plus_08_2024Params = TypedDict( + "Command_R_Plus_08_2024Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop_sequences": str, + "temperature": Annotated[float, Field(ge=0)], + "p": Annotated[float, Field(ge=0.01, le=0.99)], + "k": Annotated[int, Field(ge=0, le=500)], + "frequency_penalty": Annotated[float, Field(ge=0, le=1)], + "presence_penalty": Annotated[float, Field(ge=0, le=1)], + "seed": int, + "response_format.type": Literal["text", "json_object"], + "logprobs": bool, + "safety_mode": Literal["CONTEXTUAL", "STRICT", "OFF"], + }, + total=False, +) +setattr(Command_R_Plus_08_2024Params, "__pydantic_config__", _PARAMS_CONFIG) + +Command_R7b_12_2024Params = TypedDict( + "Command_R7b_12_2024Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop_sequences": str, + "temperature": Annotated[float, Field(ge=0)], + "p": Annotated[float, Field(ge=0.01, le=0.99)], + "k": Annotated[int, Field(ge=0, le=500)], + "frequency_penalty": Annotated[float, Field(ge=0, le=1)], + "presence_penalty": Annotated[float, Field(ge=0, le=1)], + "seed": int, + "response_format.type": Literal["text", "json_object"], + "logprobs": bool, + "tool_choice": Literal["REQUIRED", "NONE"], + "safety_mode": Literal["CONTEXTUAL", "STRICT"], + }, + total=False, +) +setattr(Command_R7b_12_2024Params, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Command_A_03_2025Params", + "Command_A_Plus_05_2026Params", + "Command_A_Reasoning_08_2025Params", + "Command_A_Translate_08_2025Params", + "Command_A_Vision_07_2025Params", + "Command_R_08_2024Params", + "Command_R_Plus_08_2024Params", + "Command_R7b_12_2024Params", +] diff --git a/packages/modelparams-python/src/modelparams/types/deepseek.py b/packages/modelparams-python/src/modelparams/types/deepseek.py new file mode 100644 index 0000000..6c578ee --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/deepseek.py @@ -0,0 +1,69 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Deepseek_ChatParams = TypedDict( + "Deepseek_ChatParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "thinking.type": Literal["disabled", "enabled"], + }, + total=False, +) +setattr(Deepseek_ChatParams, "__pydantic_config__", _PARAMS_CONFIG) + +Deepseek_ReasonerParams = TypedDict( + "Deepseek_ReasonerParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "thinking.type": Literal["enabled", "disabled"], + "reasoning_effort": Literal["high", "max"], + }, + total=False, +) +setattr(Deepseek_ReasonerParams, "__pydantic_config__", _PARAMS_CONFIG) + +Deepseek_V4_FlashParams = TypedDict( + "Deepseek_V4_FlashParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "thinking.type": Literal["enabled", "disabled"], + "reasoning_effort": Literal["high", "max"], + }, + total=False, +) +setattr(Deepseek_V4_FlashParams, "__pydantic_config__", _PARAMS_CONFIG) + +Deepseek_V4_ProParams = TypedDict( + "Deepseek_V4_ProParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "thinking.type": Literal["enabled", "disabled"], + "reasoning_effort": Literal["high", "max"], + }, + total=False, +) +setattr(Deepseek_V4_ProParams, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Deepseek_ChatParams", + "Deepseek_ReasonerParams", + "Deepseek_V4_FlashParams", + "Deepseek_V4_ProParams", +] diff --git a/packages/modelparams-python/src/modelparams/types/google.py b/packages/modelparams-python/src/modelparams/types/google.py new file mode 100644 index 0000000..27f458b --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/google.py @@ -0,0 +1,233 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Gemini_2_5_FlashParams = TypedDict( + "Gemini_2_5_FlashParams", + { + "generationConfig.maxOutputTokens": Annotated[int, Field(ge=1, le=65536)], + "generationConfig.temperature": Annotated[float, Field(ge=0, le=2)], + "generationConfig.topP": Annotated[float, Field(ge=0, le=1)], + "generationConfig.topK": Annotated[int, Field(ge=0)], + "generationConfig.seed": int, + "generationConfig.thinkingConfig.thinkingBudget": Annotated[int, Field(ge=-1, le=24576)], + "generationConfig.thinkingConfig.includeThoughts": bool, + "generationConfig.responseMimeType": Literal["text/plain", "application/json"], + }, + total=False, +) +setattr(Gemini_2_5_FlashParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gemini_2_5_Flash_LiteParams = TypedDict( + "Gemini_2_5_Flash_LiteParams", + { + "generationConfig.maxOutputTokens": Annotated[int, Field(ge=1, le=65536)], + "generationConfig.temperature": Annotated[float, Field(ge=0, le=2)], + "generationConfig.topP": Annotated[float, Field(ge=0, le=1)], + "generationConfig.topK": Annotated[int, Field(ge=0)], + "generationConfig.seed": int, + "generationConfig.thinkingConfig.thinkingBudget": int, + "generationConfig.thinkingConfig.includeThoughts": bool, + "generationConfig.responseMimeType": Literal["text/plain", "application/json"], + }, + total=False, +) +setattr(Gemini_2_5_Flash_LiteParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gemini_2_5_Flash_Lite_SubscriptionParams = TypedDict( + "Gemini_2_5_Flash_Lite_SubscriptionParams", + { + "generationConfig.maxOutputTokens": Annotated[int, Field(ge=1, le=65536)], + "generationConfig.temperature": Annotated[float, Field(ge=0, le=2)], + "generationConfig.topP": Annotated[float, Field(ge=0, le=1)], + "generationConfig.topK": Annotated[int, Field(ge=0)], + "generationConfig.seed": int, + "generationConfig.thinkingConfig.thinkingBudget": int, + "generationConfig.thinkingConfig.includeThoughts": bool, + "generationConfig.responseMimeType": Literal["text/plain", "application/json"], + }, + total=False, +) +setattr(Gemini_2_5_Flash_Lite_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gemini_2_5_Flash_SubscriptionParams = TypedDict( + "Gemini_2_5_Flash_SubscriptionParams", + { + "generationConfig.maxOutputTokens": Annotated[int, Field(ge=1, le=65536)], + "generationConfig.temperature": Annotated[float, Field(ge=0, le=2)], + "generationConfig.topP": Annotated[float, Field(ge=0, le=1)], + "generationConfig.topK": Annotated[int, Field(ge=0)], + "generationConfig.seed": int, + "generationConfig.thinkingConfig.thinkingBudget": Annotated[int, Field(ge=-1, le=24576)], + "generationConfig.thinkingConfig.includeThoughts": bool, + "generationConfig.responseMimeType": Literal["text/plain", "application/json"], + }, + total=False, +) +setattr(Gemini_2_5_Flash_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gemini_2_5_ProParams = TypedDict( + "Gemini_2_5_ProParams", + { + "generationConfig.maxOutputTokens": Annotated[int, Field(ge=1, le=65536)], + "generationConfig.temperature": Annotated[float, Field(ge=0, le=2)], + "generationConfig.topP": Annotated[float, Field(ge=0, le=1)], + "generationConfig.topK": Annotated[int, Field(ge=0)], + "generationConfig.seed": int, + "generationConfig.thinkingConfig.thinkingBudget": Annotated[int, Field(ge=128, le=32768)], + "generationConfig.thinkingConfig.includeThoughts": bool, + "generationConfig.responseMimeType": Literal["text/plain", "application/json"], + }, + total=False, +) +setattr(Gemini_2_5_ProParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gemini_2_5_Pro_SubscriptionParams = TypedDict( + "Gemini_2_5_Pro_SubscriptionParams", + { + "generationConfig.maxOutputTokens": Annotated[int, Field(ge=1, le=65536)], + "generationConfig.temperature": Annotated[float, Field(ge=0, le=2)], + "generationConfig.topP": Annotated[float, Field(ge=0, le=1)], + "generationConfig.topK": Annotated[int, Field(ge=0)], + "generationConfig.seed": int, + "generationConfig.thinkingConfig.thinkingBudget": Annotated[int, Field(ge=128, le=32768)], + "generationConfig.thinkingConfig.includeThoughts": bool, + "generationConfig.responseMimeType": Literal["text/plain", "application/json"], + }, + total=False, +) +setattr(Gemini_2_5_Pro_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gemini_3_Flash_Preview_SubscriptionParams = TypedDict( + "Gemini_3_Flash_Preview_SubscriptionParams", + { + "generationConfig.maxOutputTokens": Annotated[int, Field(ge=1, le=65536)], + "generationConfig.temperature": Annotated[float, Field(ge=0, le=2)], + "generationConfig.topP": Annotated[float, Field(ge=0, le=1)], + "generationConfig.topK": Annotated[int, Field(ge=0)], + "generationConfig.seed": int, + "generationConfig.thinkingConfig.thinkingLevel": Literal["minimal", "low", "medium", "high"], + "generationConfig.thinkingConfig.includeThoughts": bool, + "generationConfig.responseMimeType": Literal["text/plain", "application/json"], + }, + total=False, +) +setattr(Gemini_3_Flash_Preview_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gemini_3_1_Flash_Lite_Preview_SubscriptionParams = TypedDict( + "Gemini_3_1_Flash_Lite_Preview_SubscriptionParams", + { + "generationConfig.maxOutputTokens": Annotated[int, Field(ge=1, le=65536)], + "generationConfig.temperature": Annotated[float, Field(ge=0, le=2)], + "generationConfig.topP": Annotated[float, Field(ge=0, le=1)], + "generationConfig.topK": Annotated[int, Field(ge=0)], + "generationConfig.seed": int, + "generationConfig.thinkingConfig.thinkingLevel": Literal["minimal", "low", "medium", "high"], + "generationConfig.thinkingConfig.includeThoughts": bool, + "generationConfig.responseMimeType": Literal["text/plain", "application/json"], + }, + total=False, +) +setattr(Gemini_3_1_Flash_Lite_Preview_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gemini_3_1_Flash_Lite_SubscriptionParams = TypedDict( + "Gemini_3_1_Flash_Lite_SubscriptionParams", + { + "generationConfig.maxOutputTokens": Annotated[int, Field(ge=1, le=65536)], + "generationConfig.temperature": Annotated[float, Field(ge=0, le=2)], + "generationConfig.topP": Annotated[float, Field(ge=0, le=1)], + "generationConfig.topK": Annotated[int, Field(ge=0)], + "generationConfig.seed": int, + "generationConfig.thinkingConfig.thinkingLevel": Literal["minimal", "low", "medium", "high"], + "generationConfig.thinkingConfig.includeThoughts": bool, + "generationConfig.responseMimeType": Literal["text/plain", "application/json"], + }, + total=False, +) +setattr(Gemini_3_1_Flash_Lite_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gemini_3_1_Pro_Preview_SubscriptionParams = TypedDict( + "Gemini_3_1_Pro_Preview_SubscriptionParams", + { + "generationConfig.maxOutputTokens": Annotated[int, Field(ge=1, le=65536)], + "generationConfig.temperature": Annotated[float, Field(ge=0, le=2)], + "generationConfig.topP": Annotated[float, Field(ge=0, le=1)], + "generationConfig.topK": Annotated[int, Field(ge=0)], + "generationConfig.seed": int, + "generationConfig.thinkingConfig.thinkingLevel": Literal["low", "high"], + "generationConfig.thinkingConfig.includeThoughts": bool, + "generationConfig.responseMimeType": Literal["text/plain", "application/json"], + }, + total=False, +) +setattr(Gemini_3_1_Pro_Preview_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gemini_3_5_FlashParams = TypedDict( + "Gemini_3_5_FlashParams", + { + "generationConfig.maxOutputTokens": Annotated[int, Field(ge=1, le=65536)], + "generationConfig.temperature": Annotated[float, Field(ge=0, le=2)], + "generationConfig.topP": Annotated[float, Field(ge=0, le=1)], + "generationConfig.topK": Annotated[int, Field(ge=0)], + "generationConfig.seed": int, + "generationConfig.thinkingConfig.thinkingLevel": Literal["minimal", "low", "medium", "high"], + "generationConfig.thinkingConfig.includeThoughts": bool, + "generationConfig.responseMimeType": Literal["text/plain", "application/json"], + }, + total=False, +) +setattr(Gemini_3_5_FlashParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gemma_4_26b_A4b_ItParams = TypedDict( + "Gemma_4_26b_A4b_ItParams", + { + "generationConfig.maxOutputTokens": Annotated[int, Field(ge=1)], + "generationConfig.temperature": Annotated[float, Field(ge=0, le=2)], + "generationConfig.topP": Annotated[float, Field(ge=0, le=1)], + "generationConfig.topK": Annotated[int, Field(ge=0)], + "generationConfig.seed": int, + "generationConfig.thinkingConfig.thinkingLevel": Literal["minimal", "high"], + "generationConfig.responseMimeType": Literal["text/plain", "application/json"], + }, + total=False, +) +setattr(Gemma_4_26b_A4b_ItParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gemma_4_31b_ItParams = TypedDict( + "Gemma_4_31b_ItParams", + { + "generationConfig.maxOutputTokens": Annotated[int, Field(ge=1)], + "generationConfig.temperature": Annotated[float, Field(ge=0, le=2)], + "generationConfig.topP": Annotated[float, Field(ge=0, le=1)], + "generationConfig.topK": Annotated[int, Field(ge=0)], + "generationConfig.seed": int, + "generationConfig.thinkingConfig.thinkingLevel": Literal["minimal", "high"], + "generationConfig.responseMimeType": Literal["text/plain", "application/json"], + }, + total=False, +) +setattr(Gemma_4_31b_ItParams, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Gemini_2_5_FlashParams", + "Gemini_2_5_Flash_LiteParams", + "Gemini_2_5_Flash_Lite_SubscriptionParams", + "Gemini_2_5_Flash_SubscriptionParams", + "Gemini_2_5_ProParams", + "Gemini_2_5_Pro_SubscriptionParams", + "Gemini_3_Flash_Preview_SubscriptionParams", + "Gemini_3_1_Flash_Lite_Preview_SubscriptionParams", + "Gemini_3_1_Flash_Lite_SubscriptionParams", + "Gemini_3_1_Pro_Preview_SubscriptionParams", + "Gemini_3_5_FlashParams", + "Gemma_4_26b_A4b_ItParams", + "Gemma_4_31b_ItParams", +] diff --git a/packages/modelparams-python/src/modelparams/types/groq.py b/packages/modelparams-python/src/modelparams/types/groq.py new file mode 100644 index 0000000..9702968 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/groq.py @@ -0,0 +1,33 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Qwen3_32bParams = TypedDict( + "Qwen3_32bParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "seed": int, + "stop": str, + "reasoning_effort": Literal["none", "default"], + "reasoning_format": Literal["hidden", "raw", "parsed"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Qwen3_32bParams, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Qwen3_32bParams", +] diff --git a/packages/modelparams-python/src/modelparams/types/meta.py b/packages/modelparams-python/src/modelparams/types/meta.py new file mode 100644 index 0000000..577d28f --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/meta.py @@ -0,0 +1,78 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Llama_3_3_70b_InstructParams = TypedDict( + "Llama_3_3_70b_InstructParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": float, + "top_p": float, + "top_k": int, + "repetition_penalty": float, + "response_format.type": Literal["text", "json_schema"], + "tool_choice": Literal["auto", "none", "required"], + }, + total=False, +) +setattr(Llama_3_3_70b_InstructParams, "__pydantic_config__", _PARAMS_CONFIG) + +Llama_3_3_8b_InstructParams = TypedDict( + "Llama_3_3_8b_InstructParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": float, + "top_p": float, + "top_k": int, + "repetition_penalty": float, + "response_format.type": Literal["text", "json_schema"], + "tool_choice": Literal["auto", "none", "required"], + }, + total=False, +) +setattr(Llama_3_3_8b_InstructParams, "__pydantic_config__", _PARAMS_CONFIG) + +Llama_4_Maverick_17b_128e_Instruct_Fp8Params = TypedDict( + "Llama_4_Maverick_17b_128e_Instruct_Fp8Params", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": float, + "top_p": float, + "top_k": int, + "repetition_penalty": float, + "response_format.type": Literal["text", "json_schema"], + "tool_choice": Literal["auto", "none", "required"], + }, + total=False, +) +setattr(Llama_4_Maverick_17b_128e_Instruct_Fp8Params, "__pydantic_config__", _PARAMS_CONFIG) + +Llama_4_Scout_17b_16e_Instruct_Fp8Params = TypedDict( + "Llama_4_Scout_17b_16e_Instruct_Fp8Params", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": float, + "top_p": float, + "top_k": int, + "repetition_penalty": float, + "response_format.type": Literal["text", "json_schema"], + "tool_choice": Literal["auto", "none", "required"], + }, + total=False, +) +setattr(Llama_4_Scout_17b_16e_Instruct_Fp8Params, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Llama_3_3_70b_InstructParams", + "Llama_3_3_8b_InstructParams", + "Llama_4_Maverick_17b_128e_Instruct_Fp8Params", + "Llama_4_Scout_17b_16e_Instruct_Fp8Params", +] diff --git a/packages/modelparams-python/src/modelparams/types/minimax.py b/packages/modelparams-python/src/modelparams/types/minimax.py new file mode 100644 index 0000000..fe2f6d1 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/minimax.py @@ -0,0 +1,214 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Minimax_M2Params = TypedDict( + "Minimax_M2Params", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "reasoning_split": bool, + }, + total=False, +) +setattr(Minimax_M2Params, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M2_SubscriptionParams = TypedDict( + "Minimax_M2_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + }, + total=False, +) +setattr(Minimax_M2_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M2_1Params = TypedDict( + "Minimax_M2_1Params", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "reasoning_split": bool, + }, + total=False, +) +setattr(Minimax_M2_1Params, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M2_1_HighspeedParams = TypedDict( + "Minimax_M2_1_HighspeedParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "reasoning_split": bool, + }, + total=False, +) +setattr(Minimax_M2_1_HighspeedParams, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M2_1_Highspeed_SubscriptionParams = TypedDict( + "Minimax_M2_1_Highspeed_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + }, + total=False, +) +setattr(Minimax_M2_1_Highspeed_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M2_1_SubscriptionParams = TypedDict( + "Minimax_M2_1_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + }, + total=False, +) +setattr(Minimax_M2_1_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M2_5Params = TypedDict( + "Minimax_M2_5Params", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "reasoning_split": bool, + }, + total=False, +) +setattr(Minimax_M2_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M2_5_HighspeedParams = TypedDict( + "Minimax_M2_5_HighspeedParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "reasoning_split": bool, + }, + total=False, +) +setattr(Minimax_M2_5_HighspeedParams, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M2_5_Highspeed_SubscriptionParams = TypedDict( + "Minimax_M2_5_Highspeed_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + }, + total=False, +) +setattr(Minimax_M2_5_Highspeed_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M2_5_SubscriptionParams = TypedDict( + "Minimax_M2_5_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + }, + total=False, +) +setattr(Minimax_M2_5_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M2_7Params = TypedDict( + "Minimax_M2_7Params", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "reasoning_split": bool, + }, + total=False, +) +setattr(Minimax_M2_7Params, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M2_7_HighspeedParams = TypedDict( + "Minimax_M2_7_HighspeedParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "reasoning_split": bool, + }, + total=False, +) +setattr(Minimax_M2_7_HighspeedParams, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M2_7_Highspeed_SubscriptionParams = TypedDict( + "Minimax_M2_7_Highspeed_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + }, + total=False, +) +setattr(Minimax_M2_7_Highspeed_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M2_7_SubscriptionParams = TypedDict( + "Minimax_M2_7_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + }, + total=False, +) +setattr(Minimax_M2_7_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M3Params = TypedDict( + "Minimax_M3Params", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "reasoning_split": bool, + }, + total=False, +) +setattr(Minimax_M3Params, "__pydantic_config__", _PARAMS_CONFIG) + +Minimax_M3_SubscriptionParams = TypedDict( + "Minimax_M3_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0.01, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + }, + total=False, +) +setattr(Minimax_M3_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Minimax_M2Params", + "Minimax_M2_SubscriptionParams", + "Minimax_M2_1Params", + "Minimax_M2_1_HighspeedParams", + "Minimax_M2_1_Highspeed_SubscriptionParams", + "Minimax_M2_1_SubscriptionParams", + "Minimax_M2_5Params", + "Minimax_M2_5_HighspeedParams", + "Minimax_M2_5_Highspeed_SubscriptionParams", + "Minimax_M2_5_SubscriptionParams", + "Minimax_M2_7Params", + "Minimax_M2_7_HighspeedParams", + "Minimax_M2_7_Highspeed_SubscriptionParams", + "Minimax_M2_7_SubscriptionParams", + "Minimax_M3Params", + "Minimax_M3_SubscriptionParams", +] diff --git a/packages/modelparams-python/src/modelparams/types/mistral.py b/packages/modelparams-python/src/modelparams/types/mistral.py new file mode 100644 index 0000000..4b8b1e9 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/mistral.py @@ -0,0 +1,250 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Codestral_LatestParams = TypedDict( + "Codestral_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop": str, + "temperature": Annotated[float, Field(ge=0, le=1.5)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "random_seed": Annotated[int, Field(ge=0)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "response_format.type": Literal["text", "json_object"], + "safe_prompt": bool, + }, + total=False, +) +setattr(Codestral_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Devstral_2512Params = TypedDict( + "Devstral_2512Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop": str, + "temperature": Annotated[float, Field(ge=0, le=1.5)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "random_seed": Annotated[int, Field(ge=0)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "response_format.type": Literal["text", "json_object"], + "safe_prompt": bool, + }, + total=False, +) +setattr(Devstral_2512Params, "__pydantic_config__", _PARAMS_CONFIG) + +Devstral_LatestParams = TypedDict( + "Devstral_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop": str, + "temperature": Annotated[float, Field(ge=0, le=1.5)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "random_seed": Annotated[int, Field(ge=0)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "response_format.type": Literal["text", "json_object"], + "safe_prompt": bool, + }, + total=False, +) +setattr(Devstral_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Magistral_Medium_LatestParams = TypedDict( + "Magistral_Medium_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop": str, + "temperature": Annotated[float, Field(ge=0, le=1.5)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "random_seed": Annotated[int, Field(ge=0)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "prompt_mode": Literal["reasoning"], + "response_format.type": Literal["text", "json_object"], + "safe_prompt": bool, + }, + total=False, +) +setattr(Magistral_Medium_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Magistral_Small_LatestParams = TypedDict( + "Magistral_Small_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop": str, + "temperature": Annotated[float, Field(ge=0, le=1.5)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "random_seed": Annotated[int, Field(ge=0)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "prompt_mode": Literal["reasoning"], + "response_format.type": Literal["text", "json_object"], + "safe_prompt": bool, + }, + total=False, +) +setattr(Magistral_Small_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Ministral_14b_LatestParams = TypedDict( + "Ministral_14b_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop": str, + "temperature": Annotated[float, Field(ge=0, le=1.5)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "random_seed": Annotated[int, Field(ge=0)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "response_format.type": Literal["text", "json_object"], + "safe_prompt": bool, + }, + total=False, +) +setattr(Ministral_14b_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Ministral_3b_LatestParams = TypedDict( + "Ministral_3b_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop": str, + "temperature": Annotated[float, Field(ge=0, le=1.5)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "random_seed": Annotated[int, Field(ge=0)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "response_format.type": Literal["text", "json_object"], + "safe_prompt": bool, + }, + total=False, +) +setattr(Ministral_3b_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Ministral_8b_LatestParams = TypedDict( + "Ministral_8b_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop": str, + "temperature": Annotated[float, Field(ge=0, le=1.5)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "random_seed": Annotated[int, Field(ge=0)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "response_format.type": Literal["text", "json_object"], + "safe_prompt": bool, + }, + total=False, +) +setattr(Ministral_8b_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Mistral_Large_LatestParams = TypedDict( + "Mistral_Large_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop": str, + "temperature": Annotated[float, Field(ge=0, le=1.5)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "random_seed": Annotated[int, Field(ge=0)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "response_format.type": Literal["text", "json_object"], + "safe_prompt": bool, + }, + total=False, +) +setattr(Mistral_Large_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Mistral_Medium_3_5Params = TypedDict( + "Mistral_Medium_3_5Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop": str, + "temperature": Annotated[float, Field(ge=0, le=1.5)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "random_seed": Annotated[int, Field(ge=0)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "response_format.type": Literal["text", "json_object"], + "safe_prompt": bool, + }, + total=False, +) +setattr(Mistral_Medium_3_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +Mistral_Medium_LatestParams = TypedDict( + "Mistral_Medium_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop": str, + "temperature": Annotated[float, Field(ge=0, le=1.5)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "random_seed": Annotated[int, Field(ge=0)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "response_format.type": Literal["text", "json_object"], + "safe_prompt": bool, + }, + total=False, +) +setattr(Mistral_Medium_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Mistral_Small_LatestParams = TypedDict( + "Mistral_Small_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop": str, + "temperature": Annotated[float, Field(ge=0, le=1.5)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "random_seed": Annotated[int, Field(ge=0)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "response_format.type": Literal["text", "json_object"], + "safe_prompt": bool, + }, + total=False, +) +setattr(Mistral_Small_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Open_Mistral_NemoParams = TypedDict( + "Open_Mistral_NemoParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "stop": str, + "temperature": Annotated[float, Field(ge=0, le=1.5)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "random_seed": Annotated[int, Field(ge=0)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "response_format.type": Literal["text", "json_object"], + "safe_prompt": bool, + }, + total=False, +) +setattr(Open_Mistral_NemoParams, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Codestral_LatestParams", + "Devstral_2512Params", + "Devstral_LatestParams", + "Magistral_Medium_LatestParams", + "Magistral_Small_LatestParams", + "Ministral_14b_LatestParams", + "Ministral_3b_LatestParams", + "Ministral_8b_LatestParams", + "Mistral_Large_LatestParams", + "Mistral_Medium_3_5Params", + "Mistral_Medium_LatestParams", + "Mistral_Small_LatestParams", + "Open_Mistral_NemoParams", +] diff --git a/packages/modelparams-python/src/modelparams/types/moonshot.py b/packages/modelparams-python/src/modelparams/types/moonshot.py new file mode 100644 index 0000000..3058e57 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/moonshot.py @@ -0,0 +1,120 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Kimi_K2_5Params = TypedDict( + "Kimi_K2_5Params", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Kimi_K2_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +Kimi_K2_6Params = TypedDict( + "Kimi_K2_6Params", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Kimi_K2_6Params, "__pydantic_config__", _PARAMS_CONFIG) + +Kimi_K2_6_SubscriptionParams = TypedDict( + "Kimi_K2_6_SubscriptionParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Kimi_K2_6_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Kimi_K2_7_Code_Highspeed_SubscriptionParams = TypedDict( + "Kimi_K2_7_Code_Highspeed_SubscriptionParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Kimi_K2_7_Code_Highspeed_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Kimi_K2_7_Code_SubscriptionParams = TypedDict( + "Kimi_K2_7_Code_SubscriptionParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Kimi_K2_7_Code_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Moonshot_V1_128kParams = TypedDict( + "Moonshot_V1_128kParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "n": Annotated[int, Field(ge=1, le=5)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Moonshot_V1_128kParams, "__pydantic_config__", _PARAMS_CONFIG) + +Moonshot_V1_32kParams = TypedDict( + "Moonshot_V1_32kParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "n": Annotated[int, Field(ge=1, le=5)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Moonshot_V1_32kParams, "__pydantic_config__", _PARAMS_CONFIG) + +Moonshot_V1_8kParams = TypedDict( + "Moonshot_V1_8kParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "n": Annotated[int, Field(ge=1, le=5)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Moonshot_V1_8kParams, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Kimi_K2_5Params", + "Kimi_K2_6Params", + "Kimi_K2_6_SubscriptionParams", + "Kimi_K2_7_Code_Highspeed_SubscriptionParams", + "Kimi_K2_7_Code_SubscriptionParams", + "Moonshot_V1_128kParams", + "Moonshot_V1_32kParams", + "Moonshot_V1_8kParams", +] diff --git a/packages/modelparams-python/src/modelparams/types/nvidia.py b/packages/modelparams-python/src/modelparams/types/nvidia.py new file mode 100644 index 0000000..8d4a7f8 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/nvidia.py @@ -0,0 +1,244 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Gliner_PiiParams = TypedDict( + "Gliner_PiiParams", + { + "threshold": Annotated[float, Field(ge=0, le=1)], + "chunk_length": Annotated[int, Field(ge=1, le=2048)], + "overlap": Annotated[int, Field(ge=0, le=512)], + "flat_ner": bool, + }, + total=False, +) +setattr(Gliner_PiiParams, "__pydantic_config__", _PARAMS_CONFIG) + +Llama_3_1_Nemoguard_8b_Topic_ControlParams = TypedDict( + "Llama_3_1_Nemoguard_8b_Topic_ControlParams", + { + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(le=1)], + "max_tokens": Annotated[int, Field(ge=1)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "stop": str, + }, + total=False, +) +setattr(Llama_3_1_Nemoguard_8b_Topic_ControlParams, "__pydantic_config__", _PARAMS_CONFIG) + +Llama_3_1_Nemotron_Nano_8b_V1Params = TypedDict( + "Llama_3_1_Nemotron_Nano_8b_V1Params", + { + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(le=1)], + "max_tokens": Annotated[int, Field(ge=1, le=16384)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "seed": Annotated[int, Field(ge=0, le=18446744073709552000)], + "stop": str, + }, + total=False, +) +setattr(Llama_3_1_Nemotron_Nano_8b_V1Params, "__pydantic_config__", _PARAMS_CONFIG) + +Llama_3_1_Nemotron_Safety_Guard_8b_V3Params = TypedDict( + "Llama_3_1_Nemotron_Safety_Guard_8b_V3Params", + { + "temperature": Annotated[float, Field(ge=0, le=1)], + }, + total=False, +) +setattr(Llama_3_1_Nemotron_Safety_Guard_8b_V3Params, "__pydantic_config__", _PARAMS_CONFIG) + +Llama_3_1_Nemotron_Ultra_253b_V1Params = TypedDict( + "Llama_3_1_Nemotron_Ultra_253b_V1Params", + { + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(le=1)], + "max_tokens": Annotated[int, Field(ge=1, le=16384)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "seed": Annotated[int, Field(ge=0, le=18446744073709552000)], + "stop": str, + }, + total=False, +) +setattr(Llama_3_1_Nemotron_Ultra_253b_V1Params, "__pydantic_config__", _PARAMS_CONFIG) + +Llama_3_3_Nemotron_Super_49b_V1Params = TypedDict( + "Llama_3_3_Nemotron_Super_49b_V1Params", + { + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(le=1)], + "max_tokens": Annotated[int, Field(ge=1, le=16384)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "seed": Annotated[int, Field(ge=0, le=18446744073709552000)], + "stop": str, + }, + total=False, +) +setattr(Llama_3_3_Nemotron_Super_49b_V1Params, "__pydantic_config__", _PARAMS_CONFIG) + +Llama_3_3_Nemotron_Super_49b_V1_5Params = TypedDict( + "Llama_3_3_Nemotron_Super_49b_V1_5Params", + { + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(le=1)], + "max_tokens": Annotated[int, Field(ge=1, le=65536)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "seed": Annotated[int, Field(ge=0, le=18446744073709552000)], + "stop": str, + }, + total=False, +) +setattr(Llama_3_3_Nemotron_Super_49b_V1_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +Nemoguard_Jailbreak_DetectParams = TypedDict( + "Nemoguard_Jailbreak_DetectParams", + { + + }, + total=False, +) +setattr(Nemoguard_Jailbreak_DetectParams, "__pydantic_config__", _PARAMS_CONFIG) + +Nemotron_3_Nano_30b_A3bParams = TypedDict( + "Nemotron_3_Nano_30b_A3bParams", + { + "temperature": Annotated[float, Field(le=1)], + "top_p": Annotated[float, Field(le=1)], + "max_tokens": Annotated[int, Field(ge=1, le=32768)], + "seed": Annotated[int, Field(ge=0, le=18446744073709552000)], + "stop": str, + }, + total=False, +) +setattr(Nemotron_3_Nano_30b_A3bParams, "__pydantic_config__", _PARAMS_CONFIG) + +Nemotron_3_Super_120b_A12bParams = TypedDict( + "Nemotron_3_Super_120b_A12bParams", + { + "temperature": Annotated[float, Field(le=1)], + "top_p": Annotated[float, Field(le=1)], + "max_tokens": Annotated[int, Field(ge=1, le=32768)], + "reasoning_effort": Literal["none", "low", "high"], + "reasoning_budget": Annotated[int, Field(ge=-1, le=32768)], + "seed": Annotated[int, Field(ge=0, le=18446744073709552000)], + "stop": str, + }, + total=False, +) +setattr(Nemotron_3_Super_120b_A12bParams, "__pydantic_config__", _PARAMS_CONFIG) + +Nemotron_3_Ultra_550b_A55bParams = TypedDict( + "Nemotron_3_Ultra_550b_A55bParams", + { + "temperature": Annotated[float, Field(le=1)], + "top_p": Annotated[float, Field(le=1)], + "max_tokens": Annotated[int, Field(ge=1, le=32768)], + "reasoning_effort": Literal["none", "medium", "high"], + "reasoning_budget": Annotated[int, Field(ge=-1, le=32768)], + "seed": Annotated[int, Field(ge=0, le=18446744073709552000)], + "stop": str, + }, + total=False, +) +setattr(Nemotron_3_Ultra_550b_A55bParams, "__pydantic_config__", _PARAMS_CONFIG) + +Nemotron_3_Ultra_SubscriptionParams = TypedDict( + "Nemotron_3_Ultra_SubscriptionParams", + { + "temperature": Annotated[float, Field(le=1)], + "top_p": Annotated[float, Field(le=1)], + "max_tokens": Annotated[int, Field(ge=1, le=32768)], + "reasoning_effort": Literal["none", "medium", "high"], + "reasoning_budget": Annotated[int, Field(ge=-1, le=32768)], + "stop": str, + }, + total=False, +) +setattr(Nemotron_3_Ultra_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Nemotron_Content_Safety_Reasoning_4bParams = TypedDict( + "Nemotron_Content_Safety_Reasoning_4bParams", + { + "temperature": Annotated[float, Field(le=1)], + "top_p": Annotated[float, Field(le=1)], + "max_tokens": Annotated[int, Field(ge=1, le=32768)], + "seed": Annotated[int, Field(ge=0, le=18446744073709552000)], + "stop": str, + }, + total=False, +) +setattr(Nemotron_Content_Safety_Reasoning_4bParams, "__pydantic_config__", _PARAMS_CONFIG) + +Nemotron_Mini_4b_InstructParams = TypedDict( + "Nemotron_Mini_4b_InstructParams", + { + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(le=1)], + "max_tokens": Annotated[int, Field(ge=1, le=4096)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "stop": str, + }, + total=False, +) +setattr(Nemotron_Mini_4b_InstructParams, "__pydantic_config__", _PARAMS_CONFIG) + +Riva_Translate_4b_Instruct_V1_1Params = TypedDict( + "Riva_Translate_4b_Instruct_V1_1Params", + { + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(le=1)], + "max_tokens": Annotated[int, Field(ge=1, le=4096)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "stop": str, + }, + total=False, +) +setattr(Riva_Translate_4b_Instruct_V1_1Params, "__pydantic_config__", _PARAMS_CONFIG) + +Usdcode_Llama_3_1_70b_InstructParams = TypedDict( + "Usdcode_Llama_3_1_70b_InstructParams", + { + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(le=1)], + "max_tokens": Annotated[int, Field(ge=1, le=2048)], + "expert_type": Literal["auto", "code", "knowledge", "helperfunction"], + }, + total=False, +) +setattr(Usdcode_Llama_3_1_70b_InstructParams, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Gliner_PiiParams", + "Llama_3_1_Nemoguard_8b_Topic_ControlParams", + "Llama_3_1_Nemotron_Nano_8b_V1Params", + "Llama_3_1_Nemotron_Safety_Guard_8b_V3Params", + "Llama_3_1_Nemotron_Ultra_253b_V1Params", + "Llama_3_3_Nemotron_Super_49b_V1Params", + "Llama_3_3_Nemotron_Super_49b_V1_5Params", + "Nemoguard_Jailbreak_DetectParams", + "Nemotron_3_Nano_30b_A3bParams", + "Nemotron_3_Super_120b_A12bParams", + "Nemotron_3_Ultra_550b_A55bParams", + "Nemotron_3_Ultra_SubscriptionParams", + "Nemotron_Content_Safety_Reasoning_4bParams", + "Nemotron_Mini_4b_InstructParams", + "Riva_Translate_4b_Instruct_V1_1Params", + "Usdcode_Llama_3_1_70b_InstructParams", +] diff --git a/packages/modelparams-python/src/modelparams/types/openai.py b/packages/modelparams-python/src/modelparams/types/openai.py new file mode 100644 index 0000000..05cd2d5 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/openai.py @@ -0,0 +1,529 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Chatgpt_4o_LatestParams = TypedDict( + "Chatgpt_4o_LatestParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + }, + total=False, +) +setattr(Chatgpt_4o_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_3_5_TurboParams = TypedDict( + "Gpt_3_5_TurboParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + }, + total=False, +) +setattr(Gpt_3_5_TurboParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_4_TurboParams = TypedDict( + "Gpt_4_TurboParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + }, + total=False, +) +setattr(Gpt_4_TurboParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_4_Turbo_2024_04_09Params = TypedDict( + "Gpt_4_Turbo_2024_04_09Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + }, + total=False, +) +setattr(Gpt_4_Turbo_2024_04_09Params, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_4_1Params = TypedDict( + "Gpt_4_1Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + }, + total=False, +) +setattr(Gpt_4_1Params, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_4_1_MiniParams = TypedDict( + "Gpt_4_1_MiniParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + }, + total=False, +) +setattr(Gpt_4_1_MiniParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_4_1_NanoParams = TypedDict( + "Gpt_4_1_NanoParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + }, + total=False, +) +setattr(Gpt_4_1_NanoParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_4oParams = TypedDict( + "Gpt_4oParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + }, + total=False, +) +setattr(Gpt_4oParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_4o_2024_11_20Params = TypedDict( + "Gpt_4o_2024_11_20Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + }, + total=False, +) +setattr(Gpt_4o_2024_11_20Params, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_4o_MiniParams = TypedDict( + "Gpt_4o_MiniParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + }, + total=False, +) +setattr(Gpt_4o_MiniParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5Params = TypedDict( + "Gpt_5Params", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["minimal", "low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_Chat_LatestParams = TypedDict( + "Gpt_5_Chat_LatestParams", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + }, + total=False, +) +setattr(Gpt_5_Chat_LatestParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_MiniParams = TypedDict( + "Gpt_5_MiniParams", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["minimal", "low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_MiniParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_NanoParams = TypedDict( + "Gpt_5_NanoParams", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["minimal", "low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_NanoParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_1Params = TypedDict( + "Gpt_5_1Params", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["none", "low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_1Params, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_1_Codex_Max_SubscriptionParams = TypedDict( + "Gpt_5_1_Codex_Max_SubscriptionParams", + { + "reasoning.effort": Literal["minimal", "low", "medium", "high", "xhigh"], + "reasoning.summary": Literal["auto", "concise", "detailed", "none"], + "text.verbosity": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_1_Codex_Max_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_1_Codex_SubscriptionParams = TypedDict( + "Gpt_5_1_Codex_SubscriptionParams", + { + "reasoning.effort": Literal["minimal", "low", "medium", "high"], + "reasoning.summary": Literal["auto", "concise", "detailed", "none"], + "text.verbosity": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_1_Codex_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_2Params = TypedDict( + "Gpt_5_2Params", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["none", "low", "medium", "high", "xhigh"], + }, + total=False, +) +setattr(Gpt_5_2Params, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_2_Codex_SubscriptionParams = TypedDict( + "Gpt_5_2_Codex_SubscriptionParams", + { + "reasoning.effort": Literal["minimal", "low", "medium", "high", "xhigh"], + "reasoning.summary": Literal["auto", "concise", "detailed", "none"], + "text.verbosity": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_2_Codex_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_2_SubscriptionParams = TypedDict( + "Gpt_5_2_SubscriptionParams", + { + "reasoning.effort": Literal["minimal", "low", "medium", "high", "xhigh"], + "reasoning.summary": Literal["auto", "concise", "detailed", "none"], + "text.verbosity": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_2_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_3_CodexParams = TypedDict( + "Gpt_5_3_CodexParams", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["low", "medium", "high", "xhigh"], + }, + total=False, +) +setattr(Gpt_5_3_CodexParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_3_Codex_Spark_SubscriptionParams = TypedDict( + "Gpt_5_3_Codex_Spark_SubscriptionParams", + { + "reasoning.effort": Literal["minimal", "low", "medium", "high", "xhigh"], + "reasoning.summary": Literal["auto", "concise", "detailed", "none"], + "text.verbosity": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_3_Codex_Spark_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_3_Codex_SubscriptionParams = TypedDict( + "Gpt_5_3_Codex_SubscriptionParams", + { + "reasoning.effort": Literal["minimal", "low", "medium", "high", "xhigh"], + "reasoning.summary": Literal["auto", "concise", "detailed", "none"], + "text.verbosity": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_3_Codex_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_4Params = TypedDict( + "Gpt_5_4Params", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["none", "low", "medium", "high", "xhigh"], + }, + total=False, +) +setattr(Gpt_5_4Params, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_4_MiniParams = TypedDict( + "Gpt_5_4_MiniParams", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["none", "low", "medium", "high", "xhigh"], + }, + total=False, +) +setattr(Gpt_5_4_MiniParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_4_Mini_SubscriptionParams = TypedDict( + "Gpt_5_4_Mini_SubscriptionParams", + { + "reasoning.effort": Literal["minimal", "low", "medium", "high", "xhigh"], + "reasoning.summary": Literal["auto", "concise", "detailed", "none"], + "text.verbosity": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_4_Mini_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_4_NanoParams = TypedDict( + "Gpt_5_4_NanoParams", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["none", "low", "medium", "high", "xhigh"], + }, + total=False, +) +setattr(Gpt_5_4_NanoParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_4_ProParams = TypedDict( + "Gpt_5_4_ProParams", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["medium", "high", "xhigh"], + }, + total=False, +) +setattr(Gpt_5_4_ProParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_4_Pro_SubscriptionParams = TypedDict( + "Gpt_5_4_Pro_SubscriptionParams", + { + "reasoning.effort": Literal["medium", "high", "xhigh"], + "reasoning.summary": Literal["auto", "concise", "detailed", "none"], + "text.verbosity": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_4_Pro_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_4_SubscriptionParams = TypedDict( + "Gpt_5_4_SubscriptionParams", + { + "reasoning.effort": Literal["minimal", "low", "medium", "high", "xhigh"], + "reasoning.summary": Literal["auto", "concise", "detailed", "none"], + "text.verbosity": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_4_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_5Params = TypedDict( + "Gpt_5_5Params", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["none", "low", "medium", "high", "xhigh"], + }, + total=False, +) +setattr(Gpt_5_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_5_ProParams = TypedDict( + "Gpt_5_5_ProParams", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["medium", "high", "xhigh"], + }, + total=False, +) +setattr(Gpt_5_5_ProParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_5_Pro_SubscriptionParams = TypedDict( + "Gpt_5_5_Pro_SubscriptionParams", + { + "reasoning.effort": Literal["medium", "high", "xhigh"], + "reasoning.summary": Literal["auto", "concise", "detailed", "none"], + "text.verbosity": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_5_Pro_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_5_SubscriptionParams = TypedDict( + "Gpt_5_5_SubscriptionParams", + { + "reasoning.effort": Literal["minimal", "low", "medium", "high", "xhigh"], + "reasoning.summary": Literal["auto", "concise", "detailed", "none"], + "text.verbosity": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_5_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_6_LunaParams = TypedDict( + "Gpt_5_6_LunaParams", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["none", "low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_6_LunaParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_5_6_SolParams = TypedDict( + "Gpt_5_6_SolParams", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["none", "low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_5_6_SolParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_Oss_120bParams = TypedDict( + "Gpt_Oss_120bParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1, le=131072)], + "reasoning_effort": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_Oss_120bParams, "__pydantic_config__", _PARAMS_CONFIG) + +Gpt_Oss_20bParams = TypedDict( + "Gpt_Oss_20bParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1, le=131072)], + "reasoning_effort": Literal["low", "medium", "high"], + }, + total=False, +) +setattr(Gpt_Oss_20bParams, "__pydantic_config__", _PARAMS_CONFIG) + +O1Params = TypedDict( + "O1Params", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["low", "medium", "high", "xhigh"], + }, + total=False, +) +setattr(O1Params, "__pydantic_config__", _PARAMS_CONFIG) + +O1_MiniParams = TypedDict( + "O1_MiniParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "reasoning_effort": Literal["minimal", "low", "medium", "high"], + }, + total=False, +) +setattr(O1_MiniParams, "__pydantic_config__", _PARAMS_CONFIG) + +O1_PreviewParams = TypedDict( + "O1_PreviewParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "reasoning_effort": Literal["minimal", "low", "medium", "high"], + }, + total=False, +) +setattr(O1_PreviewParams, "__pydantic_config__", _PARAMS_CONFIG) + +O3Params = TypedDict( + "O3Params", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["low", "medium", "high", "xhigh"], + }, + total=False, +) +setattr(O3Params, "__pydantic_config__", _PARAMS_CONFIG) + +O3_MiniParams = TypedDict( + "O3_MiniParams", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["low", "medium", "high", "xhigh"], + }, + total=False, +) +setattr(O3_MiniParams, "__pydantic_config__", _PARAMS_CONFIG) + +O3_ProParams = TypedDict( + "O3_ProParams", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["low", "medium", "high", "xhigh"], + }, + total=False, +) +setattr(O3_ProParams, "__pydantic_config__", _PARAMS_CONFIG) + +O4_MiniParams = TypedDict( + "O4_MiniParams", + { + "max_completion_tokens": Annotated[int, Field(ge=16)], + "reasoning_effort": Literal["low", "medium", "high", "xhigh"], + }, + total=False, +) +setattr(O4_MiniParams, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Chatgpt_4o_LatestParams", + "Gpt_3_5_TurboParams", + "Gpt_4_TurboParams", + "Gpt_4_Turbo_2024_04_09Params", + "Gpt_4_1Params", + "Gpt_4_1_MiniParams", + "Gpt_4_1_NanoParams", + "Gpt_4oParams", + "Gpt_4o_2024_11_20Params", + "Gpt_4o_MiniParams", + "Gpt_5Params", + "Gpt_5_Chat_LatestParams", + "Gpt_5_MiniParams", + "Gpt_5_NanoParams", + "Gpt_5_1Params", + "Gpt_5_1_Codex_Max_SubscriptionParams", + "Gpt_5_1_Codex_SubscriptionParams", + "Gpt_5_2Params", + "Gpt_5_2_Codex_SubscriptionParams", + "Gpt_5_2_SubscriptionParams", + "Gpt_5_3_CodexParams", + "Gpt_5_3_Codex_Spark_SubscriptionParams", + "Gpt_5_3_Codex_SubscriptionParams", + "Gpt_5_4Params", + "Gpt_5_4_MiniParams", + "Gpt_5_4_Mini_SubscriptionParams", + "Gpt_5_4_NanoParams", + "Gpt_5_4_ProParams", + "Gpt_5_4_Pro_SubscriptionParams", + "Gpt_5_4_SubscriptionParams", + "Gpt_5_5Params", + "Gpt_5_5_ProParams", + "Gpt_5_5_Pro_SubscriptionParams", + "Gpt_5_5_SubscriptionParams", + "Gpt_5_6_LunaParams", + "Gpt_5_6_SolParams", + "Gpt_Oss_120bParams", + "Gpt_Oss_20bParams", + "O1Params", + "O1_MiniParams", + "O1_PreviewParams", + "O3Params", + "O3_MiniParams", + "O3_ProParams", + "O4_MiniParams", +] diff --git a/packages/modelparams-python/src/modelparams/types/perplexity.py b/packages/modelparams-python/src/modelparams/types/perplexity.py new file mode 100644 index 0000000..5da2b1d --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/perplexity.py @@ -0,0 +1,98 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +SonarParams = TypedDict( + "SonarParams", + { + "max_tokens": Annotated[int, Field(ge=1, le=128000)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "search_mode": Literal["web", "academic", "sec"], + "search_recency_filter": Literal["hour", "day", "week", "month", "year"], + "search_domain_filter": str, + "search_after_date_filter": str, + "search_before_date_filter": str, + "web_search_options.search_context_size": Literal["low", "medium", "high"], + "return_images": bool, + "return_related_questions": bool, + "disable_search": bool, + }, + total=False, +) +setattr(SonarParams, "__pydantic_config__", _PARAMS_CONFIG) + +Sonar_Deep_ResearchParams = TypedDict( + "Sonar_Deep_ResearchParams", + { + "max_tokens": Annotated[int, Field(ge=1, le=128000)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "reasoning_effort": Literal["minimal", "low", "medium", "high"], + "search_mode": Literal["web", "academic", "sec"], + "search_recency_filter": Literal["hour", "day", "week", "month", "year"], + "search_domain_filter": str, + "search_after_date_filter": str, + "search_before_date_filter": str, + "web_search_options.search_context_size": Literal["low", "medium", "high"], + "return_images": bool, + "return_related_questions": bool, + }, + total=False, +) +setattr(Sonar_Deep_ResearchParams, "__pydantic_config__", _PARAMS_CONFIG) + +Sonar_ProParams = TypedDict( + "Sonar_ProParams", + { + "max_tokens": Annotated[int, Field(ge=1, le=128000)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "search_mode": Literal["web", "academic", "sec"], + "search_recency_filter": Literal["hour", "day", "week", "month", "year"], + "search_domain_filter": str, + "search_after_date_filter": str, + "search_before_date_filter": str, + "web_search_options.search_context_size": Literal["low", "medium", "high"], + "return_images": bool, + "return_related_questions": bool, + "disable_search": bool, + }, + total=False, +) +setattr(Sonar_ProParams, "__pydantic_config__", _PARAMS_CONFIG) + +Sonar_Reasoning_ProParams = TypedDict( + "Sonar_Reasoning_ProParams", + { + "max_tokens": Annotated[int, Field(ge=1, le=128000)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "search_mode": Literal["web", "academic", "sec"], + "search_recency_filter": Literal["hour", "day", "week", "month", "year"], + "search_domain_filter": str, + "search_after_date_filter": str, + "search_before_date_filter": str, + "web_search_options.search_context_size": Literal["low", "medium", "high"], + "return_images": bool, + "return_related_questions": bool, + "disable_search": bool, + }, + total=False, +) +setattr(Sonar_Reasoning_ProParams, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "SonarParams", + "Sonar_Deep_ResearchParams", + "Sonar_ProParams", + "Sonar_Reasoning_ProParams", +] diff --git a/packages/modelparams-python/src/modelparams/types/xai.py b/packages/modelparams-python/src/modelparams/types/xai.py new file mode 100644 index 0000000..4108f73 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/xai.py @@ -0,0 +1,116 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Grok_4_20_0309_Non_ReasoningParams = TypedDict( + "Grok_4_20_0309_Non_ReasoningParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "seed": int, + "stop": str, + "response_format.type": Literal["text", "json_object", "json_schema"], + }, + total=False, +) +setattr(Grok_4_20_0309_Non_ReasoningParams, "__pydantic_config__", _PARAMS_CONFIG) + +Grok_4_20_0309_ReasoningParams = TypedDict( + "Grok_4_20_0309_ReasoningParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "seed": int, + "response_format.type": Literal["text", "json_object", "json_schema"], + }, + total=False, +) +setattr(Grok_4_20_0309_ReasoningParams, "__pydantic_config__", _PARAMS_CONFIG) + +Grok_4_20_Multi_Agent_0309Params = TypedDict( + "Grok_4_20_Multi_Agent_0309Params", + { + "max_output_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "reasoning.effort": Literal["low", "medium", "high", "xhigh"], + "text.format.type": Literal["text", "json_object", "json_schema"], + }, + total=False, +) +setattr(Grok_4_20_Multi_Agent_0309Params, "__pydantic_config__", _PARAMS_CONFIG) + +Grok_4_3Params = TypedDict( + "Grok_4_3Params", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "seed": int, + "reasoning_effort": Literal["none", "low", "medium", "high"], + "response_format.type": Literal["text", "json_object", "json_schema"], + }, + total=False, +) +setattr(Grok_4_3Params, "__pydantic_config__", _PARAMS_CONFIG) + +Grok_4_5Params = TypedDict( + "Grok_4_5Params", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "seed": int, + "reasoning_effort": Literal["low", "medium", "high"], + "response_format.type": Literal["text", "json_object", "json_schema"], + }, + total=False, +) +setattr(Grok_4_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +Grok_4_5_SubscriptionParams = TypedDict( + "Grok_4_5_SubscriptionParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "seed": int, + "reasoning_effort": Literal["low", "medium", "high"], + "response_format.type": Literal["text", "json_object", "json_schema"], + }, + total=False, +) +setattr(Grok_4_5_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Grok_Build_0_1Params = TypedDict( + "Grok_Build_0_1Params", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "seed": int, + "response_format.type": Literal["text", "json_object", "json_schema"], + }, + total=False, +) +setattr(Grok_Build_0_1Params, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Grok_4_20_0309_Non_ReasoningParams", + "Grok_4_20_0309_ReasoningParams", + "Grok_4_20_Multi_Agent_0309Params", + "Grok_4_3Params", + "Grok_4_5Params", + "Grok_4_5_SubscriptionParams", + "Grok_Build_0_1Params", +] diff --git a/packages/modelparams-python/src/modelparams/types/xiaomi.py b/packages/modelparams-python/src/modelparams/types/xiaomi.py new file mode 100644 index 0000000..edaa253 --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/xiaomi.py @@ -0,0 +1,59 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Mimo_V2_5Params = TypedDict( + "Mimo_V2_5Params", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "thinking.type": Literal["enabled", "disabled"], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Mimo_V2_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +Mimo_V2_5_ProParams = TypedDict( + "Mimo_V2_5_ProParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "thinking.type": Literal["enabled", "disabled"], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "presence_penalty": Annotated[float, Field(ge=-2, le=2)], + "frequency_penalty": Annotated[float, Field(ge=-2, le=2)], + "stop": str, + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Mimo_V2_5_ProParams, "__pydantic_config__", _PARAMS_CONFIG) + +Mimo_V2_5_SubscriptionParams = TypedDict( + "Mimo_V2_5_SubscriptionParams", + { + "max_completion_tokens": Annotated[int, Field(ge=1)], + "thinking.type": Literal["enabled", "disabled"], + "temperature": Annotated[float, Field(ge=0, le=2)], + "top_p": Annotated[float, Field(ge=0, le=1)], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Mimo_V2_5_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Mimo_V2_5Params", + "Mimo_V2_5_ProParams", + "Mimo_V2_5_SubscriptionParams", +] diff --git a/packages/modelparams-python/src/modelparams/types/z_ai.py b/packages/modelparams-python/src/modelparams/types/z_ai.py new file mode 100644 index 0000000..d74615e --- /dev/null +++ b/packages/modelparams-python/src/modelparams/types/z_ai.py @@ -0,0 +1,331 @@ +# AUTO-GENERATED by packages/modelparams-python/scripts/codegen.ts. +# Do not edit by hand; the YAML catalog under /models is the source of truth. + +# ruff: noqa: F401 + +from typing import Annotated, Literal + +from pydantic import ConfigDict, Field +from typing_extensions import TypedDict + +_PARAMS_CONFIG = ConfigDict(strict=True, extra="forbid") + +Glm_4_5Params = TypedDict( + "Glm_4_5Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_4_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_4_5_AirParams = TypedDict( + "Glm_4_5_AirParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_4_5_AirParams, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_4_5_Air_SubscriptionParams = TypedDict( + "Glm_4_5_Air_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_4_5_Air_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_4_5_AirxParams = TypedDict( + "Glm_4_5_AirxParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_4_5_AirxParams, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_4_5_FlashParams = TypedDict( + "Glm_4_5_FlashParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_4_5_FlashParams, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_4_5_SubscriptionParams = TypedDict( + "Glm_4_5_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_4_5_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_4_5_XParams = TypedDict( + "Glm_4_5_XParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_4_5_XParams, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_4_6Params = TypedDict( + "Glm_4_6Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_4_6Params, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_4_6_SubscriptionParams = TypedDict( + "Glm_4_6_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_4_6_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_4_7Params = TypedDict( + "Glm_4_7Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_4_7Params, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_4_7_FlashParams = TypedDict( + "Glm_4_7_FlashParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_4_7_FlashParams, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_4_7_FlashxParams = TypedDict( + "Glm_4_7_FlashxParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_4_7_FlashxParams, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_4_7_SubscriptionParams = TypedDict( + "Glm_4_7_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_4_7_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_5Params = TypedDict( + "Glm_5Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_5Params, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_5_SubscriptionParams = TypedDict( + "Glm_5_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_5_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_5_TurboParams = TypedDict( + "Glm_5_TurboParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_5_TurboParams, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_5_Turbo_SubscriptionParams = TypedDict( + "Glm_5_Turbo_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_5_Turbo_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_5_1Params = TypedDict( + "Glm_5_1Params", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_5_1Params, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_5_1_SubscriptionParams = TypedDict( + "Glm_5_1_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_5_1_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_5_2Params = TypedDict( + "Glm_5_2Params", + { + "max_tokens": Annotated[int, Field(ge=1, le=131072)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "reasoning_effort": Literal["max", "xhigh", "high", "medium", "low", "minimal", "none"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_5_2Params, "__pydantic_config__", _PARAMS_CONFIG) + +Glm_5_2_SubscriptionParams = TypedDict( + "Glm_5_2_SubscriptionParams", + { + "max_tokens": Annotated[int, Field(ge=1, le=131072)], + "temperature": Annotated[float, Field(ge=0, le=1)], + "top_p": Annotated[float, Field(ge=0.01, le=1)], + "do_sample": bool, + "thinking.type": Literal["enabled", "disabled"], + "reasoning_effort": Literal["max", "xhigh", "high", "medium", "low", "minimal", "none"], + "response_format.type": Literal["text", "json_object"], + }, + total=False, +) +setattr(Glm_5_2_SubscriptionParams, "__pydantic_config__", _PARAMS_CONFIG) + +__all__ = [ + "Glm_4_5Params", + "Glm_4_5_AirParams", + "Glm_4_5_Air_SubscriptionParams", + "Glm_4_5_AirxParams", + "Glm_4_5_FlashParams", + "Glm_4_5_SubscriptionParams", + "Glm_4_5_XParams", + "Glm_4_6Params", + "Glm_4_6_SubscriptionParams", + "Glm_4_7Params", + "Glm_4_7_FlashParams", + "Glm_4_7_FlashxParams", + "Glm_4_7_SubscriptionParams", + "Glm_5Params", + "Glm_5_SubscriptionParams", + "Glm_5_TurboParams", + "Glm_5_Turbo_SubscriptionParams", + "Glm_5_1Params", + "Glm_5_1_SubscriptionParams", + "Glm_5_2Params", + "Glm_5_2_SubscriptionParams", +] diff --git a/packages/modelparams-python/src/modelparams/validation.py b/packages/modelparams-python/src/modelparams/validation.py new file mode 100644 index 0000000..9f52ecd --- /dev/null +++ b/packages/modelparams-python/src/modelparams/validation.py @@ -0,0 +1,19 @@ +from __future__ import annotations + +from functools import cache +from typing import Any, cast + +from pydantic import TypeAdapter + +from ._generated.model_ids import ModelId +from ._generated.registry import PARAM_TYPES +from .models import JsonPrimitive + + +@cache +def params_adapter(model_id: ModelId) -> TypeAdapter[Any]: + return TypeAdapter(PARAM_TYPES[model_id]) + + +def validate_params(model_id: ModelId, params: object) -> dict[str, JsonPrimitive]: + return cast(dict[str, JsonPrimitive], params_adapter(model_id).validate_python(params)) diff --git a/packages/modelparams-python/tests/test_catalog.py b/packages/modelparams-python/tests/test_catalog.py new file mode 100644 index 0000000..e80ff31 --- /dev/null +++ b/packages/modelparams-python/tests/test_catalog.py @@ -0,0 +1,83 @@ +from importlib import metadata +from types import MappingProxyType + +import pytest +from pydantic import ValidationError + +import modelparams +from modelparams import ( + BY_ID, + CATALOG, + DEFAULTS, + MODEL_IDS, + PROVIDERS, + get_defaults, + get_model, + get_param, + list_all_models, + list_models, +) +from modelparams._generated.registry import PARAM_TYPES + +HAIKU = "anthropic/claude-haiku-4-5-20251001" + + +def test_version_falls_back_when_distribution_metadata_is_unavailable( + monkeypatch: pytest.MonkeyPatch, +) -> None: + def missing_version(_distribution_name: str) -> str: + raise metadata.PackageNotFoundError + + monkeypatch.setattr(modelparams.metadata, "version", missing_version) + assert modelparams._package_version() == "0+unknown" + + +def test_generated_catalog_indexes_are_complete() -> None: + assert CATALOG + assert len(CATALOG) == len(MODEL_IDS) == len(BY_ID) == len(DEFAULTS) + assert set(BY_ID) == set(MODEL_IDS) + assert set(PARAM_TYPES) == set(MODEL_IDS) + assert PROVIDERS + + +def test_get_model_returns_frozen_pythonic_metadata() -> None: + model = get_model(HAIKU) + assert model.provider == "anthropic" + assert model.auth_type == "api_key" + assert model.model == "claude-haiku-4-5-20251001" + assert model.params + with pytest.raises(ValidationError): + model.model = "changed" + + +def test_defaults_are_immutable_and_do_not_include_missing_values() -> None: + defaults = get_defaults(HAIKU) + assert isinstance(defaults, MappingProxyType) + assert defaults["max_tokens"] == 4096 + assert defaults["thinking.type"] == "disabled" + with pytest.raises(TypeError): + defaults["max_tokens"] = 1 # type: ignore[index] + assert ( + get_defaults("alibaba/qwen-flash")["extra_body.chat_template_kwargs.enable_thinking"] + is True + ) + + +def test_model_listing_and_lookup_helpers() -> None: + assert list_models() is MODEL_IDS + anthropic = list_models("anthropic") + assert anthropic + assert all(model_id.startswith("anthropic/") for model_id in anthropic) + assert get_param(HAIKU, "thinking.type") is not None + assert get_param(HAIKU, "not.a.parameter") is None + assert list_all_models() is CATALOG + + +def test_applicability_aliases_are_preserved() -> None: + parameter = get_param("anthropic/claude-3-5-sonnet-latest", "temperature") + assert parameter is not None + assert parameter.applicability is not None + assert parameter.applicability.except_ is not None + dumped = parameter.applicability.model_dump(by_alias=True) + assert "except" in dumped + assert "except_" not in dumped diff --git a/packages/modelparams-python/tests/test_validation.py b/packages/modelparams-python/tests/test_validation.py new file mode 100644 index 0000000..8451869 --- /dev/null +++ b/packages/modelparams-python/tests/test_validation.py @@ -0,0 +1,91 @@ +from typing import Any, cast + +import pytest +from pydantic import ValidationError + +from modelparams import MODEL_IDS, get_defaults, params_adapter, validate_params + +GPT = "openai/gpt-4.1" +HAIKU = "anthropic/claude-haiku-4-5-20251001" + + +def error_types(error: ValidationError) -> set[str]: + return {str(issue["type"]) for issue in error.errors()} + + +def test_accepts_valid_and_empty_params() -> None: + assert validate_params(GPT, {"temperature": 0.5, "max_tokens": 100}) == { + "temperature": 0.5, + "max_tokens": 100, + } + assert validate_params(GPT, {}) == {} + + +def test_rejects_unknown_keys_and_collects_errors() -> None: + with pytest.raises(ValidationError) as caught: + validate_params(GPT, {"temperature": 5, "nope": 1}) + assert {issue["loc"] for issue in caught.value.errors()} == {("temperature",), ("nope",)} + assert error_types(caught.value) == {"less_than_equal", "extra_forbidden"} + + +@pytest.mark.parametrize( + ("params", "expected_type"), + [ + ({"temperature": "0.5"}, "float_type"), + ({"temperature": True}, "float_type"), + ({"max_tokens": 1.5}, "int_type"), + ({"max_tokens": "10"}, "int_type"), + ], +) +def test_strict_validation_rejects_coercion(params: dict[str, object], expected_type: str) -> None: + with pytest.raises(ValidationError) as caught: + validate_params(GPT, params) + assert expected_type in error_types(caught.value) + + +def test_enforces_ranges_and_enum_literals() -> None: + with pytest.raises(ValidationError) as high: + validate_params(GPT, {"temperature": 2.1}) + assert "less_than_equal" in error_types(high.value) + + with pytest.raises(ValidationError) as low: + validate_params(GPT, {"temperature": -0.1}) + assert "greater_than_equal" in error_types(low.value) + + assert validate_params(HAIKU, {"thinking.type": "enabled"}) == {"thinking.type": "enabled"} + with pytest.raises(ValidationError) as enum_error: + validate_params(HAIKU, {"thinking.type": "off"}) + assert "literal_error" in error_types(enum_error.value) + + +def test_preserves_dot_paths_without_expansion() -> None: + params = { + "thinking.type": "enabled", + "thinking.budget_tokens": 4096, + } + assert validate_params(HAIKU, params) == params + + +def test_does_not_inject_defaults_or_enforce_step_or_applicability() -> None: + assert validate_params(HAIKU, {}) == {} + assert validate_params(GPT, {"temperature": 0.55}) == {"temperature": 0.55} + contradictory = {"thinking.type": "enabled", "temperature": 0.5} + assert validate_params("anthropic/claude-sonnet-4-6", contradictory) == contradictory + + +def test_adapter_is_cached_and_unknown_model_raises_key_error() -> None: + assert params_adapter(GPT) is params_adapter(GPT) + with pytest.raises(KeyError): + params_adapter(cast(Any, "openai/not-a-model")) + + +def test_every_generated_adapter_accepts_its_catalog_defaults() -> None: + for model_id in MODEL_IDS: + validated = params_adapter(model_id).validate_python(dict(get_defaults(model_id))) + assert validated == dict(get_defaults(model_id)) + + +@pytest.mark.parametrize("params", [None, 42, "params", [1, 2]]) +def test_rejects_non_dictionary_inputs(params: object) -> None: + with pytest.raises(ValidationError): + validate_params(GPT, params) diff --git a/packages/modelparams-python/tests/typecheck/params.py b/packages/modelparams-python/tests/typecheck/params.py new file mode 100644 index 0000000..ad89159 --- /dev/null +++ b/packages/modelparams-python/tests/typecheck/params.py @@ -0,0 +1,19 @@ +from modelparams.types.anthropic import Claude_Haiku_4_5_20251001Params +from modelparams.types.openai import Gpt_4_1Params + +valid_openai: Gpt_4_1Params = {"temperature": 0.7, "max_tokens": 1024} +valid_haiku: Claude_Haiku_4_5_20251001Params = { + "thinking.type": "enabled", + "thinking.budget_tokens": 4096, +} +empty: Gpt_4_1Params = {} + +bad_enum: Claude_Haiku_4_5_20251001Params = { + "thinking.type": "off", # type: ignore[typeddict-item] +} +bad_type: Gpt_4_1Params = { + "max_tokens": "many", # type: ignore[typeddict-item] +} +bad_key: Gpt_4_1Params = { + "top_k": 40, # type: ignore[typeddict-unknown-key] +} diff --git a/packages/modelparams-python/uv.lock b/packages/modelparams-python/uv.lock new file mode 100644 index 0000000..b4719e7 --- /dev/null +++ b/packages/modelparams-python/uv.lock @@ -0,0 +1,1087 @@ +version = 1 +revision = 3 +requires-python = ">=3.10" +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version < '3.15'", +] + +[[package]] +name = "annotated-types" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/56/a8120250d128bed162cd73c76d45f6ef9991f3e068f62a8ee060afa3104a/annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7", size = 15893, upload-time = "2026-07-23T20:16:13.995Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" }, +] + +[[package]] +name = "ast-serialize" +version = "0.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/ad/0d70a3a2d6e01968d985415259e8ec7ad3f777903f9b1c1f3c8c44642c60/ast_serialize-0.6.0.tar.gz", hash = "sha256:aadd3ffcf4858c9726bf3515f7b199c7eadbe504f96028e4a87172c0da65a8fe", size = 61489, upload-time = "2026-06-30T20:02:55.555Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/12/3e5f575f156555547c250a8b0d1347517a3a20fc7f4492e9703a69d4f45e/ast_serialize-0.6.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:a7520b672827885bafeae7501f684d14d47d17e5f45256f9df547686cca52264", size = 1177640, upload-time = "2026-06-30T20:02:06.708Z" }, + { url = "https://files.pythonhosted.org/packages/a2/a4/921a9e27951627983b0f368859ea00f8330a551dc0bf4c2fdcb11855a98b/ast_serialize-0.6.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a14191beec7e0c078d2fc1f6edc0aee88bcd4db9f18e1bc9f8052b559c22dddc", size = 1168111, upload-time = "2026-06-30T20:02:08.366Z" }, + { url = "https://files.pythonhosted.org/packages/00/69/950cf404de7b8782cf95e5c1237e25e2aa46177b287f39f9eeddf481fd6f/ast_serialize-0.6.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32ef62ec34cf6be20ad77d4799556638fbdf187f3ae10698dfb20ef9f2c89516", size = 1227656, upload-time = "2026-06-30T20:02:09.843Z" }, + { url = "https://files.pythonhosted.org/packages/4c/a8/46f8f6a6479d9d2273980957bb091a506c55f5b95d3c029ee58518a78407/ast_serialize-0.6.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:13b7769970a39983b0adf2f38917b1cd3b8946f76df045756c3d741bc689f089", size = 1227706, upload-time = "2026-06-30T20:02:11.367Z" }, + { url = "https://files.pythonhosted.org/packages/b7/b9/9ac415bda0a40e49eab8fea3b2741c19c98bb84d57d62c4cfc6230eb67be/ast_serialize-0.6.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6f7a408601bb3edaefb3bc67a4c01f5235e3253653b6a5729a2ee2382b35341c", size = 1431705, upload-time = "2026-06-30T20:02:12.737Z" }, + { url = "https://files.pythonhosted.org/packages/e5/06/8807115d441444879f7561b5eede5ac18fc80392f11826d61ccf31f503b1/ast_serialize-0.6.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8670bfa51208a2c0c8d138928e40e998fab158f9200d53bb80c088b5b8eda7b8", size = 1249533, upload-time = "2026-06-30T20:02:14.571Z" }, + { url = "https://files.pythonhosted.org/packages/3e/c0/c2ba82ef9618650357d9421a1fdb27ffec862a7f57e8e2de82a3ccd11e12/ast_serialize-0.6.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a4826809eb8597a8cd59fd924b6d7c285b8969a1e0007e2cb652cab62376270f", size = 1252619, upload-time = "2026-06-30T20:02:16.219Z" }, + { url = "https://files.pythonhosted.org/packages/0f/a7/fa31d52dd4102cede29fb9634e98d214129b2783b4f95528c6dc6a8f6587/ast_serialize-0.6.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:577a6c189068686869f5f1ddc38363f3ae1808a4753b577266f9202071a7bb66", size = 1242983, upload-time = "2026-06-30T20:02:17.813Z" }, + { url = "https://files.pythonhosted.org/packages/b1/20/ddf742b5ad3c4bafd3466f2265037cfd99bc1b9a5ee46a5d58c90d523242/ast_serialize-0.6.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:085de7f62dc9cc247eb01e965a362707d1d90b1d89a82c5bf78301a60a3c417b", size = 1296148, upload-time = "2026-06-30T20:02:19.146Z" }, + { url = "https://files.pythonhosted.org/packages/24/cb/9f6f217cce8b3b632c5568b478d195a35e79dce4dbe309438cb89ba6ea4f/ast_serialize-0.6.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9f8a8b78b13173de6a9ec22111d9be674874cd5bdccda04f14ae5ebc2bef403a", size = 1403826, upload-time = "2026-06-30T20:02:20.696Z" }, + { url = "https://files.pythonhosted.org/packages/2d/f8/9d16d4f0107a183924425cc0e7618d8bf76f96b45afa9ff19f924ed1ad57/ast_serialize-0.6.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f2ff3baffc3a29c1f15bc9098aa0c09763410262d5e6cef42116f7356c184554", size = 1502943, upload-time = "2026-06-30T20:02:22.034Z" }, + { url = "https://files.pythonhosted.org/packages/80/dd/bbc1c38756350dddf7e24acae1c9482ef42051c267417e019aecc1ed4075/ast_serialize-0.6.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:0067b25fce104eaae5b88383de9ab803faeb671831e14ca698b771b356e2600f", size = 1497632, upload-time = "2026-06-30T20:02:23.517Z" }, + { url = "https://files.pythonhosted.org/packages/42/7e/9daffefcf5b97e6bb4c3e0b3c024c1aee9722f23d3cf7cd2ff80d6fb4a40/ast_serialize-0.6.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c617417f9cbb0cb144f6283c3cbe0d2e0f01beaf9f608f662b21191058a626ec", size = 1448858, upload-time = "2026-06-30T20:02:24.889Z" }, + { url = "https://files.pythonhosted.org/packages/e5/1f/f9baaab81a677ea0af7d2458cac2f94ebcc85958f8a3c15ba9d9e5dab653/ast_serialize-0.6.0-cp314-cp314t-win32.whl", hash = "sha256:5337cb256dcea3df9288205213d1601581536526b8f4da44b6974f1180f3252a", size = 1052600, upload-time = "2026-06-30T20:02:26.263Z" }, + { url = "https://files.pythonhosted.org/packages/9e/1f/41b535866519512d8cf6669cb2cff7823b7672bb6279c0333b4ff89d7d9f/ast_serialize-0.6.0-cp314-cp314t-win_amd64.whl", hash = "sha256:2d947e45cafc4b09bd7528917fa84c517654a43de173c79785574b7b3068ac24", size = 1095570, upload-time = "2026-06-30T20:02:27.639Z" }, + { url = "https://files.pythonhosted.org/packages/50/64/e472fe3e3a2d33d874b987e8518aedf24562919e3b6161a4fa1797e89c0f/ast_serialize-0.6.0-cp314-cp314t-win_arm64.whl", hash = "sha256:6e15ec740436e1a0d62de848641abe5f3a2f89a7f94907d534795ac91bbacf14", size = 1067267, upload-time = "2026-06-30T20:02:28.949Z" }, + { url = "https://files.pythonhosted.org/packages/52/19/ac8348ae8711c9b5ae834634f635780cab62a0f5e6f988882e048b89c2ae/ast_serialize-0.6.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:093cb8bb91b720d8523580498d031791bb1bbaa048599c3d21085d380e11a596", size = 1185367, upload-time = "2026-06-30T20:02:30.427Z" }, + { url = "https://files.pythonhosted.org/packages/c1/f6/ec7ec652c51db77c2f61d8573338e13e4704303265ccc658cb4031d9f354/ast_serialize-0.6.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:e61580a69faf47e3689795367ed211f2a10fd741478cc0f36a0f128793360aad", size = 1178657, upload-time = "2026-06-30T20:02:31.964Z" }, + { url = "https://files.pythonhosted.org/packages/6f/02/613a7534a41d0122f37d1e0c64aa8ac78bfb831f8c92f6db057a311abb3c/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:305802f2ce2a7c4e87835078ea85c58b586ddda8095b92fe2ead9364ae19c80a", size = 1238620, upload-time = "2026-06-30T20:02:33.664Z" }, + { url = "https://files.pythonhosted.org/packages/4d/21/087957bba486242afc52f49b2d9e21c9dad00289356cf9efe67084015a9d/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c7b8b8f0c42f752ea00b2b7d7c090b3f80d9c1c5c75cadf16423790a0cc74081", size = 1236075, upload-time = "2026-06-30T20:02:34.936Z" }, + { url = "https://files.pythonhosted.org/packages/82/04/78128bbb170071c2c72a210a181f1c00e11cc1cec60a8beef747b07f9201/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd5b91b9e6f2356ace3a556963b0cd783b395fbbb0bb17b4defc283415466e77", size = 1441348, upload-time = "2026-06-30T20:02:36.245Z" }, + { url = "https://files.pythonhosted.org/packages/64/64/62fb99d6faf199b4c3e5b08a07136e9a0d7664bb249c6de3670e5b63e9b6/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4d6ef91590258ada18909b9caea344dac4de2013906b035473cd674a43f4b790", size = 1258580, upload-time = "2026-06-30T20:02:37.53Z" }, + { url = "https://files.pythonhosted.org/packages/ca/87/b4d6c38e0ccd5e85dc54cecdf933a152c60b28fe5d993a6d8a72fa6d5896/ast_serialize-0.6.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dcbed41e9386059fc0261d602445ede0976c2ecec2939688bcbcb9ed0b6f28b7", size = 1261693, upload-time = "2026-06-30T20:02:39.123Z" }, + { url = "https://files.pythonhosted.org/packages/0e/4b/3676ca2191f39bafb75f93f99b2f429ec464586158fece2165f3572805dc/ast_serialize-0.6.0-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:cdc4e6f930b9090c2f92c9036ad12ffb8e6e44d4a5ba06f1458a05d60f203f7b", size = 1252517, upload-time = "2026-06-30T20:02:40.511Z" }, + { url = "https://files.pythonhosted.org/packages/f3/58/494ef8c4b4acb2f4a265ac934caf45f792a08fe27d6b853de35ad991941a/ast_serialize-0.6.0-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:897ac47b5637be41c0c07061c8a912fafa967ef1dc73fa115e4bfa70882a093b", size = 1304843, upload-time = "2026-06-30T20:02:41.961Z" }, + { url = "https://files.pythonhosted.org/packages/b1/f2/13736d920ab3d49bbee80ef1a277dd7b7aaf3b3545efd9d2a8114fe05525/ast_serialize-0.6.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c4af9a1386166e40ed01464991806f89038a2d89782576c7774876fa77034e32", size = 1413698, upload-time = "2026-06-30T20:02:44.179Z" }, + { url = "https://files.pythonhosted.org/packages/a8/5a/e046f3899e2acba4677d7427b76431443a1aa1a0e583dfb05b55b69d55cf/ast_serialize-0.6.0-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:c901adbd750029b9ac4ad3d6aa56853e0ad4875119fbf52b7b8298afc223828b", size = 1512209, upload-time = "2026-06-30T20:02:45.584Z" }, + { url = "https://files.pythonhosted.org/packages/cc/c7/e42aaca7bb2d22a7c06d5a8c7930086c5a334e93d716e6fa5e6647a4515f/ast_serialize-0.6.0-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:3ae22a366b752ab4496191525b78b097b5b72d531752e3c1dd7e383a8f2c8a1a", size = 1508464, upload-time = "2026-06-30T20:02:46.942Z" }, + { url = "https://files.pythonhosted.org/packages/95/93/5524a3dc6c3f593de3228ed9cbef73afa047625b7000ec21b7f58e6eb4d4/ast_serialize-0.6.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:4ed29121da8b3fdc291002801a1de0f76248fa07dce89157a5f277842cf6126e", size = 1457164, upload-time = "2026-06-30T20:02:48.294Z" }, + { url = "https://files.pythonhosted.org/packages/4f/c0/36a6ffb4d653cf621427b4c4928671f53ad800c453474de2b82564a44ad9/ast_serialize-0.6.0-cp39-abi3-pyemscripten_2026_0_wasm32.whl", hash = "sha256:b1dac4e09d341c1300ba69cdcbe62867b32a8c75d90db9bf4d083bec3b039f0b", size = 863014, upload-time = "2026-06-30T20:02:49.742Z" }, + { url = "https://files.pythonhosted.org/packages/09/c7/7d5ad8b49e1278e1c2a1e0274bd7850560b3f09313aa00c13bc8d5544792/ast_serialize-0.6.0-cp39-abi3-win32.whl", hash = "sha256:82c312a7844d2fdeb4d5c48bd3d215bf940dafd4704e1a9bcf252a99010a99b1", size = 1063165, upload-time = "2026-06-30T20:02:50.98Z" }, + { url = "https://files.pythonhosted.org/packages/47/ae/6710c14ecb276031cf10249f6adf5a59e2d3fdb3b5183bd59f70524067ee/ast_serialize-0.6.0-cp39-abi3-win_amd64.whl", hash = "sha256:113b58346f9ceb664352032770caca817d4a3c86f611c6088e6ef65ddaa70f0e", size = 1101444, upload-time = "2026-06-30T20:02:52.554Z" }, + { url = "https://files.pythonhosted.org/packages/66/40/c53deb2cd0c9b0fb636d24d9f40924cf2e65028e6b20b10cd5c1eeb2c730/ast_serialize-0.6.0-cp39-abi3-win_arm64.whl", hash = "sha256:ccd132fe8db56f61fe743b1f644d01b8d65b83248a8da506f3132bda86d6ed5e", size = 1072965, upload-time = "2026-06-30T20:02:54.097Z" }, +] + +[[package]] +name = "backports-tarfile" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/86/72/cd9b395f25e290e633655a100af28cb253e4393396264a98bd5f5951d50f/backports_tarfile-1.2.0.tar.gz", hash = "sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991", size = 86406, upload-time = "2024-05-28T17:01:54.731Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/fa/123043af240e49752f1c4bd24da5053b6bd00cad78c2be53c0d1e8b975bc/backports.tarfile-1.2.0-py3-none-any.whl", hash = "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34", size = 30181, upload-time = "2024-05-28T17:01:53.112Z" }, +] + +[[package]] +name = "build" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "os_name == 'nt'" }, + { name = "importlib-metadata", marker = "python_full_version < '3.10.2'" }, + { name = "packaging" }, + { name = "pyproject-hooks" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/78/e0/df5e171f685f82f37b12e1f208064e24244911079d7b767447d1af7e0d70/build-1.5.0.tar.gz", hash = "sha256:302c22c3ba2a0fd5f3911918651341ebb3896176cbdec15bd421f80b1afc7647", size = 89796, upload-time = "2026-04-30T03:18:25.17Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/fe/6bea5c9162869c5beba5d9c8abbed835ec85bf1ec1fba05a3822325c45f3/build-1.5.0-py3-none-any.whl", hash = "sha256:13f3eecb844759ab66efec90ca17639bbf14dc06cb2fdf37a9010322d9c50a6f", size = 26018, upload-time = "2026-04-30T03:18:23.644Z" }, +] + +[[package]] +name = "certifi" +version = "2026.7.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" }, +] + +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/0b/ba385d8ccedf926c3cd06e8e2f327027da5afe5f0eb30f1f7bc43ac55125/cffi-2.1.1-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:42e2f76b9455f5a9a844f770bf3e200ed3da0e15f5df3db9c31fe80b04b3d004", size = 211037, upload-time = "2026-08-03T21:19:17.705Z" }, + { url = "https://files.pythonhosted.org/packages/a3/b9/0f2e58b2cefa33255bff36935d42b13180fe559bba82596540eb404bde7d/cffi-2.1.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5a59cc1c4442bc3d5c703bf720b51138d0bfc173618807c9ee2490a7541dd3d9", size = 218652, upload-time = "2026-08-03T21:19:18.735Z" }, + { url = "https://files.pythonhosted.org/packages/75/77/60bebf6f818bec84210ac5b6979ce4eeadce6fbbaabc9c7ab23e506d1ce5/cffi-2.1.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:194cffa889098ced9976c3fc6340305e43f6303657d298da55366907c05c22d6", size = 218742, upload-time = "2026-08-03T21:19:22.523Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ae/679bf47e73fd77b352171727f07de559a003f14de5d02b904a6ec1fa73ca/cffi-2.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5bb4e7ea95dcd6a014a6fef62e62467d67d8e582326443f3d68e71d6320a9fcf", size = 221054, upload-time = "2026-08-03T21:19:23.694Z" }, + { url = "https://files.pythonhosted.org/packages/09/b8/eefc0e06913b70aa153bf74c946094a18f58fd4aff11b7f372bfdfdca050/cffi-2.1.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3d22a20b1fb1632cc72c22f95f7b0d2961c3e1c235f245ba4c606c4771035659", size = 213489, upload-time = "2026-08-03T21:19:24.922Z" }, + { url = "https://files.pythonhosted.org/packages/6f/13/4e56852824a03cdf68523a35686f1c28eacd4bd30a7b0a78e682e6e6e1d3/cffi-2.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:1dea0e4d7d4f11f619fe8c1d76caf49e24405b4b5743c0e3be16a500ecd930c9", size = 220241, upload-time = "2026-08-03T21:19:26.214Z" }, + { url = "https://files.pythonhosted.org/packages/ad/5a/4707a0dc1f203f5dde5a907b0d4e3c25d71120241048bd5bc6f1bb9d4e71/cffi-2.1.1-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:154852545011f779917b11c78db2358d095da62a9a172b78ad0a583ee5adc0d0", size = 211805, upload-time = "2026-08-03T21:19:31.867Z" }, + { url = "https://files.pythonhosted.org/packages/ad/66/c19feabb28485b6e0bbaaafa90837a1ef5d302e90f2178bd33f17a49879b/cffi-2.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3311ed60d36f83378794e1009ac6258bafbf81f7888b4caa7b35a521e3f95813", size = 218716, upload-time = "2026-08-03T21:19:32.896Z" }, + { url = "https://files.pythonhosted.org/packages/f7/a4/4399daaf8f7dfee9d7c3327fdb0426ee041cc63edc358b93911ceb2bfc7a/cffi-2.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:34e261f78cb6ceaaa36f42f2613f4380d94d9c759a9c73c769ee6e0247364632", size = 217807, upload-time = "2026-08-03T21:19:36.286Z" }, + { url = "https://files.pythonhosted.org/packages/28/f7/dabe6da2466ecbd82dc62e7342dc6b1065dad990c06f00f0ede9ebf2a0ed/cffi-2.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7225e4514edb64eb6740324353e0da0711954fd8d7da4576755b1c6e09b697cd", size = 221252, upload-time = "2026-08-03T21:19:37.416Z" }, + { url = "https://files.pythonhosted.org/packages/ce/87/616202d8e51342c07d2534c510111c4cc37201775ce8f60802c9335d1edd/cffi-2.1.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:df913725b79db7bcf03448f36b7bf8815363417d5b58deecf9305e3e30f0f21a", size = 214214, upload-time = "2026-08-03T21:19:38.507Z" }, + { url = "https://files.pythonhosted.org/packages/b4/c6/ab025d75d2c26c19b087c0124e75ee31cb65032f4fe345d356d8c507ab97/cffi-2.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f5cfbc5fe74540d335175b656c725d74d90e3730c626d92575eea35029d9afaa", size = 219408, upload-time = "2026-08-03T21:19:39.809Z" }, + { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", size = 214799, upload-time = "2026-08-03T21:19:47.218Z" }, + { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", size = 222389, upload-time = "2026-08-03T21:19:48.331Z" }, + { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", size = 225232, upload-time = "2026-08-03T21:19:53.109Z" }, + { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/035513d4117049066b4779dc3b7c0c0fdad175fa13731c9f4003f1cd1478/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e", size = 194248, upload-time = "2026-08-03T21:19:59.399Z" }, + { url = "https://files.pythonhosted.org/packages/76/af/2aeb4dbb5fc41a04161ae9ff1518de7cec08e164f44a8ce6a4cf7fd2cd1d/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c", size = 196908, upload-time = "2026-08-03T21:20:00.746Z" }, + { url = "https://files.pythonhosted.org/packages/43/1f/1c3d90d91811c8f86ced9ed637956c54bfe5b79ca98fe976d7f8c8979f6b/cffi-2.1.1-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c", size = 214722, upload-time = "2026-08-03T21:20:04.377Z" }, + { url = "https://files.pythonhosted.org/packages/37/6f/3b5ce4c3b2192d250f04908f2bfd91ef34552ec8f7716a5d4abdb8d67bb2/cffi-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125", size = 222369, upload-time = "2026-08-03T21:20:05.544Z" }, + { url = "https://files.pythonhosted.org/packages/95/95/86342356ff5953b3fb06f7ef7c5bee212d45e770abc7218d451b9148313c/cffi-2.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2", size = 221824, upload-time = "2026-08-03T21:20:09.274Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ff/7b3429ff53aafe931ed8a5fc69f481bbef7ba6de87ddcbb63d08f483f613/cffi-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b", size = 225148, upload-time = "2026-08-03T21:20:10.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/34/a95870b9221e09cf4f2ce3178b1a210abdfe63a1bd357da940418d7b8d15/cffi-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7", size = 223564, upload-time = "2026-08-03T21:20:12.165Z" }, + { url = "https://files.pythonhosted.org/packages/d3/7b/d6bbf82b8b96e7391438898c42f5bd96dd02030fd5b64937d248220003e2/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c", size = 194064, upload-time = "2026-08-03T21:20:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/94/e6/bcc91b283be94735e268487a054004f0aa19947b6348fa367db53230abc8/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb", size = 196720, upload-time = "2026-08-03T21:20:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/67/b8/b42132ca113dc567d37684437b46ca1dafc885902b02a110a02d5b511857/cffi-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1", size = 222328, upload-time = "2026-08-03T21:20:22.118Z" }, + { url = "https://files.pythonhosted.org/packages/e9/02/4e7d553a7ac4b4238b38b3c1b80d486e9d4436f8d2acbf87a0997fe3f402/cffi-2.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96", size = 221525, upload-time = "2026-08-03T21:20:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/82/1d/a4aaf9babd75acb4d5f223bff71533bee748dd770a382619a798960ee9ba/cffi-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527", size = 225053, upload-time = "2026-08-03T21:20:26.985Z" }, + { url = "https://files.pythonhosted.org/packages/81/10/5dc0e7bdd18e22107054288283380fc97a06ae3f1656a106908d666a3c88/cffi-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13", size = 223213, upload-time = "2026-08-03T21:20:28.277Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9c/92934c3bea9f785b23eba304538c0b4d37a2a96d2431eb3a1bc87a11aa19/cffi-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94", size = 223864, upload-time = "2026-08-03T21:20:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/9a/95/eff5f0cee78d2eabc7eebffec40d3fc1876b5f3c95582e018bb4b99601f2/cffi-2.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676", size = 223803, upload-time = "2026-08-03T21:20:36.564Z" }, + { url = "https://files.pythonhosted.org/packages/fa/01/579d39fb8bef00a335a23d83757b44feb24cd6345a2c451b64cb67b9c362/cffi-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e", size = 226763, upload-time = "2026-08-03T21:20:37.816Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b0/0b44f47c60b01b57b6e2bbd92343f13a85a1d93bc46ccf6e47e244acd99c/cffi-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f", size = 225688, upload-time = "2026-08-03T21:20:38.959Z" }, + { url = "https://files.pythonhosted.org/packages/c1/8f/9ebe220eab48a093d1a5a5e339ab0dc7316eef3bb04d63c42f0251b61f50/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d", size = 194043, upload-time = "2026-08-03T21:20:48.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/69/844bad3ece306c4782c2ecb93597035b6690d48704b803914c199da1e8b3/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b", size = 196737, upload-time = "2026-08-03T21:20:49.457Z" }, + { url = "https://files.pythonhosted.org/packages/e2/31/9e1313b0a6e30e91b3b3d3fff51ae99c857c07738e3afcce1f7334e1b7ab/cffi-2.1.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6", size = 222271, upload-time = "2026-08-03T21:20:53.462Z" }, + { url = "https://files.pythonhosted.org/packages/44/16/29e6d01b388bef055ecd6ca8244b3f4d336bd09e92d5d892187b9601084e/cffi-2.1.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399", size = 221630, upload-time = "2026-08-03T21:20:57.336Z" }, + { url = "https://files.pythonhosted.org/packages/a4/18/fa7f1f6857d5eb88a4ca99ffcbfb7c387a287ccc154c64a73e86314745d7/cffi-2.1.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688", size = 225134, upload-time = "2026-08-03T21:20:58.675Z" }, + { url = "https://files.pythonhosted.org/packages/e0/9f/e8e3dfa04a1b4c241f8c91faacad872b4d4efd051d49764ad4e2fd4b9fea/cffi-2.1.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7", size = 223197, upload-time = "2026-08-03T21:20:59.968Z" }, + { url = "https://files.pythonhosted.org/packages/53/b2/6187f46f2912276a3ae284076109cc5c8680482f11f766ccf26db4a86427/cffi-2.1.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e", size = 223779, upload-time = "2026-08-03T21:21:03.553Z" }, + { url = "https://files.pythonhosted.org/packages/52/86/2976131c639aead931c5bee5aba67e4b09fbeb8018b6f282f70803f923a7/cffi-2.1.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6", size = 223835, upload-time = "2026-08-03T21:21:07.539Z" }, + { url = "https://files.pythonhosted.org/packages/ac/0c/33a7aeab2f9c76918c52e084beb39c570db3588133412929e8ec06fab90b/cffi-2.1.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94", size = 226705, upload-time = "2026-08-03T21:21:08.774Z" }, + { url = "https://files.pythonhosted.org/packages/e3/26/2cde30fdde421130bfc18f70395731a6e6b2053c6a1978a5258ff04e72fa/cffi-2.1.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5", size = 225539, upload-time = "2026-08-03T21:21:09.911Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.9" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bd/2a/23f34ec9d04624958e137efdc394888716353190e75f25dd22c7a2c7a8aa/charset_normalizer-3.4.9.tar.gz", hash = "sha256:673611bbd43f0810bec0b0f028ddeaaa501190339cac411f347ac76917c3ae7b", size = 152439, upload-time = "2026-07-07T14:34:58.454Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ad/81/8e983840c6e5b93b33c2ba81aa3d52c2e42f0e9a690ce7607a2e61da4a5c/charset_normalizer-3.4.9-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cd6280cf040f233bd7d3407b743b4b4c74f70e8e1c4199cb112a62c941c0772a", size = 322240, upload-time = "2026-07-07T14:32:36.236Z" }, + { url = "https://files.pythonhosted.org/packages/de/d1/b4319dc3229d8272fba305e206fc0a148e2de8d4087917ce62ae6382f359/charset_normalizer-3.4.9-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa99adc8f081b475a12843953db36831eaf83ec33eb46a90629ca6a5de45a616", size = 216475, upload-time = "2026-07-07T14:32:38.142Z" }, + { url = "https://files.pythonhosted.org/packages/80/33/6c99c1b3e6b8bf730e1bc809b9a2608f224145069114c479a2e9e1494346/charset_normalizer-3.4.9-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c1225416b463483160e4af85d5fc3a9690ccb53fd4b1865a6437825f5ede3209", size = 238670, upload-time = "2026-07-07T14:32:39.658Z" }, + { url = "https://files.pythonhosted.org/packages/7f/f4/ffbb83546e1f198ecc70ecd372b65cf2b50f9068b380abd67640f17a8e18/charset_normalizer-3.4.9-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:16d10d789dd9bcca1173c95af82c58433122564b7bc39385124be735a35cbe99", size = 233476, upload-time = "2026-07-07T14:32:41.155Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5f/b98b8da398637b551e427e7be922bdec19177dc54d6811dcdaa503f23aac/charset_normalizer-3.4.9-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9bb41182d93ea91f60b4bc8fbf4c820c69ef8a12ab2d917f3f1834f1acad07e8", size = 223817, upload-time = "2026-07-07T14:32:42.592Z" }, + { url = "https://files.pythonhosted.org/packages/36/31/a276bb2e66243072a3fd06fdcab9cbb61a305b02143d70d2bda21d888fa8/charset_normalizer-3.4.9-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:bcf74c1df76758a395bf0af608c04c82257523f55c9868b334f06270d0f2112b", size = 207974, upload-time = "2026-07-07T14:32:44.258Z" }, + { url = "https://files.pythonhosted.org/packages/5e/be/7ee4453d7e88dfbc4104ccd34900b9f2c7c17dac22881865fe0e82424a25/charset_normalizer-3.4.9-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b5314963fce9b0b12743891de876e724997864ee22aa496f903f426c7e2fa5b2", size = 221655, upload-time = "2026-07-07T14:32:45.64Z" }, + { url = "https://files.pythonhosted.org/packages/1d/85/181c652953eb5276d198f375b1dd641047392050098100a3a02d6534f657/charset_normalizer-3.4.9-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e9701d0049d92c16703a42771b98d560b95248949f23f8cf7b4eddd201814fb9", size = 219229, upload-time = "2026-07-07T14:32:47.376Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e7/aaf6da33fc9f4691cda8f7efbc9f69179d3d39ec8a4799baf273ee1d8db0/charset_normalizer-3.4.9-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:65a7ff3f705e57d392f7261b6d0550fe137c3019477431f1c355e0db0a7d3e15", size = 209704, upload-time = "2026-07-07T14:32:48.855Z" }, + { url = "https://files.pythonhosted.org/packages/63/01/f2fb3bd3a73be48b173ee0c6aa8d2497af97d5663a8c4c4b491de4c62f7a/charset_normalizer-3.4.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:79580094b00d1789d1f93ea55bc43cb2f611910c72235b7657f3482ddcc1b22d", size = 226243, upload-time = "2026-07-07T14:32:50.239Z" }, + { url = "https://files.pythonhosted.org/packages/c4/02/c57a22739fe05246b0b5783b3bfb6afaac4eebb46f3ececdfb2f048f780e/charset_normalizer-3.4.9-cp310-cp310-win32.whl", hash = "sha256:432786d3561e69aeeae6c7e8648964ce0ad05736120135601f87ac26b9c83381", size = 150935, upload-time = "2026-07-07T14:32:51.676Z" }, + { url = "https://files.pythonhosted.org/packages/37/8d/ca39a7559a4797505530d084fd3a49a2c959efbbbff146302fb7be4e3b35/charset_normalizer-3.4.9-cp310-cp310-win_amd64.whl", hash = "sha256:8c041122946b7ba21bb32c45b1aa57b1be35527690aeb3c5c234521085632eee", size = 162314, upload-time = "2026-07-07T14:32:53.193Z" }, + { url = "https://files.pythonhosted.org/packages/01/da/a44bd7a13d426e69e4894557106cd58669097bfad4a8681123b618fbfc5d/charset_normalizer-3.4.9-cp310-cp310-win_arm64.whl", hash = "sha256:375b83ed0aecfce76c16d198fbc21f3b11b337d68662bea0a995046682a11419", size = 153075, upload-time = "2026-07-07T14:32:54.554Z" }, + { url = "https://files.pythonhosted.org/packages/0b/e3/85ec501f206fb049259288c1f3506e53876937fb00edb47009348e66756b/charset_normalizer-3.4.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0e94703ec9684807f20cfb5eed95c70f67f2a8f21ad620146d7b5a13677b93e5", size = 317075, upload-time = "2026-07-07T14:32:56.021Z" }, + { url = "https://files.pythonhosted.org/packages/c3/69/2a5385192e67175f7d8bd5ce4f57c24bc956439adeae5c13a99aa28a53d1/charset_normalizer-3.4.9-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a441ea71902098ffe78c5abe6c494f44160b4af614ed16c3d9a3b1d17fd8ee2", size = 213837, upload-time = "2026-07-07T14:32:57.78Z" }, + { url = "https://files.pythonhosted.org/packages/b3/46/03ddc7da576d814fe0a36dd1f0fd3258e95404b4b2e3c026b7923d7e133f/charset_normalizer-3.4.9-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:304b13570067b2547562e308af560b3963857b1fa90bd6afd978130130fe2d6a", size = 235503, upload-time = "2026-07-07T14:32:59.205Z" }, + { url = "https://files.pythonhosted.org/packages/4e/6e/de0229a7ef40f6f9d28a837eebf4ec47bdca5dab4e900c84f22919af636a/charset_normalizer-3.4.9-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4773092f8019072343a7447203308b176e10199920eb02d6195e81bbb3274c29", size = 229944, upload-time = "2026-07-07T14:33:00.803Z" }, + { url = "https://files.pythonhosted.org/packages/a5/34/49b9060e8418b14fb5cba9cf6bfb383111e2538a03a1fb18e66a95aeb3d5/charset_normalizer-3.4.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:04ce310cb89c15df659582aee80a0603788732a5e017d5bd5c81158106ce249c", size = 221276, upload-time = "2026-07-07T14:33:02.199Z" }, + { url = "https://files.pythonhosted.org/packages/44/95/80282cce0fae9c3061203d723ee87da996aed79679e65d8935050ee7ca1f/charset_normalizer-3.4.9-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:c0323c9daef75ef2e5083624b4585018a0c9d5e3b40f607eed81a311270b934b", size = 205260, upload-time = "2026-07-07T14:33:03.698Z" }, + { url = "https://files.pythonhosted.org/packages/0c/74/2f62c8821b969ea3bd67cc2e6976834f48ca5d12664d2559ebcd9bcfbed7/charset_normalizer-3.4.9-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:871ff67ea1aad4dfd91736464934d56b32dac49f9fbe16cddba36198a7b3a0db", size = 217786, upload-time = "2026-07-07T14:33:05.12Z" }, + { url = "https://files.pythonhosted.org/packages/d9/8d/feabb82cb49fcad14515b1d7d1ca4787b0da7fc723a212bf89bc9e0fac52/charset_normalizer-3.4.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:67830fc78e67501f47bb950471b2dcb9b35b140084429318e862895a8e89c993", size = 216798, upload-time = "2026-07-07T14:33:06.629Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ff/c946d63bc3786d5b84d960b0f7ab7e25b828486a946b5aa997625bcaf6a6/charset_normalizer-3.4.9-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:3d92613ec25e43b05f042302531ec0f00b8445190e43325880cbd6ab7c2581da", size = 206429, upload-time = "2026-07-07T14:33:08.006Z" }, + { url = "https://files.pythonhosted.org/packages/af/ba/5e5007c370702f85d2ef75791fac7943ed41e080364a673b20142e430e3e/charset_normalizer-3.4.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:280081916dc341820640489a66e4696049401ef1cf6dd672f672e70ad915aca3", size = 223066, upload-time = "2026-07-07T14:33:09.783Z" }, + { url = "https://files.pythonhosted.org/packages/83/d5/9096aa3cf532dfad237861544eb47a0f20d5adbf1039760fed8eaae935d9/charset_normalizer-3.4.9-cp311-cp311-win32.whl", hash = "sha256:ac351b3b8014eead140e77e9717e2992c6bbe30b63bc3422422eb84865412e3d", size = 150456, upload-time = "2026-07-07T14:33:11.217Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a1/e29995109e455dc8eff8d0fac6ae509be39561318a7cfeac5d33ad029213/charset_normalizer-3.4.9-cp311-cp311-win_amd64.whl", hash = "sha256:6366a16e1a25018694d6a5d784d09b046edc9eac40ea2b54065c3052672516a1", size = 161410, upload-time = "2026-07-07T14:33:12.743Z" }, + { url = "https://files.pythonhosted.org/packages/4f/8d/1569f4d0032d6ba2a4fe4591c35bf87868c600c41a71eb5c2e1ffa8464c2/charset_normalizer-3.4.9-cp311-cp311-win_arm64.whl", hash = "sha256:1d22856ffbe153a602df38e4a5464f0b748a54002e0d69ac6d2ad0a197cc99ec", size = 152649, upload-time = "2026-07-07T14:33:14.173Z" }, + { url = "https://files.pythonhosted.org/packages/70/4a/ecbd131485c07fcdfad54e28946d513e3da22ef3b4bd854dcafae54ec739/charset_normalizer-3.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:45b0cc4e3556cd875e09102988d1ab8356c998b596c9fced84547c8138b487a0", size = 319300, upload-time = "2026-07-07T14:33:15.666Z" }, + { url = "https://files.pythonhosted.org/packages/ec/96/5d9364e3342d69f3a045e1777bc47c85c383e6e9466d561b33fdb419d1f9/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9b2aff1c7b3884512b9512c3eaadd9bab39fb45042ffaaa1dd08ff2b9f8109d9", size = 215802, upload-time = "2026-07-07T14:33:17.031Z" }, + { url = "https://files.pythonhosted.org/packages/4b/4c/5361f9aa7f2cb58d94f2ab831b3d493f69efb1d239654b4744e3c09527cb/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9104ed0bd76a429d46f9ec0dbc9b08ad1d2dcdf2b00a5a0daa1c145329b35b44", size = 237171, upload-time = "2026-07-07T14:33:18.576Z" }, + { url = "https://files.pythonhosted.org/packages/50/78/ce342ca4ff30b2eb49fe6d9578df85974f90c67d294113e94efdd9664cbd/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7b86a2b16095d250c6f58b3d9b2eee6f4147754344f3dab0922f7c9bf7d226c9", size = 233075, upload-time = "2026-07-07T14:33:20.084Z" }, + { url = "https://files.pythonhosted.org/packages/01/c4/4fa4c8b3097a11f3c5f09a35b72ed6855fb1d332469504962ab7bafcc702/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e226f6218febc71f6c1fc2fafb91c226f75bdc1d8fb12d66823716e891608fd", size = 224256, upload-time = "2026-07-07T14:33:21.747Z" }, + { url = "https://files.pythonhosted.org/packages/87/3a/ad914516df7e358a81aae018caa5e0470ba827fa6d763b1d2e87d920a5f6/charset_normalizer-3.4.9-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:90c44bc373b7687f6948b693cceaea1348ae0975d7474746559494468e3c1d84", size = 208784, upload-time = "2026-07-07T14:33:23.313Z" }, + { url = "https://files.pythonhosted.org/packages/d7/74/3c12f9755717dfe5c5c87da63f35d765fa0c00382ec26bf23f7fae34f2ba/charset_normalizer-3.4.9-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cdef90ae47919cae358d8ab15797a800ed41da7aba5d72419fb510729e2ed4b", size = 219928, upload-time = "2026-07-07T14:33:24.814Z" }, + { url = "https://files.pythonhosted.org/packages/33/9a/895095b83e7907abd6d3d99aad3a38ad0d9686cc186cb0c94c24320fe63e/charset_normalizer-3.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:60f44ade2cf573dad7a277e6f8ca9a51a21dda572b13bd7d8539bb3cd5dbedde", size = 218489, upload-time = "2026-07-07T14:33:26.42Z" }, + { url = "https://files.pythonhosted.org/packages/a1/34/ef5c05f412f42520d7709b7d3784d19640839eb7366ded1755511585429f/charset_normalizer-3.4.9-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:a1786910334ed46ab1dd73222f2cd1e05c2c3bb39f6dddb4f8b36fc382058a39", size = 210267, upload-time = "2026-07-07T14:33:27.952Z" }, + { url = "https://files.pythonhosted.org/packages/83/dc/9b29fa4412b318bf3bfea985c35d67eb55e04b59a7c3f2237168b0e0be6f/charset_normalizer-3.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:03d07803992c6c7bbc976327f34b18b6160327fc81cb82c9d504720ac0be3b62", size = 226030, upload-time = "2026-07-07T14:33:29.397Z" }, + { url = "https://files.pythonhosted.org/packages/0e/42/6dbc00b8cd16011691203e33570fa42ed5746599a2e878112d16eab403a3/charset_normalizer-3.4.9-cp312-cp312-win32.whl", hash = "sha256:78841cccf1af7b40f6f716338d50c0902dbe88d9f800b3c973b7a9a0a693a642", size = 151185, upload-time = "2026-07-07T14:33:30.781Z" }, + { url = "https://files.pythonhosted.org/packages/80/cc/f920afd1a23c58ccd53c1d36085a71893a4737ff5e66e0371efab6809850/charset_normalizer-3.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:4b3dac63058cc36820b0dd072f89898604e2d39686fe05321729d00d8ac185a0", size = 162557, upload-time = "2026-07-07T14:33:32.176Z" }, + { url = "https://files.pythonhosted.org/packages/f0/e6/0386d43a261ff4e4b30c5857af7df877254b46bec7b9d1b74b6bf969a90b/charset_normalizer-3.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:78fa18e436a1a0e58dbd7e02fc4473f3f32cceb12df9dfca542d075961c307d2", size = 152665, upload-time = "2026-07-07T14:33:33.711Z" }, + { url = "https://files.pythonhosted.org/packages/b2/06/97ec2aeae780b31d742b6352218b43841a6871e2564578ca522dce4a45c3/charset_normalizer-3.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:440eede837960000d74978f0eba527be106b5b9aee0daf779d395276ed0b0614", size = 317688, upload-time = "2026-07-07T14:33:35.408Z" }, + { url = "https://files.pythonhosted.org/packages/d0/39/8ff066c672434225f8d25f8b739f992af250944392173dcc88362681c9bf/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21e764fd1e70b6a3e205a0e46f3051701f98a8cb3fad66eeb80e48bb502f8698", size = 214982, upload-time = "2026-07-07T14:33:36.996Z" }, + { url = "https://files.pythonhosted.org/packages/92/8f/3a47a3667c83c2df9483d91644c6c107de3bf8874aa1793da9d3012eb986/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e4fd89cc178bced6ad29cb3e6dd4aa63fa5017c3524dbd0b25998fb64a87cc8b", size = 236460, upload-time = "2026-07-07T14:33:38.536Z" }, + { url = "https://files.pythonhosted.org/packages/f1/60/b22cdbee7e4013dab8b0d7647fc6181120fbbbc8f7025c226d15bd5a47fc/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bd47ba7fc3ca94896759ea0109775132d3e7ab921fbf54038e1bab2e46c313c9", size = 232003, upload-time = "2026-07-07T14:33:40.059Z" }, + { url = "https://files.pythonhosted.org/packages/ea/f8/72eb13dcabe7257035cea8aefd922caad2f110d252bf9f67c4c2ca763aee/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:84fd18bcc17526fc2b3c1af7d2b9217d32c9c04448c16ec693b9b4f1985c3d33", size = 223149, upload-time = "2026-07-07T14:33:41.631Z" }, + { url = "https://files.pythonhosted.org/packages/b0/3e/faee8f9de92b14ee1198e9163252bb15efee7301b31256a3b6d9ebfdd0dd/charset_normalizer-3.4.9-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:5b10cd92fc5c498b35a8635df6d5a100207f88b63a4dc1de7ef9a548e1e2cd63", size = 207901, upload-time = "2026-07-07T14:33:43.209Z" }, + { url = "https://files.pythonhosted.org/packages/3a/25/45f30093ae27dd7b92a793b61882a38685f993700113ca36e0c9c14965e1/charset_normalizer-3.4.9-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a4fbdde9dd4a9ce5fd52c2b3a347bb50cc89483ef783f1cb00d408c13f7a96c0", size = 219176, upload-time = "2026-07-07T14:33:44.725Z" }, + { url = "https://files.pythonhosted.org/packages/48/18/c8f397329c35e32f6a837e488986f4ae03bd2abebc453b48714991630c2f/charset_normalizer-3.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:416c229f77e5ea25b3dfd4b582f8d73d7e43c22320302b9ab128a2d3a0b38efe", size = 217356, upload-time = "2026-07-07T14:33:46.192Z" }, + { url = "https://files.pythonhosted.org/packages/86/7e/5ce0bba863470fd1902d5e5843968951bddf38abe4742fc97116ef4598b3/charset_normalizer-3.4.9-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:75286256590a6320cf106a0d28970d3560aad9ee09aa7b34fb40524792436d35", size = 209614, upload-time = "2026-07-07T14:33:47.705Z" }, + { url = "https://files.pythonhosted.org/packages/6c/ef/2473d3c4d869155be4af1191111d59c4d5c4e0173026f7e85b176e23bf65/charset_normalizer-3.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:69b157c5d3292bcd443faca052f3096f637f1e074b98212a933c074ae23dc3b8", size = 224991, upload-time = "2026-07-07T14:33:49.238Z" }, + { url = "https://files.pythonhosted.org/packages/d0/a3/53ddae3db108a088156aa8ddfafd411ebbc1340f48c5573f697b27f69a39/charset_normalizer-3.4.9-cp313-cp313-win32.whl", hash = "sha256:51307f5c71007673a2bf8232ad973483d281e74cb99c8c5a990af1eefa6277d9", size = 150622, upload-time = "2026-07-07T14:33:50.711Z" }, + { url = "https://files.pythonhosted.org/packages/e8/ef/6953a77c7cf2c2ff9998e6f575ab3e380119f100223381565a4f94c1f836/charset_normalizer-3.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:fe2c7201c642b7c308f1675355ad7ff7b66acfe3541625efe5a3ad38f29d6115", size = 161947, upload-time = "2026-07-07T14:33:52.197Z" }, + { url = "https://files.pythonhosted.org/packages/6e/fb/d560d1d1555debbfe7849d9cac6145c1b537709d79576bf22557ed803b82/charset_normalizer-3.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:611057cc5d5c0afc743ba8be6bd828c17e0aaa8643f9d0a9b9bb7dea80eb8012", size = 152594, upload-time = "2026-07-07T14:33:53.486Z" }, + { url = "https://files.pythonhosted.org/packages/7e/8d/496817fa0944239ecae662dd57ea765cfeaec6a735f9f025d4b7b72e7143/charset_normalizer-3.4.9-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:0327fcd59a935777d83410750c50600ee9571af2846f71ce40f25b13da1ef380", size = 317253, upload-time = "2026-07-07T14:33:54.994Z" }, + { url = "https://files.pythonhosted.org/packages/2b/f9/ef4a69ea338ad3c0deceea0f5f7d2380ae8b52132b06d652cb0d2cd86706/charset_normalizer-3.4.9-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a79d9f4d8001473a30c163556b3c3bfebec837495a412dde78b51672f6134f9", size = 215898, upload-time = "2026-07-07T14:33:56.334Z" }, + { url = "https://files.pythonhosted.org/packages/8c/e7/5ddfd76fc061eb52de219658a4aa431cbacadf0a0219c8854f00da50d289/charset_normalizer-3.4.9-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:33bdcc2a32c0a0e861f60841a512c8acc658c87c2ac59d89e3a46dacf7d866e4", size = 236718, upload-time = "2026-07-07T14:33:57.9Z" }, + { url = "https://files.pythonhosted.org/packages/49/ba/768fa3f36048d81c477a0ce61f813bc1454d80917ccfe550abd9f44f5e24/charset_normalizer-3.4.9-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f840ed6d8ecba8255df8c42b87fadeda98ddfc6eeec05e2dc66e26d46dd6f58a", size = 232519, upload-time = "2026-07-07T14:33:59.811Z" }, + { url = "https://files.pythonhosted.org/packages/f4/c4/b3e049d2aa3766180c78507110543d9d50894cc97f57de543f1be521dcdc/charset_normalizer-3.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c25fe15c70c59eb7c5ce8c06a1f3fa1da0ecc5ea1e7a5922c40fd2fa9b0d5046", size = 223143, upload-time = "2026-07-07T14:34:01.517Z" }, + { url = "https://files.pythonhosted.org/packages/19/79/55c32d06d76ae4feafe053f061f3e3ab70bcf19f4007797ce8c3efda7830/charset_normalizer-3.4.9-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:f7fb7d750cfa0a070d2c24e831fd3481019a60dd317ea2b39acbcebc08b6ed81", size = 206742, upload-time = "2026-07-07T14:34:03.04Z" }, + { url = "https://files.pythonhosted.org/packages/10/e0/47c079dd82d217c807479cd59ffd30af56307ea31c108b75758970459ad3/charset_normalizer-3.4.9-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4d1c96a7a18b9690a4d46df09e3e3382406ae3213727cd1019ebade1c4a81917", size = 219191, upload-time = "2026-07-07T14:34:04.657Z" }, + { url = "https://files.pythonhosted.org/packages/42/ab/b9bc2e77d6b44a7e46ef62ec5cac1c9a6ba7b9135a5d560f002696ec9995/charset_normalizer-3.4.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a4cfde78a9f2880208d16a93b795726a3017d5977e08d1e162a7a31322479c41", size = 218328, upload-time = "2026-07-07T14:34:06.115Z" }, + { url = "https://files.pythonhosted.org/packages/f1/78/c9c71d599f5aa2d42bcdd35cbbd46d7f535351a57e40ff7d8e5a7e219401/charset_normalizer-3.4.9-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:d4d6fcde76f94f5cb9e43e9e9a61f16dacefd228cbbf6f1a09bd9b219a92f1a1", size = 207406, upload-time = "2026-07-07T14:34:07.554Z" }, + { url = "https://files.pythonhosted.org/packages/f6/39/c914445c321a845097ce4f6ac7de9a18228a77b766272125a1ce00d851eb/charset_normalizer-3.4.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:898f0e9068ca27d37f8e83a5b962821df851532e6c4a7d615c1c033f9da6eedf", size = 225157, upload-time = "2026-07-07T14:34:09.061Z" }, + { url = "https://files.pythonhosted.org/packages/9b/f2/c0d4b8508565a36bc5c624e88ed297f5b0b1095011034d7f5b83a69908b5/charset_normalizer-3.4.9-cp314-cp314-win32.whl", hash = "sha256:c1c948747b03be832dceed96ca815cef7360de9aa19d37c730f8e3f6101aca48", size = 151095, upload-time = "2026-07-07T14:34:10.901Z" }, + { url = "https://files.pythonhosted.org/packages/49/fd/a1d26144398c67486422a72bf5812cda22cb4ccfcd95a290fb41ceb4b8e2/charset_normalizer-3.4.9-cp314-cp314-win_amd64.whl", hash = "sha256:16b65ea0f2465b6fb52aa22de5eca612aa964ddfec00a912e26f4656cbef890b", size = 162796, upload-time = "2026-07-07T14:34:12.47Z" }, + { url = "https://files.pythonhosted.org/packages/20/95/d75e82f8ce9fd323ebf059c16c9aadefb22a1ecde13b7840b35835e4886c/charset_normalizer-3.4.9-cp314-cp314-win_arm64.whl", hash = "sha256:40a126142a56b2dfc0aacbad1de8310cbf60da7656db0e6b16eebd48e3e93519", size = 153334, upload-time = "2026-07-07T14:34:14.044Z" }, + { url = "https://files.pythonhosted.org/packages/00/5e/17398df3a139985ba9d11ed072531986f408c8fca952835ef1ab1820c02b/charset_normalizer-3.4.9-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:609b3ba8fcc0fb5ab7af00719d0fb6ad0cb518e48e7712d12fd68f1327951198", size = 338848, upload-time = "2026-07-07T14:34:15.688Z" }, + { url = "https://files.pythonhosted.org/packages/cd/91/7253a32e86b7e1d1239b1b36ba6dd0f021a21107ab33054b53119cc083b9/charset_normalizer-3.4.9-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51447e9aa2684679af07ca5021c3db526e0284347ebf4ffcec1154c3350cfe32", size = 223022, upload-time = "2026-07-07T14:34:17.248Z" }, + { url = "https://files.pythonhosted.org/packages/cb/32/2e64bd2be10e89c61e57ebe6a93fd98ae88eb7ebe414b5121f22c96c69eb/charset_normalizer-3.4.9-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cc1b0fff8ead343dae06305f954eb8468ba0ec1a97881f42489d198e4ce3c632", size = 241590, upload-time = "2026-07-07T14:34:18.813Z" }, + { url = "https://files.pythonhosted.org/packages/3d/ef/d96ec496cfea0c21db43b0ad03891308b02388d054cc902cf0e5a1ad6a88/charset_normalizer-3.4.9-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fa36ec09ef71d158186bc79e359ff5fdd6e7996fe8ab638f00d6b93139ba4fcf", size = 239584, upload-time = "2026-07-07T14:34:20.52Z" }, + { url = "https://files.pythonhosted.org/packages/d4/ce/9af95f7876194bd7a14e3dfe4a4de2e0bff02666a3910d72beafd06cc297/charset_normalizer-3.4.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:df115d4d83168fdf2cae48ef1ff6d1cb4c466364e30861b37121de0f3bf1b990", size = 230224, upload-time = "2026-07-07T14:34:22.189Z" }, + { url = "https://files.pythonhosted.org/packages/52/94/af74dde74a3996bd959c350709bfe50e297823d70a8c1cbd54b838880863/charset_normalizer-3.4.9-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:f86c6358749bd4fda175388691e3ba8c46e24c5347d0afd20f9b7edfc9faf07d", size = 212667, upload-time = "2026-07-07T14:34:23.857Z" }, + { url = "https://files.pythonhosted.org/packages/ee/f0/f1c4fe746c395922961b5916ed1d7d6e7d4c84851d19ed43cc89980ec953/charset_normalizer-3.4.9-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:32286a2c8d167e897177b673176c1e3e00d4057caf5d2b64eef9a3666b03018e", size = 227179, upload-time = "2026-07-07T14:34:25.586Z" }, + { url = "https://files.pythonhosted.org/packages/e4/56/6c745619ac397e8871e2bcd3cea1eec86b877488f33888b3aef5c3ed506e/charset_normalizer-3.4.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:83aed2c10721ddd90f68140685391b50811a880af20654c59af6b6c66c40513c", size = 225372, upload-time = "2026-07-07T14:34:27.212Z" }, + { url = "https://files.pythonhosted.org/packages/78/ad/98aae8630ac71f16711968e38a5acfecce41b778bf2f0312851020f565a8/charset_normalizer-3.4.9-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cd6c3d4b783c556fa00bf540854e42f135e2f256abd29669fcd0da0f2dec79c2", size = 215222, upload-time = "2026-07-07T14:34:28.774Z" }, + { url = "https://files.pythonhosted.org/packages/f7/40/9593d54209765207a7f11073c06494c1721e4ca4a0a426c597679bf7f91e/charset_normalizer-3.4.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ee2f2a527e3c1a6e6411eb4209642e138b544a2d72fe5d0d76daf77b24063534", size = 231958, upload-time = "2026-07-07T14:34:30.345Z" }, + { url = "https://files.pythonhosted.org/packages/b1/27/693ee5e8a18191eb38647360c51cd505013e2bd3b366aa43fd5344c21e3c/charset_normalizer-3.4.9-cp314-cp314t-win32.whl", hash = "sha256:0d861473f743244d349b50f850d10eb87aeb22bbdcc8e64f79273c94af5a8226", size = 155580, upload-time = "2026-07-07T14:34:31.884Z" }, + { url = "https://files.pythonhosted.org/packages/80/3f/bd97d3d9c613013d07cb7733d299385b41df37f0471310f5a73dc359f0b8/charset_normalizer-3.4.9-cp314-cp314t-win_amd64.whl", hash = "sha256:9b8e0f3107e2200b76f6054de99016eac3ee6762713587b36baaa7e4bd2ae177", size = 167620, upload-time = "2026-07-07T14:34:33.438Z" }, + { url = "https://files.pythonhosted.org/packages/3d/c6/eee9dca4439b1061f76373f06ea855678cc4a64c1c3c90b50e479edbb8eb/charset_normalizer-3.4.9-cp314-cp314t-win_arm64.whl", hash = "sha256:19ac87f93086ce37b86e098888555c4b4bc48102279bae3350098c0ed664b501", size = 158037, upload-time = "2026-07-07T14:34:35.018Z" }, + { url = "https://files.pythonhosted.org/packages/98/2b/f97f1c193fb855c345d678f5077d6926034db0722df74c8f057020e05a25/charset_normalizer-3.4.9-py3-none-any.whl", hash = "sha256:68e5f26a1ad57ded6d1cfb85331d1c1a195314756471d97758c48498bb4dcdf5", size = 64538, upload-time = "2026-07-07T14:34:56.993Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "cryptography" +version = "50.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/de/41/6cbdcf9142d00fe82836fbb51e503e58088575cf7a0fe1dbff6695bf0840/cryptography-50.0.0.tar.gz", hash = "sha256:eeac2acb5a20ed25e0ad6d1df9891a520b78b404266b6d11778f25d5d691a6c9", size = 880201, upload-time = "2026-07-31T14:25:10.11Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/57/ef/8f2df13c7216bcad3e1c74e07f6e193d93e998e114f524a53877c9af27ad/cryptography-50.0.0-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fd9192b7b70c573d7f214eb1ae35e00d359f6f5e4b27c7e21e30de1fc6204645", size = 4719554, upload-time = "2026-07-31T14:23:35.611Z" }, + { url = "https://files.pythonhosted.org/packages/d9/41/029086c34d91052fc3b88bcc8056f709a7c915c7a23b235a54eb800b1c97/cryptography-50.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:06a32a980526a6ab9a4b9bf8f7385800791e2bb960903cb6b530e4817509a3b7", size = 4702130, upload-time = "2026-07-31T14:23:37.635Z" }, + { url = "https://files.pythonhosted.org/packages/7d/ff/b6ce0954962e7f7b969f850a883744197bb3910bdfd7b6da162eab7d9f68/cryptography-50.0.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:a1b30560f2acc95aa8b2e06e716a13dbfc97314747b80d9707e307f77b40d6b3", size = 4725244, upload-time = "2026-07-31T14:23:39.471Z" }, + { url = "https://files.pythonhosted.org/packages/6b/72/a1116d683a6d7ece94590013882515de087edf9ef0e6292aae615a44df73/cryptography-50.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:b42a28c1844fd9de8f3f7d540e36b66f3a9c83fceac7170ebc7a6a19edd9dcae", size = 4734609, upload-time = "2026-07-31T14:23:43.139Z" }, + { url = "https://files.pythonhosted.org/packages/15/37/36a9c479bbe49acea2636c7fd3360d20f7b7e079c300352011c44850b181/cryptography-50.0.0-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:900131fafd8aead39ac7dd3a7e833be754c17a95cfd91221636949fe4eb0aa8a", size = 4356517, upload-time = "2026-07-31T14:23:44.939Z" }, + { url = "https://files.pythonhosted.org/packages/32/98/8a151d64367204cbc63ec65d37502f1d9c53cf4bfc6ec3c532614dbec60d/cryptography-50.0.0-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:07949c449a1abcf60d1ee6e88956d89404c7df3c8258f46589e912988e551987", size = 4724529, upload-time = "2026-07-31T14:23:46.93Z" }, + { url = "https://files.pythonhosted.org/packages/da/3a/f05e32c99d440c9bb891ea0e36c9091891e36be5a9a87ab2ee6ea20729f6/cryptography-50.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:82148ec5bddac30b51a5b3c1945075f896fa022cb93f8e4a01e9f6ee95292c5f", size = 4734462, upload-time = "2026-07-31T14:23:50.861Z" }, + { url = "https://files.pythonhosted.org/packages/ca/dc/bd72b26be8953f80625f63151efd38eee71c76ca6cf591c08ff34615a79e/cryptography-50.0.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1489e263a8048bb8b6a8bac662eb2d402ea5d2b7b4699b72f385f1e2772db105", size = 4852708, upload-time = "2026-07-31T14:23:52.715Z" }, + { url = "https://files.pythonhosted.org/packages/27/20/c930314a2ab476d15dec966ec87e2e9637bb02b06106b12c0396c57bb603/cryptography-50.0.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:7cec5b856506da6defb290f30c9ee687d5f5e8cb0bd3f6459dde43b0b4fa40ef", size = 5004179, upload-time = "2026-07-31T14:23:54.887Z" }, + { url = "https://files.pythonhosted.org/packages/d4/67/91eb047e69c5e845f2f14b8a2e4a1aab0f283cb885531e9e22c8adb176bc/cryptography-50.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:19736989797678c6af1e55cd49055cdbcb55d8f6b5583ac5335f933aba9101dc", size = 4700648, upload-time = "2026-07-31T14:24:00.702Z" }, + { url = "https://files.pythonhosted.org/packages/30/82/85f0f7425c856b9f96459411eb12e74ef72df9caf6f8f15bf23a33ff131f/cryptography-50.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:80b63928fa35083b33966ce1efb70e5b9607181e49dcd1c22c8c005e319f667f", size = 4682442, upload-time = "2026-07-31T14:24:02.538Z" }, + { url = "https://files.pythonhosted.org/packages/1a/28/b555a365adff1cca2fbe7b9e487d68a40de6bc67ff2cb587473eb43de0e7/cryptography-50.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:d58c3db7cd6eed54e6c06744db55456b65ebd7492ddeae9c1e93cfca7aa857d3", size = 4707596, upload-time = "2026-07-31T14:24:04.394Z" }, + { url = "https://files.pythonhosted.org/packages/38/14/6120e5bd7c5aa022ad15424ba4d5c5269d0d9448ed4d55e492ea91e3c1c4/cryptography-50.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:11b74db56cdbe3cdee6e3f6982ecb70334fa10dce99ed58bf7894aaaa3b2a037", size = 4717113, upload-time = "2026-07-31T14:24:08.349Z" }, + { url = "https://files.pythonhosted.org/packages/fa/71/190bf38c3ee2e0f8efc9860ae100c9df4169742eef274b91e7aa1cb133b9/cryptography-50.0.0-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:f59e38625469987d7ef6d495323c55e7db6c212eaf6112267e0d3b565a2e9c9f", size = 4338580, upload-time = "2026-07-31T14:24:10.227Z" }, + { url = "https://files.pythonhosted.org/packages/3a/63/504ccfbbe61fd8aa983f7f146399cdf034c72c2fc55f5b2dfdcdcdb20c99/cryptography-50.0.0-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:ecfed7367f965a0328cfbdd70da860f15441f002f613185668c6e6ebf5a0ac11", size = 4707038, upload-time = "2026-07-31T14:24:12.169Z" }, + { url = "https://files.pythonhosted.org/packages/e5/45/8aae2972c520145377ea3559a605a899bebe227bf070b33cdb445929a9b9/cryptography-50.0.0-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:6ba6a53445bd3cfa809ef3ef5f1589aa6ba08784a1d962bf47d0940e871dab1c", size = 4716439, upload-time = "2026-07-31T14:24:16.415Z" }, + { url = "https://files.pythonhosted.org/packages/7b/20/4fe50b619a48c2525cc46e2dbc1ac490708d704be5d467bdaac6dc955682/cryptography-50.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3f5735ffe4996d28b809371756219f5354864902a3b9e7c0b9ee87041209fc9c", size = 4837383, upload-time = "2026-07-31T14:24:18.553Z" }, + { url = "https://files.pythonhosted.org/packages/92/91/3a31366e183343d3703f8995c095f5734676bd6938118047e50fcf279eb4/cryptography-50.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:1b4a266766514614f8aa60416e71f2fc6e575d36e7bdc90f644fadb2f4b75b95", size = 4985772, upload-time = "2026-07-31T14:24:20.385Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c6/7a6202a534e32103a285b7834a120869557fe198d51d7cfe59754c8bda9c/cryptography-50.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:910e1d2668e7de9648f2bcee30e180db2a6b15c30f887d7c4c93ddf96e3992e3", size = 4745252, upload-time = "2026-07-31T14:24:26.118Z" }, + { url = "https://files.pythonhosted.org/packages/85/4f/0fa8c2f4428198f15d9ff8d63400e27afbf94ce833f6108da1eb3753f945/cryptography-50.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a91296cb61e8df6f86d0c19cc4068228da256bf59bf86049fbd821084565327f", size = 4728939, upload-time = "2026-07-31T14:24:27.994Z" }, + { url = "https://files.pythonhosted.org/packages/d1/63/54dd723490ba2dc09b299682c10b38db38f159728bcaae8c591b8af2f22d/cryptography-50.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:e722f16708d854fe924790e051061f6704a472c3bac347b6fd88033ea8dd0dc5", size = 4748483, upload-time = "2026-07-31T14:24:30.254Z" }, + { url = "https://files.pythonhosted.org/packages/46/c9/f60aed34c013f317f92817b6c171c2d22a78270fa41109bd4b08af26b194/cryptography-50.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:105110f43a471dbd0060b9c9516cb8a6a79233631a04cc2ba16f28323ac6e025", size = 4762647, upload-time = "2026-07-31T14:24:34.599Z" }, + { url = "https://files.pythonhosted.org/packages/be/f3/f9a0173b139372c3a48ed98154b45cc6b9de17c789d5ab552e621c293609/cryptography-50.0.0-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:828743d939e9629bc267b8e2d08d8bb67cd4319c771a33d4b18b22dd8fb7440a", size = 4385197, upload-time = "2026-07-31T14:24:36.647Z" }, + { url = "https://files.pythonhosted.org/packages/d8/36/83bb81f6e569bc38e1e4a7bc80f29b46bb9601920bc455fc8e888f5d5742/cryptography-50.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:2a8183b489dc1f7f80f135780fadc1108f14b31b8a40411c7a5b17425f65f28b", size = 4748095, upload-time = "2026-07-31T14:24:39.493Z" }, + { url = "https://files.pythonhosted.org/packages/9c/f8/d97f9603efda3888187bfdb893f26c41be4735c10631d05d284ee6b047c4/cryptography-50.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:37fdb0d0111f1e2ff07139dfb79f1b49531f8e213c46f1163dd7642979b58c47", size = 4762400, upload-time = "2026-07-31T14:24:43.636Z" }, + { url = "https://files.pythonhosted.org/packages/64/a2/4615c8f7d81a00b1d6e6afe19f694e1543582349fb5f4076f6cb5dc36485/cryptography-50.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c87f62a3d3b9888ed0fdde100ec06aa61ca9cd44bad9057d1dff9a516b5f5bb9", size = 4878208, upload-time = "2026-07-31T14:24:45.522Z" }, + { url = "https://files.pythonhosted.org/packages/d2/1a/efcfb02f91407149a0dacffffab791f7e19bf6385f63b3666dc8b5e5c9c8/cryptography-50.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:65c2c3add92b45fd0709db8594536aea39c2a67af0e27ffcf049c498501140b7", size = 5037050, upload-time = "2026-07-31T14:24:47.697Z" }, + { url = "https://files.pythonhosted.org/packages/01/b6/0b9e125e90f3d2dcf599a218a899cda7326a3158cfa258723f0b398b08f6/cryptography-50.0.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:8eb5e1172eb569ea8a872796576e6a67c276351728b6455d5beb01242b027c6a", size = 4692441, upload-time = "2026-07-31T14:24:53.743Z" }, + { url = "https://files.pythonhosted.org/packages/53/c9/a5151588710785a96d7bc4de27d4cd62f263bbbcb203cfe29df537eb6505/cryptography-50.0.0-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:910d11e1a385c654bf738bf3e6b8e6ed5de0f5610fcae2be9e5b398d8081d20e", size = 4699810, upload-time = "2026-07-31T14:24:55.746Z" }, + { url = "https://files.pythonhosted.org/packages/c7/1a/15b92b25eb6ce3089cd49377ae990a0f3ad485a510f968aed1f19dbdcdf2/cryptography-50.0.0-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:62598a8a57f815db4c6259a4e97d857dab56697e7de8e8ab02352ab74da1995d", size = 4691924, upload-time = "2026-07-31T14:24:58.082Z" }, + { url = "https://files.pythonhosted.org/packages/62/15/219075012ab13e8905f3cd572204f4acb4b111df787104346b9bc0cea789/cryptography-50.0.0-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:07479a1cb08219ab719147e742e76090c9c773321959bb94946fffdd397a6437", size = 4699593, upload-time = "2026-07-31T14:24:59.951Z" }, +] + +[[package]] +name = "docutils" +version = "0.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/39/a4/5180d9afc57e8fca05601dd652bdff19604c218814037fe90ffc7625a50a/docutils-0.23.tar.gz", hash = "sha256:746f5060322511280a1e50eb76846ed6bf2342984b2ac04dc42caa1a8d78799e", size = 2303823, upload-time = "2026-05-27T17:41:06.934Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/91/30151a39f7570f448ed84529390628a651d7f27c87d73c9b887f8189695e/docutils-0.23-py3-none-any.whl", hash = "sha256:25d013af9bf23bc1c7b2b093dff4208166c53a94786c9e447808335ef1185fea", size = 634701, upload-time = "2026-05-27T17:40:58.442Z" }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + +[[package]] +name = "id" +version = "1.6.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/04/c2156091427636080787aac190019dc64096e56a23b7364d3c1764ee3a06/id-1.6.1.tar.gz", hash = "sha256:d0732d624fb46fd4e7bc4e5152f00214450953b9e772c182c1c22964def1a069", size = 18088, upload-time = "2026-02-04T16:19:41.26Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/77/de194443bf38daed9452139e960c632b0ef9f9a5dd9ce605fdf18ca9f1b1/id-1.6.1-py3-none-any.whl", hash = "sha256:f5ec41ed2629a508f5d0988eda142e190c9c6da971100612c4de9ad9f9b237ca", size = 14689, upload-time = "2026-02-04T16:19:40.051Z" }, +] + +[[package]] +name = "idna" +version = "3.18" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/63/9496c57188a2ee585e0f1db071d75089a11e98aa86eb99d9d7618fc1edce/idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848", size = 196711, upload-time = "2026-06-02T14:34:07.794Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" }, +] + +[[package]] +name = "importlib-metadata" +version = "9.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/01/15bb152d77b21318514a96f43af312635eb2500c96b55398d020c93d86ea/importlib_metadata-9.0.0.tar.gz", hash = "sha256:a4f57ab599e6a2e3016d7595cfd72eb4661a5106e787a95bcc90c7105b831efc", size = 56405, upload-time = "2026-03-20T06:42:56.999Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/3d/2d244233ac4f76e38533cfcb2991c9eb4c7bf688ae0a036d30725b8faafe/importlib_metadata-9.0.0-py3-none-any.whl", hash = "sha256:2d21d1cc5a017bd0559e36150c21c830ab1dc304dedd1b7ea85d20f45ef3edd7", size = 27789, upload-time = "2026-03-20T06:42:55.665Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "jaraco-classes" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780, upload-time = "2024-03-31T07:27:36.643Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/66/b15ce62552d84bbfcec9a4873ab79d993a1dd4edb922cbfccae192bd5b5f/jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790", size = 6777, upload-time = "2024-03-31T07:27:34.792Z" }, +] + +[[package]] +name = "jaraco-context" +version = "6.1.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "backports-tarfile", marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/50/4763cd07e722bb6285316d390a164bc7e479db9d90daa769f22578f698b4/jaraco_context-6.1.2.tar.gz", hash = "sha256:f1a6c9d391e661cc5b8d39861ff077a7dc24dc23833ccee564b234b81c82dfe3", size = 16801, upload-time = "2026-03-20T22:13:33.922Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/58/bc8954bda5fcda97bd7c19be11b85f91973d67a706ed4a3aec33e7de22db/jaraco_context-6.1.2-py3-none-any.whl", hash = "sha256:bf8150b79a2d5d91ae48629d8b427a8f7ba0e1097dd6202a9059f29a36379535", size = 7871, upload-time = "2026-03-20T22:13:32.808Z" }, +] + +[[package]] +name = "jaraco-functools" +version = "4.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6c/1f/c23395957d41ccf27c4e535c3d334c4051e5395b3752057ba4cbaec35c56/jaraco_functools-4.6.0.tar.gz", hash = "sha256:880c577ec9720b3a052d5bc611fb9f2269b3d87902ef42440df443b88e443280", size = 20837, upload-time = "2026-07-14T01:28:02.544Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/36/ecc85bc96c273dc8a11273ed4782272975e6338d4a3e9228621175edf0e3/jaraco_functools-4.6.0-py3-none-any.whl", hash = "sha256:99e3dc0060c5cbe8fcd1cdb36258e2a65ca40f1566b2033b12abb1bb44dd3c30", size = 11677, upload-time = "2026-07-14T01:28:01.59Z" }, +] + +[[package]] +name = "jeepney" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/6f/357efd7602486741aa73ffc0617fb310a29b588ed0fd69c2399acbb85b0c/jeepney-0.9.0.tar.gz", hash = "sha256:cf0e9e845622b81e4a28df94c40345400256ec608d0e55bb8a3feaa9163f5732", size = 106758, upload-time = "2025-02-27T18:51:01.684Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010, upload-time = "2025-02-27T18:51:00.104Z" }, +] + +[[package]] +name = "keyring" +version = "25.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata", marker = "python_full_version < '3.12'" }, + { name = "jaraco-classes" }, + { name = "jaraco-context" }, + { name = "jaraco-functools" }, + { name = "jeepney", marker = "sys_platform == 'linux'" }, + { name = "pywin32-ctypes", marker = "sys_platform == 'win32'" }, + { name = "secretstorage", marker = "sys_platform == 'linux'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160, upload-time = "2025-11-16T16:26:08.402Z" }, +] + +[[package]] +name = "librt" +version = "0.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/dc/2f/3908645ddddab7120b46295e541ead308109fa48dbec7d67d7a778870d60/librt-0.13.0.tar.gz", hash = "sha256:1d2a610c14ac0d0750ee0a3ab8548e83155258387891caaca04def4bf7289781", size = 211402, upload-time = "2026-07-08T12:26:29.834Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/89/2f/ec5241c38e7fa0fe6c26bfc450e78b9489a6c3c08b394b85d2c10e506975/librt-0.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:34e47058fcc69a313293d6dee94216a4f30c929ae6f2476e58c5ba635aa639d5", size = 148654, upload-time = "2026-07-08T12:24:30.622Z" }, + { url = "https://files.pythonhosted.org/packages/a5/1a/d651e18d3ee7aa2879322368c4f278bb7ecaa6b90caadfdec4ebfa8389f3/librt-0.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dbdd5b6509d0c2a8fe72cf494c299a61dbd58142a90a4190664ae159e4a7b547", size = 153537, upload-time = "2026-07-08T12:24:31.773Z" }, + { url = "https://files.pythonhosted.org/packages/45/18/10bff2122577246009d9619b6569596daf69b7648812f997ca9ca0426f60/librt-0.13.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e56ea4ee4df77585a6b5c138f6538680886024fa559f5b55bd14b12e98e67b2", size = 494336, upload-time = "2026-07-08T12:24:33.079Z" }, + { url = "https://files.pythonhosted.org/packages/67/69/87dfee871b852970f137fdeae8e2ca356c5ab38e6f21d2a3299535fc3159/librt-0.13.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:f1f9cc4d09a46d9cb3c2063ae100629d3f52a6517c3c08c2f4c9828261883929", size = 485393, upload-time = "2026-07-08T12:24:34.324Z" }, + { url = "https://files.pythonhosted.org/packages/e9/d5/625447a8c0441ff5f15f4ac5e1d323fb9d4d256ebfde7a3c8e003f646057/librt-0.13.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f125f5d46b20f89dc5587a55cc416b4ba2a5b2ffda36d048ee120e17598a653a", size = 515382, upload-time = "2026-07-08T12:24:35.575Z" }, + { url = "https://files.pythonhosted.org/packages/8d/d8/1c8c49ea04235960426444deece9092a6b3a9587a850a81bae2335317411/librt-0.13.0-cp310-cp310-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:2608d3b39f9e0b4a66a130d9150c615cba40a5090d25eeeaa225e0e46de8c0ac", size = 509483, upload-time = "2026-07-08T12:24:36.923Z" }, + { url = "https://files.pythonhosted.org/packages/6f/65/f1760fc48050e215201a03506c32b7270159088d01f64557b53e39e74a45/librt-0.13.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:9fd35e95ab5e45c3901d37110263c7db85a961110f5460588fe37f8c131f88a7", size = 532503, upload-time = "2026-07-08T12:24:38.203Z" }, + { url = "https://files.pythonhosted.org/packages/18/1b/793e281dcf494879eff99f642b63ebc9c7c58694a1c2d1e93362a22c7041/librt-0.13.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:5f31b0aa13c9b04370d4da6be1ab7779776b3a075cceb6747a39a4be85fe1e40", size = 537027, upload-time = "2026-07-08T12:24:39.34Z" }, + { url = "https://files.pythonhosted.org/packages/69/45/0801bbb40c9eea795d3dd3ce91c4c5f3fe7d42d23ec4be3e8cb283bcc754/librt-0.13.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:0b795f5fc70fbbb787ceaf79bb3a0d627bcc33c53de51741755263ec406b775a", size = 517100, upload-time = "2026-07-08T12:24:40.907Z" }, + { url = "https://files.pythonhosted.org/packages/a1/6c/eb5f514f8e29d4924bc0ff4601dd7b4175557e182e7c0721e84cffa39b8a/librt-0.13.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:36b306a623aaad96fe4b378692b54f9c0789fccd833b9851753d5fbf6138cfde", size = 558653, upload-time = "2026-07-08T12:24:42.359Z" }, + { url = "https://files.pythonhosted.org/packages/b4/bf/f140100d1b59fe87ff40b5ecbb4e27924335b189a784e230ee465452f6c2/librt-0.13.0-cp310-cp310-win32.whl", hash = "sha256:a3762e75fcac8c9e4dacaaf438bffd9003e2ca2c531b756f3c0035deefa674c8", size = 104402, upload-time = "2026-07-08T12:24:43.668Z" }, + { url = "https://files.pythonhosted.org/packages/22/7c/57e40fef7cfb61869341cb28bdcefe8a950bebcbecca74a397bae14dce4a/librt-0.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:d63bae12a8aeb51380be3438e4dc4bd27354d0f8e19166b2f44e3e94d6f552dc", size = 125002, upload-time = "2026-07-08T12:24:44.793Z" }, + { url = "https://files.pythonhosted.org/packages/89/25/a6498964cfeec270c468cffdc118f69c29b412593610d55fa1327ca51ff4/librt-0.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1b5a7bbff495baedbd9b916c367d66854008f8f3b575908ded477c499dc60082", size = 148029, upload-time = "2026-07-08T12:24:45.961Z" }, + { url = "https://files.pythonhosted.org/packages/78/59/dc86d1bffd8e0c2818bace29d9f7783cfbb8e0673bf3673b5bbd5bbe0420/librt-0.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:34bc7938b9fdf14fe32a406c19c71faf894c5cee7e7474bd0be2f17200b82d14", size = 153036, upload-time = "2026-07-08T12:24:47.257Z" }, + { url = "https://files.pythonhosted.org/packages/29/3f/b923826660f02f286186cd9303d52bb05ced0a13708edc104dc8480920e3/librt-0.13.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f40e56b61b41be5f7dec938cfeffd660668cf4b5e72c78e7bd671d66b7bc2c79", size = 493062, upload-time = "2026-07-08T12:24:48.483Z" }, + { url = "https://files.pythonhosted.org/packages/88/87/6c0980a9c9b1302cb68d108906697b89eceb55889bb1dcf77c109aa56ca5/librt-0.13.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:9c5d02b89de5acd0379a51ec44a89476fb03df6145442e1c8ecd6bee2f91b176", size = 485510, upload-time = "2026-07-08T12:24:49.727Z" }, + { url = "https://files.pythonhosted.org/packages/32/81/795ae3b9df5dd94079fb807e38191855e023e8c6249014ae6bc3f0d9a490/librt-0.13.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7db9a3ff32ef5f7d1703d93831a3316cdf0b537de6a1cc03cc8fdd09b9194e89", size = 515909, upload-time = "2026-07-08T12:24:51.135Z" }, + { url = "https://files.pythonhosted.org/packages/20/e5/182de15abce8907108a6fdb41487de65beb5099b74dc5841b19b099168db/librt-0.13.0-cp311-cp311-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3dbb2a31882456cadc7053378e81ad7ed7693db4ac9f98ab5f81ef034aa8ec9f", size = 508620, upload-time = "2026-07-08T12:24:52.358Z" }, + { url = "https://files.pythonhosted.org/packages/32/03/33978d32db76e1f66377e8f78e42a2ca3c162143331677d1f50bbad36cfb/librt-0.13.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c6014e3c80f9c1fe268ef8b0e0ef113bac672cc032f2f93866e7ddad4f3e663d", size = 530363, upload-time = "2026-07-08T12:24:53.503Z" }, + { url = "https://files.pythonhosted.org/packages/e6/f5/b291fbd2d00f7d8287bcbf67b5aa0c6afed4bc26cef23e079629c47a2c04/librt-0.13.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:091b60a4d2174fc1ec5c34cdc0b72efb6224753d76b7da61ebeab7a191aec8bd", size = 534209, upload-time = "2026-07-08T12:24:55.138Z" }, + { url = "https://files.pythonhosted.org/packages/3e/03/6f41f17939d191bc21609f220da8509316bc62797f078545fe83be522e78/librt-0.13.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:66cb1138f384a191a6d75f986064841fcfdc0cea98f7bd9c9ab9b38049917588", size = 514254, upload-time = "2026-07-08T12:24:56.276Z" }, + { url = "https://files.pythonhosted.org/packages/af/c2/2e4befa5410a7443019c14abccc94ff619797171f6b72013635fb87f31d7/librt-0.13.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:17221a7569f8f292aa0014226e48aa25b8c2b08da18088cd230953d0ea0f9cd1", size = 557611, upload-time = "2026-07-08T12:24:57.561Z" }, + { url = "https://files.pythonhosted.org/packages/ab/54/8b69f81448417adbc040a2185f4e2eece1e1994b7dcfaeed4662b30f98a5/librt-0.13.0-cp311-cp311-win32.whl", hash = "sha256:fc67741da44c6eaa90e01eafb586bbba9b51eb5b6ed381ee6f5ae72eb3316d21", size = 104906, upload-time = "2026-07-08T12:24:58.806Z" }, + { url = "https://files.pythonhosted.org/packages/76/5a/f4aaf37b50f2fde12c8c663b83fdd499cdc24f957f19543d7414bfcc9e25/librt-0.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:cc99dfb62b23c9207c33d0be8a2e2af7a42e21e6ea388b380a0c948c7b88953b", size = 125852, upload-time = "2026-07-08T12:25:00.065Z" }, + { url = "https://files.pythonhosted.org/packages/f2/99/bf1820e6feeabc2f218c24450ec0c995d6a91e8ba0fd3caf042c9e8adb2a/librt-0.13.0-cp311-cp311-win_arm64.whl", hash = "sha256:40ccd13c252d3fe473ffc8a57be7565abc8b64cf1b108344c859d5164f7f3e0c", size = 111832, upload-time = "2026-07-08T12:25:01.148Z" }, + { url = "https://files.pythonhosted.org/packages/f0/f4/b2933ddae222dac338476abb872641169a5cfed2c2bb5444a5b07b32b0c3/librt-0.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:30536798f4504c0fad0885b1d371b0539abb081e4570c9d7c641cb51141b49f0", size = 150990, upload-time = "2026-07-08T12:25:02.42Z" }, + { url = "https://files.pythonhosted.org/packages/90/ef/db98f744ca50e6efc9c95c70ee49b77aefac31f6a3fc7c83754a42d6a74f/librt-0.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:93d24ebb82aa4420b1409c389e7857bc35bd0b668007ac8172427d5c73cc8cc5", size = 155238, upload-time = "2026-07-08T12:25:03.681Z" }, + { url = "https://files.pythonhosted.org/packages/03/e7/a197e7bc72baf2c61ce7fdc6906a5054dc05bd8da0819aa894e4857bf87e/librt-0.13.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cb8a1adce42d8b75485a5d56a9623a50bcab995b6079f1dac59fc44034dd93d9", size = 503073, upload-time = "2026-07-08T12:25:05.049Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e7/7887712e27da7c1ab80fcabb1de6eb24243964f6557cae530d4b70706dbd/librt-0.13.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:0763ca2ab66058174f9dee426dc64f5e0a89c24a7df8d3fe3f1836c04e25de4b", size = 496528, upload-time = "2026-07-08T12:25:06.26Z" }, + { url = "https://files.pythonhosted.org/packages/94/f0/f2283385bb6b950b26a1410f4ce51ec27231e0b3a4b925c46366d218b198/librt-0.13.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b222493da6e7b6199db9bd79502436cf5a27da3c1f7fa83c7e285444fc93fd03", size = 531786, upload-time = "2026-07-08T12:25:07.658Z" }, + { url = "https://files.pythonhosted.org/packages/36/11/69ac3b54766ffba5fd7e5acebfb048d66dbe1f9f2d14516c2b3edc59cf87/librt-0.13.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fadc63331f4388c3dc90090448f682a7e9feafc11481391c1e94f2f907a3976e", size = 524393, upload-time = "2026-07-08T12:25:09.121Z" }, + { url = "https://files.pythonhosted.org/packages/61/5f/d72f95fd444a926a3c14b4e24979474116988dd57a45be242077c45d3c22/librt-0.13.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:70d9c62a4cffd9f23396cd5ef93fc5d11b31596b9b7d6306074abe3d5fcf09bd", size = 543026, upload-time = "2026-07-08T12:25:10.459Z" }, + { url = "https://files.pythonhosted.org/packages/c4/08/dcd9993ad192737a004ba263d549f8ea605b326b952e7d6205c7d4170b76/librt-0.13.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:66c0e7e6b02a155576df2c77ec933a70b72da726e248c494abf690923e624348", size = 546829, upload-time = "2026-07-08T12:25:11.716Z" }, + { url = "https://files.pythonhosted.org/packages/96/d5/6d9bb2f54e4109a956b7128836529653eb9d740f784bc47ed10a02c1000e/librt-0.13.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:ac04bcd3328eb91d99dfedf6a60d9c1f15d3434e6f6daf922f0420f7d90b85c7", size = 535700, upload-time = "2026-07-08T12:25:13.144Z" }, + { url = "https://files.pythonhosted.org/packages/8c/f2/10946922503858a359492fa27f13e86228bde702116a740ac7b3cd185f24/librt-0.13.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:db327e7271e653c32040b85ae6188059c924b57d7e1e29f935523fa017cd4e82", size = 573566, upload-time = "2026-07-08T12:25:14.336Z" }, + { url = "https://files.pythonhosted.org/packages/48/a8/94f00e3c99479a18088af3685ea016c42f3c7d5d1964d8dbb40c08d7f1aa/librt-0.13.0-cp312-cp312-win32.whl", hash = "sha256:860bd1d8ba48456ce08feaf8d343a8aaeb2fa086f2bcaa2a923fa3f7a3ff9aa3", size = 106099, upload-time = "2026-07-08T12:25:16.159Z" }, + { url = "https://files.pythonhosted.org/packages/c9/7b/2da9c74c1ed25a89cc4e1c8e007ea2eb4a0f1fafa3e70d757fe3242c5c5c/librt-0.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:e54a315caf843c8d77e388cadc56ea9ded569935ee2d2347d7ea94992e5aa6fa", size = 126934, upload-time = "2026-07-08T12:25:17.275Z" }, + { url = "https://files.pythonhosted.org/packages/d0/65/aead61bbf3b5358593f9d4779d2a0e88eaf6ec191a6342dde36dd1df6371/librt-0.13.0-cp312-cp312-win_arm64.whl", hash = "sha256:c718e99a0992127af84385378460db624103b559ab260435abcfe77a4e4ed1c1", size = 112236, upload-time = "2026-07-08T12:25:18.425Z" }, + { url = "https://files.pythonhosted.org/packages/67/3b/18e7b63255297a2bdc9c25c8d6d4ca8eca9f63aceb1252c0f7427ac7099e/librt-0.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a468951af16155824e88bdd8326ebe5bdb371f3ec0ac04642994b98201d914f3", size = 151027, upload-time = "2026-07-08T12:25:19.638Z" }, + { url = "https://files.pythonhosted.org/packages/4d/68/e2248452c00d1a03b45fee1752cdc8f790a476efd2402b75181da88a9e61/librt-0.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ae01d8512cc17079e53425635327dbf3f7ff57a42c00dec348bf79791c56444c", size = 155152, upload-time = "2026-07-08T12:25:20.851Z" }, + { url = "https://files.pythonhosted.org/packages/0e/16/52b1c99bf19057a062aac39c900cbb81499f6f75d6c537c14463d247ba78/librt-0.13.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:32c26893cd085c1efe83219e78d866da23fb20a066101b8f68210004361d224c", size = 502499, upload-time = "2026-07-08T12:25:22.055Z" }, + { url = "https://files.pythonhosted.org/packages/9f/54/b811151805c795f55e0dedee6ec687b75f9982a8105d240ea3910737a77b/librt-0.13.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5929da1981a46bcf4b28b1b9499905f0ff58e2419da402a048234e9783acbc4b", size = 496108, upload-time = "2026-07-08T12:25:23.296Z" }, + { url = "https://files.pythonhosted.org/packages/8f/f8/094d6b2bd93f3fdaa54db54cc788c4a365333bddad65ab02e04da0b1d004/librt-0.13.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:94b85d664d777bab6c0d709416cb42938251fda9e221b79e3a2215d85df5f4f9", size = 531576, upload-time = "2026-07-08T12:25:24.648Z" }, + { url = "https://files.pythonhosted.org/packages/2e/40/541733d5755824f968f7ec39d78ffbd75d145964157ae5e69a09ec6d7326/librt-0.13.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:531b2df3e9fe96b1fcf73a6d165921e4656be5f58d631d384ebce344298368db", size = 524390, upload-time = "2026-07-08T12:25:25.898Z" }, + { url = "https://files.pythonhosted.org/packages/c6/b5/255673cfdbf5ba663339d36cd863c897289ab4337577e19f9405ce059f36/librt-0.13.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:109b84a9edf69ad89dc1f66358659e14a031baca95e3e5b0060bd903ede8efd6", size = 543053, upload-time = "2026-07-08T12:25:27.436Z" }, + { url = "https://files.pythonhosted.org/packages/9e/11/ab5005e9c9850710f21e354201bf090646349d3fabf5f951eaf70235729e/librt-0.13.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:1304368a3e7ffc3e9db986796cc5326fdb5943a3567ecc137cff318e4240c0e7", size = 546387, upload-time = "2026-07-08T12:25:28.65Z" }, + { url = "https://files.pythonhosted.org/packages/a2/04/a5d7ce1d1df1afd15ca283dcdf7530ac073e12d69ae8c40879dda96f7868/librt-0.13.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e4f9b472e7d308d94b62c801982065661158c6ed02790d6c7ddb4337cea0f9c1", size = 535970, upload-time = "2026-07-08T12:25:30.171Z" }, + { url = "https://files.pythonhosted.org/packages/5a/76/927e267a6daa290174ac281b23c9804c8829b042ade9c6f24a065f540958/librt-0.13.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9f836c37478f167a81200d8c8b2c920a22224564bed2c23d7aeec760965c367a", size = 573582, upload-time = "2026-07-08T12:25:31.507Z" }, + { url = "https://files.pythonhosted.org/packages/10/24/b6c5213efe39c19f9e13605644d0cf063b4ddaa33ac2e45b088e23a70e2e/librt-0.13.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:4000d961ff9598ac6ea603c6c836a5ed49bc205ade5fc378b998dfe1e2c36628", size = 82189, upload-time = "2026-07-08T12:25:32.675Z" }, + { url = "https://files.pythonhosted.org/packages/4c/00/d29736be177a906ac0b84a5b04b4fbfa22c776dc2f366de4172b0f968c08/librt-0.13.0-cp313-cp313-win32.whl", hash = "sha256:79e44cff71750d299d61a678e49995b0d5935a9cda238c2574daeca3ba536927", size = 106193, upload-time = "2026-07-08T12:25:33.692Z" }, + { url = "https://files.pythonhosted.org/packages/c8/ac/aff6fb45393cb8912f39dfb156ef6b2d1cadb207ff465fc8f66141054be8/librt-0.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:54dab44a847d5ad1acd05c8a83fe518ae685516ecf4d3f7cc6e3df2a66767650", size = 126962, upload-time = "2026-07-08T12:25:34.769Z" }, + { url = "https://files.pythonhosted.org/packages/d9/3a/d68cb2b334d53fd30fac81d3a489ce4ba0d9506f4df43fcf676b68352b19/librt-0.13.0-cp313-cp313-win_arm64.whl", hash = "sha256:d4cb6fbfdf874340ab5e51450753c0f817b6958a3621125ee695bbc3de866566", size = 112127, upload-time = "2026-07-08T12:25:35.981Z" }, + { url = "https://files.pythonhosted.org/packages/7b/66/f49ae0d592bd45b6941e9a8bafcb6a87cddcd501ee7874707e767f01b585/librt-0.13.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:25218d94b1d2cbc0ba1d8a3f9dc9af578d9646e5ed16443a70cde1dfdcce6d71", size = 149818, upload-time = "2026-07-08T12:25:37.203Z" }, + { url = "https://files.pythonhosted.org/packages/3d/50/51c76d74014d04fb95b6506d286808984b78a2f7a41039094e6b2194ac48/librt-0.13.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f26629539d4893c2957a16c41bb058e1e135c1f150f6a2e25ed047f64cf3f5c6", size = 154071, upload-time = "2026-07-08T12:25:39.399Z" }, + { url = "https://files.pythonhosted.org/packages/b8/fe/f19b0f5f82d5a1f2da736586bc840abd00ce07d6388136ae80b7333883fc/librt-0.13.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a4517d47b2b8af26975a406fba7d314de9696d864252e0257c6ea90238cfe27f", size = 494168, upload-time = "2026-07-08T12:25:40.641Z" }, + { url = "https://files.pythonhosted.org/packages/94/bc/b8550c75775127fd31a5f20e8775997f7b527ad661fc8ddccd7497c064f7/librt-0.13.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:f19e181de5b3a1148bb3420b8c4b0b0ea0fce6950099724ad151d6cea5acc180", size = 491054, upload-time = "2026-07-08T12:25:41.905Z" }, + { url = "https://files.pythonhosted.org/packages/30/14/4d0204867623df3f33f86efd3d3692ba5e01321443f4d6eab35a22697618/librt-0.13.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22034924f5b42d5a56371cf271771bfeaabf235a7a8b6264bef2d20013f786c6", size = 523006, upload-time = "2026-07-08T12:25:43.327Z" }, + { url = "https://files.pythonhosted.org/packages/19/0a/c45fc9a260934696bace1ac5df1e148ac92bd71767aee3bf7cd7a4534f4c/librt-0.13.0-cp314-cp314-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7897db4e95e22468bdda33d8e012ceacd0182abf001e6389d763f0def6286b9", size = 515058, upload-time = "2026-07-08T12:25:44.541Z" }, + { url = "https://files.pythonhosted.org/packages/13/0a/50c5ce45b326854ef8fa6ae4c36cf5142e5c55315eaf9e51d0ae73ac4da3/librt-0.13.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1ce61b3746545029d4f5c17d6bd74b676254ad98433086c846ffb5e8fa73f007", size = 534025, upload-time = "2026-07-08T12:25:45.825Z" }, + { url = "https://files.pythonhosted.org/packages/89/2d/08c413c8f93fc13b8103624fce38e5caa86cd08cbbc8465870ab287af54b/librt-0.13.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:46c330e82565962c761dbce7941be2cff7db674ee807455a8d0cadc5f9b759b0", size = 540557, upload-time = "2026-07-08T12:25:47.059Z" }, + { url = "https://files.pythonhosted.org/packages/b3/c1/93af71fb4a364952210051811dd4e40174e79656b050c89cacac18af3330/librt-0.13.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:375f5af8f99cbaa99dd293af986e3d57caabc9ba81a5d3f021603764854197a1", size = 523201, upload-time = "2026-07-08T12:25:48.392Z" }, + { url = "https://files.pythonhosted.org/packages/c1/6e/9766f07b676a4889d9f8bc2864e9ba5fff165653143ef4dda7df6aa34d16/librt-0.13.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9320d34c3376ae204b2cd176e8d4883a013934e0aef822f1aed9c536490c275d", size = 565740, upload-time = "2026-07-08T12:25:49.678Z" }, + { url = "https://files.pythonhosted.org/packages/a2/1e/664e3472ce2b6e10e9b83f29d4a36eb982ff6b5a169ae7567bba3a4c4ff5/librt-0.13.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:9af313c66157a69dc69ea0059a66961692250e0dc95af9c385a48ffb770a0d16", size = 81611, upload-time = "2026-07-08T12:25:50.857Z" }, + { url = "https://files.pythonhosted.org/packages/2f/d4/8582a4d65e2234673685e07309d02c230b28a85724eb0acbf13f019b7f6e/librt-0.13.0-cp314-cp314-win32.whl", hash = "sha256:f2a7253458e34f33543551394ae4fe104b497ec2a65ac266074de64c1df82e37", size = 100106, upload-time = "2026-07-08T12:25:52.03Z" }, + { url = "https://files.pythonhosted.org/packages/63/ce/0cb99efe6086b46cd985dc26672166fae312a239690e75871f7fafbd3fc5/librt-0.13.0-cp314-cp314-win_amd64.whl", hash = "sha256:a3dfe4edf10e8ed7e55b026a8bfc2c2a8704218b659cd4bffdf604fab966dc39", size = 121209, upload-time = "2026-07-08T12:25:53.166Z" }, + { url = "https://files.pythonhosted.org/packages/26/85/4f3ccb083a3c9b0d42e223acdb3c3f507953324a59cdcab4826e8e2e3b89/librt-0.13.0-cp314-cp314-win_arm64.whl", hash = "sha256:68a5faee4bba381cb93b5961f684a514cf0053cb92308ff9c792c2fea0b174c6", size = 106404, upload-time = "2026-07-08T12:25:54.253Z" }, + { url = "https://files.pythonhosted.org/packages/b2/77/333191499538c8e8189de7a4cba8e6f49ee949fd6d6e6324b21fd1522466/librt-0.13.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:a38fb81d8376dfa2f8963b265fec07637802b0d01e2a127c19c66cb070fb24f5", size = 159231, upload-time = "2026-07-08T12:25:55.432Z" }, + { url = "https://files.pythonhosted.org/packages/7a/9e/2aa83758f22c278b837a1d8025898434ce2b8bff36678d5330ecaef56dff/librt-0.13.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d4c8d9bd5abce34b2e75edb3bf37ab0f34e49b1f915a40ae8468eb7c85bc5b46", size = 161300, upload-time = "2026-07-08T12:25:56.585Z" }, + { url = "https://files.pythonhosted.org/packages/bb/c0/86791e936553ca763d6b3c2fb4d31d596cd00e14fa631c283a40ba01559a/librt-0.13.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:387e2f1d27e89bffe0d3f520f0da0662c973fd607ca16c1808f8a5085419485e", size = 582056, upload-time = "2026-07-08T12:25:58.144Z" }, + { url = "https://files.pythonhosted.org/packages/a8/d3/a9ec15984a185e000c4d2a16ba28bd623124ad4c38a10974c7ff78e3a893/librt-0.13.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:4f6db193d2e5e0ed60359b9a5a682cd67205d0d3b1e459a867dd4b5c4e7eaa7a", size = 562758, upload-time = "2026-07-08T12:25:59.544Z" }, + { url = "https://files.pythonhosted.org/packages/3c/af/dbe36b78b19c06a55097f99305e4ea9458e2273e6ae16a3cbecaad7ee978/librt-0.13.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0d38604854e8d22faadf683ec6c02bb0f886e2ba56ef981a1c36ee275f21ea22", size = 602095, upload-time = "2026-07-08T12:26:00.991Z" }, + { url = "https://files.pythonhosted.org/packages/2a/a8/2966891b4dd2830f5203fbee92ac2c4947653a2390ba73dfa44244fad025/librt-0.13.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:371f7ce73026815dafd51c50ce38416e91428b28c4b2ec97cd39271164b0045c", size = 593452, upload-time = "2026-07-08T12:26:02.352Z" }, + { url = "https://files.pythonhosted.org/packages/61/f5/4df8bfc8405ecf8c0d525b4d69636f694bdd8620b313ec8b76e54a5926cc/librt-0.13.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3aaedf52171bee90860704c560bc798fe83b76247df47568e0197e9b13c735a0", size = 623729, upload-time = "2026-07-08T12:26:04.294Z" }, + { url = "https://files.pythonhosted.org/packages/d6/13/9ac202dffc8db06f75d06c08c2f9f6ff054be67d21272dcc078fa1cc0c57/librt-0.13.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:96bad8725a4f196a798366c25ce075d1f7543a4ec045ffc13e6a7ec095cdab04", size = 617077, upload-time = "2026-07-08T12:26:05.845Z" }, + { url = "https://files.pythonhosted.org/packages/6e/f0/ebe38610716aee5cb28efd95089bb90192096179802779381e1c5dcf239c/librt-0.13.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:6bf6a559ffe4a93bbea6cf31ddf01a7fd9ba342ef51f27beb178e318b74acd61", size = 599561, upload-time = "2026-07-08T12:26:07.21Z" }, + { url = "https://files.pythonhosted.org/packages/4f/5c/c2e72e236fff7abc716d5b1753b8b8cd3ea85ac46fe17d2e7c51d4e1c723/librt-0.13.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:301067672387902c55f94b51d5022304b36c966ea9fe1f21caab99a9bef487c9", size = 645511, upload-time = "2026-07-08T12:26:08.562Z" }, + { url = "https://files.pythonhosted.org/packages/0c/99/6203ce619dee940d6bfbe099ec3fe4be00a68e9d60f70abf906cf124fe66/librt-0.13.0-cp314-cp314t-win32.whl", hash = "sha256:5fdcf34f86de8fb66d7dc7589f96ba91c4aa46671200d400e6fd6f109a483f18", size = 104357, upload-time = "2026-07-08T12:26:09.828Z" }, + { url = "https://files.pythonhosted.org/packages/52/dd/843b6314087c41657c7036d7914d8f294bdf9b580aa8513ea0588c8e9a3d/librt-0.13.0-cp314-cp314t-win_amd64.whl", hash = "sha256:260c33e92263fa629b4f6d3c51967a1c2158fe6c33237aaa3ebeac586b085259", size = 126998, upload-time = "2026-07-08T12:26:10.975Z" }, + { url = "https://files.pythonhosted.org/packages/5f/5d/3dcec2884ba1b0806d1408612555c38dd5d68e90156b59f75f6e36435c3a/librt-0.13.0-cp314-cp314t-win_arm64.whl", hash = "sha256:2f281549a4c52ac7bb97997f14353f8bd0e53a34ca0dad1c905cfd0b4a58ae99", size = 110771, upload-time = "2026-07-08T12:26:12.303Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "4.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "modelparams" +version = "0.0.1" +source = { editable = "." } +dependencies = [ + { name = "pydantic" }, + { name = "typing-extensions" }, +] + +[package.optional-dependencies] +dev = [ + { name = "build" }, + { name = "mypy" }, + { name = "pytest" }, + { name = "ruff" }, + { name = "twine" }, +] + +[package.metadata] +requires-dist = [ + { name = "build", marker = "extra == 'dev'", specifier = ">=1.2" }, + { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.13" }, + { name = "pydantic", specifier = ">=2.10,<3" }, + { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.3" }, + { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.9" }, + { name = "twine", marker = "extra == 'dev'", specifier = ">=6.0" }, + { name = "typing-extensions", specifier = ">=4.12" }, +] +provides-extras = ["dev"] + +[[package]] +name = "more-itertools" +version = "11.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/de/1d/f4da6f02cdffe04d6362210b807146a26044c88d839208aec273bb0d9184/more_itertools-11.1.0.tar.gz", hash = "sha256:48e8f4d9e7e5878571ecf6f2b4e57634f93cd474cc8cfbd2376f2d11b396e30d", size = 145772, upload-time = "2026-05-22T14:14:29.909Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/3d/1087453384dbde46a8c7f9356eead2c58be8a7bf156bca40243377c85715/more_itertools-11.1.0-py3-none-any.whl", hash = "sha256:4b65538ae22f6fed0ce4874efd317463a7489796a0939fa66824dd542125a192", size = 72226, upload-time = "2026-05-22T14:14:28.824Z" }, +] + +[[package]] +name = "mypy" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ast-serialize" }, + { name = "librt", marker = "platform_python_implementation != 'PyPy'" }, + { name = "mypy-extensions" }, + { name = "pathspec" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/12/af/4e516a05d3ca2eb9283e9ec45b2c02225c1514dd6da49fd3c9eaa6639370/mypy-2.3.0.tar.gz", hash = "sha256:465965d41cd9a2726694e983e8ce7113259327bec798115d1e1dfa2a52fb666e", size = 3988104, upload-time = "2026-07-13T11:34:53.387Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a9/09/f2f5f45dae0c9a0891e4751a73312730e009395102e5d72a22a976cca41f/mypy-2.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1fa8d916ac3b705af733c4c1e6c9ebe38fd0d52beb15b105c3e8355b55e6ecdc", size = 14927774, upload-time = "2026-07-13T11:28:38.224Z" }, + { url = "https://files.pythonhosted.org/packages/56/b9/345367effd3a6877275a94d481614bfca983f45e028c6290e2cc54603811/mypy-2.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:28e1e2af8cd8fff551fd30f2fe4b03fb76764ac8b1ba6c6a1bd00ad32b412db3", size = 14000127, upload-time = "2026-07-13T11:30:19.57Z" }, + { url = "https://files.pythonhosted.org/packages/99/6c/a10b7a7b9f0a755fb94e27ae834d4cea9ad6c5221f9325eef8f182641feb/mypy-2.3.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3e77244df3843048c3f927182916730e40c124cbaa43905c1fb86cb382aa0805", size = 14229437, upload-time = "2026-07-13T11:28:17.765Z" }, + { url = "https://files.pythonhosted.org/packages/d9/bd/a26a602acb1bbf849fa4bdac4bc657ee2f11c0c2a764a2cc87a5304e865c/mypy-2.3.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9559ab18a9c9957dfa3004ab57cd4bac5f26a724329a9584e583367f0c2e1117", size = 15171457, upload-time = "2026-07-13T11:29:01.834Z" }, + { url = "https://files.pythonhosted.org/packages/7f/14/124f462bef69bcbc90b9358088460b6091954a3e004852fcd9948db617a5/mypy-2.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:09abd66d8685e73f8f7d17b847c3e104d9a7b164a8706ea87d6c96a3d45816d5", size = 15478281, upload-time = "2026-07-13T11:32:23.413Z" }, + { url = "https://files.pythonhosted.org/packages/db/a4/8bdca6a8ac8d856d82ed049144af2721245a135c2e8001d3890c93975852/mypy-2.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:5e91adad1ca81742ac7ef9893959911df867752206b37135185e88dfb3c89494", size = 11148008, upload-time = "2026-07-13T11:34:17.332Z" }, + { url = "https://files.pythonhosted.org/packages/83/41/490eea348e60ba50decec20bc750605444149a5d7a8cc560042f90ba2c75/mypy-2.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:6f99ec626e3c3a2f7c0b22c5b90ddb5dabb1c18729c971e9bdaca1f1766d2cee", size = 10142329, upload-time = "2026-07-13T11:32:52.116Z" }, + { url = "https://files.pythonhosted.org/packages/e6/b9/d75b3082b05f1b3028828aeb18e74ae5ab0a0936051bbf1f32f59f654747/mypy-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3419d00717afbc5265b50dd14b1278f29ea4884dd398ab67873489ac093fd329", size = 14838725, upload-time = "2026-07-13T11:32:44.655Z" }, + { url = "https://files.pythonhosted.org/packages/a9/50/79a65c6ea6e115bc73296038a4543b2d5c91f07912b918a2c616a2514bba/mypy-2.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cfca8ee88544090f86b6dcce05ec55d66eb48a762412ac2507810ba4bd793b6f", size = 13911128, upload-time = "2026-07-13T11:32:02.021Z" }, + { url = "https://files.pythonhosted.org/packages/90/48/e11ed7716c26953ca321f726e452e374dbf81a6f2b8b212ec02af29b6b8f/mypy-2.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:75cbb4b9ef04a0c84a957f07abc4504fbf64b8dcc145675101f2d3a78a4b1d6a", size = 14146742, upload-time = "2026-07-13T11:33:03.313Z" }, + { url = "https://files.pythonhosted.org/packages/06/72/6807565b1c4861ef66f7fdd98b51c61556356eab80235717b46c53bb8627/mypy-2.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:982e3d53dd23d0a4cef67dd66791fdbede0cf38f9eb617bf47663554c51e1e36", size = 15081418, upload-time = "2026-07-13T11:31:13.899Z" }, + { url = "https://files.pythonhosted.org/packages/00/80/1ea14c5d80e589e415973db3e47c78c2219a305b808b2b506395342c1d79/mypy-2.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:85c5385b93012ffa3b31479ab579aef5415f4f3a32c6cf1ae07a984d2a0ff461", size = 15328164, upload-time = "2026-07-13T11:31:35.723Z" }, + { url = "https://files.pythonhosted.org/packages/37/28/8223157404a3d51920078459c37f80fbdc590e1d8ea049dc5ce48643022a/mypy-2.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:13b1b16e2fa39f3b2e33fb1c468abc7a69369fa2e886b4b87b5afc81472325cd", size = 11136472, upload-time = "2026-07-13T11:27:37.018Z" }, + { url = "https://files.pythonhosted.org/packages/6f/cc/ea27e5959c5f258585a756b252031f3b313583d81b5064b2bebc41d3706b/mypy-2.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:b5cd2f027a972a4a5f2278a11fac9747f5f81a53a30b714d74950b6807e55568", size = 10135800, upload-time = "2026-07-13T11:30:08.92Z" }, + { url = "https://files.pythonhosted.org/packages/dc/94/0e7e592619e2133596a47cdd642534b0456545c218430bd3b9d8fefdd1b1/mypy-2.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d53fc67b9d28a43c6199077f49fea0f05839e36cf6158500331c9549225e5a5", size = 15026523, upload-time = "2026-07-13T11:34:49.206Z" }, + { url = "https://files.pythonhosted.org/packages/f6/d2/1e1731df090a857df2807177a4626863e5ac0f0256513c35780efe53986f/mypy-2.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fbc00cee7bdbb9291979ddc9d08034a29dfcda4932628c9bbc28c1edd589df0c", size = 14032189, upload-time = "2026-07-13T11:33:57.168Z" }, + { url = "https://files.pythonhosted.org/packages/44/95/cab921f4a806e171f34113e6181dd23c55358ccf6a80741269ef594a410e/mypy-2.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:04e617030eca5221909c8b7d8d7fd1c637948199aa2100b2ad9813feb07e1491", size = 14198696, upload-time = "2026-07-13T11:32:12.767Z" }, + { url = "https://files.pythonhosted.org/packages/66/80/e6d008bb19fe446e3662d85e0e2717bf9f2d611a2164fb29d6e067dbf46c/mypy-2.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56c184d2c20ca6b6378d58d1960270a767f41f5e44acbbd27f05effef4f4e1d7", size = 15286904, upload-time = "2026-07-13T11:34:27.594Z" }, + { url = "https://files.pythonhosted.org/packages/db/83/94397c9293608a364aa03e8084fb34ede4ae976a260384b9b52929308135/mypy-2.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3961a4a34b05f7c74b0f05aa51fbfe99a2d1e126038df40318d15c8f558b7ef3", size = 15528342, upload-time = "2026-07-13T11:34:07.819Z" }, + { url = "https://files.pythonhosted.org/packages/cf/96/d8b37d819adec6cfccfb1fd3afc1735d94717ddeafb45536db9c6943e09b/mypy-2.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:b1942b9314d4c784b8ea1dbab4972603290e5dd5630f06675f13aec97526bc4c", size = 11218346, upload-time = "2026-07-13T11:28:27.745Z" }, + { url = "https://files.pythonhosted.org/packages/2b/cd/cd9f725b19b19e5b530a154cf9bcf9e94279c5d55b3c34fb42b3aa48ea1b/mypy-2.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:be51653d7669d7d7955d613b8d0bb57d5b652eaf71a873ddf65ac87254dd2595", size = 10204525, upload-time = "2026-07-13T11:31:02.552Z" }, + { url = "https://files.pythonhosted.org/packages/6e/ae/f7d056eb0294586a572d0d0d89580ec633c064db520f11d37d5a2fb833bd/mypy-2.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:91ad22a52ae2c7e621c2f67c94d5a17f66b3209a4cff5cf8a573579835c69e97", size = 14947298, upload-time = "2026-07-13T11:27:47.734Z" }, + { url = "https://files.pythonhosted.org/packages/32/d5/db3e7af01e7844d21662c6ddc1f7825ec7cb4053f0391ac02faf3638396f/mypy-2.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:99ac767cc5d3b64c8d0ae226ead10c96694f94e4e7da1668642225dcd4e75aac", size = 13950768, upload-time = "2026-07-13T11:27:57.726Z" }, + { url = "https://files.pythonhosted.org/packages/d9/fb/43c031f0190513d1ec248ed037eceb742ddd2a4d74bbf406658a28173837/mypy-2.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de6d2c484742a4d7b0ed6d07b143375624d3b899c5749c7b3c947f56261f48a6", size = 14151586, upload-time = "2026-07-13T11:29:18.615Z" }, + { url = "https://files.pythonhosted.org/packages/ec/c3/f8b2ffc60883084da91be51af58e88a7ffd4ff9795acb7d902ff88d31eb1/mypy-2.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7da939dd335cfd2ad788bdfd081c9f4e47634ab995e5a45eb15fd1e5bc052f8b", size = 15227411, upload-time = "2026-07-13T11:30:29.904Z" }, + { url = "https://files.pythonhosted.org/packages/83/2e/16b917fc7adcf03f1aadddfc93aab804ffb234b1ab09c0ffd6d92a5d34a2/mypy-2.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7247eb2824f996722a949530183394921ca71deb9680052a338cf53cff7925c2", size = 15478790, upload-time = "2026-07-13T11:33:14.686Z" }, + { url = "https://files.pythonhosted.org/packages/c0/88/aaa65a93c73d0cdae7e42f8adb302bf6885bb281302084f99d0290a35347/mypy-2.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:75b0984bb3cbd76bb5c9291a8671f7ae66ca3b51c7584c358fc2e923259f0757", size = 11234919, upload-time = "2026-07-13T11:33:39.28Z" }, + { url = "https://files.pythonhosted.org/packages/35/19/b40de63f1a80e63bc2d40f0679a6a8dbd34e95176c8122119bdf406aa552/mypy-2.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:d78fcf900b59cb7e82cb7e3a235e31b462d9333d92285bd1e4952d355b8ffba1", size = 10201510, upload-time = "2026-07-13T11:31:52.619Z" }, + { url = "https://files.pythonhosted.org/packages/a4/58/fa0ae047da911f540284009b4f44b96fe09d83c076d7c103e9d645f46303/mypy-2.3.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ea317b060ce83e26050f8f9e4d7d6bf44ed7597c8ff9990bccffbb9d1d8522db", size = 14941909, upload-time = "2026-07-13T11:32:34.332Z" }, + { url = "https://files.pythonhosted.org/packages/15/14/2ba1d61452d7c2a7fe12741e8d374e52b183476b07aa7f9e2a0d02b0720a/mypy-2.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:094af99f92638aa92852326188b85a89e50f4a472f44827c03362228482f0762", size = 13967581, upload-time = "2026-07-13T11:30:00.587Z" }, + { url = "https://files.pythonhosted.org/packages/ed/5a/483fb9e5ffbbb1a28dccc7b0a13d141b17ac769b6c9f488c0a0c63698962/mypy-2.3.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de121747278144fc9ae7caa2e978cf5df12aebc82933182f5b3b86081a30baef", size = 14168807, upload-time = "2026-07-13T11:28:48.6Z" }, + { url = "https://files.pythonhosted.org/packages/ae/77/70d7a10732063beb74ad713682cf871e88f5c5fa39bfc8beff8a524bf9cb/mypy-2.3.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:37fa4de896a84e2dc9200d91e614c22563b43d1a266789d4bbac7b22ebe6192b", size = 15200144, upload-time = "2026-07-13T11:31:25.283Z" }, + { url = "https://files.pythonhosted.org/packages/56/72/766218ac783be4fdfcd699b90037b63017348a3e86fb2c1fbfb18302637d/mypy-2.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f1b3a98dfd21058bc759bb3337d5d1f61d0fdf9f3cf9c00f4291790fb5427bff", size = 15460389, upload-time = "2026-07-13T11:29:29.077Z" }, + { url = "https://files.pythonhosted.org/packages/38/4e/8a9db7411ecb8ec0cb1fd05dba432f28bafffcd38b4e887714a4a0506689/mypy-2.3.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:944c665d984157cb96a679dfb7a4a81dd1d36b24b9c284b699514e6e626b82d4", size = 7753664, upload-time = "2026-07-13T11:29:08.147Z" }, + { url = "https://files.pythonhosted.org/packages/65/4c/c3f8bfd6ed0e5e38b5a244403b27f821d433443df5a15a278417c10a3a3c/mypy-2.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:4359424140d985192c778c1ce2c114a10c1ca58a381ed79cfa70d37df94b299f", size = 11417237, upload-time = "2026-07-13T11:33:47.467Z" }, + { url = "https://files.pythonhosted.org/packages/3c/00/89a32eaf5ccf174bc4f90db0eaea5d70636c01b8d49f384bdab2e8834390/mypy-2.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:3dd0bed92c4bdec57c42505b96416fb9e6a5aa7be84d2809bcd5f2ecec2860d7", size = 10389252, upload-time = "2026-07-13T11:31:43.81Z" }, + { url = "https://files.pythonhosted.org/packages/31/56/104f93d69aa9f339b6b9d3b0a7faa699b8b466c942cf3ae86cc2a2ec0915/mypy-2.3.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:691fdc37132b1ae628d834f672e74de83462d9fb4aff621835767fb43a8dd373", size = 16385495, upload-time = "2026-07-13T11:29:49.818Z" }, + { url = "https://files.pythonhosted.org/packages/d2/03/f1d2123313f55efafdd27706960f43a771c62f1b68426c76043f3ab9ebf3/mypy-2.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:aec15d465d477558fd842757b487849007311cf3897849cdda0e3162ac0ac556", size = 15098155, upload-time = "2026-07-13T11:30:40.301Z" }, + { url = "https://files.pythonhosted.org/packages/e5/5d/d5f9200399b445e81726c4f23becee33f233aee81c72680b1ef3a258b641/mypy-2.3.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b352b7e49f5e6576009e8df730e1ff4f915cb565b851b396d2ffe2f5a6f5da88", size = 15514155, upload-time = "2026-07-13T11:34:38.569Z" }, + { url = "https://files.pythonhosted.org/packages/cd/ce/69977c555f08faa3190cfde44189b89dbd56861b1ab97aa18fc5f3a2e4a3/mypy-2.3.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c6c6bf687b17f90dbfcad95b960d32eaa0154c00da45f03ab50bf8952e047fe", size = 16766351, upload-time = "2026-07-13T11:33:29.195Z" }, + { url = "https://files.pythonhosted.org/packages/bc/92/6648b6caa3ab9e00f9ac0c2a78307805f873dd48139b24a6f6f7c3667bbf/mypy-2.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f4ed18f111bfe2d599bca7468e7f9251042c1c2118f762c8de2766a56d773c60", size = 17043490, upload-time = "2026-07-13T11:30:53.927Z" }, + { url = "https://files.pythonhosted.org/packages/7c/ab/0dc91d80f3f016634c68d451f294a97320fe903a9b6f90b9e57b3f7f1717/mypy-2.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0b025a93cffb9781d231f232be07a17912f35f10a313c24f301c81e842870654", size = 12146869, upload-time = "2026-07-13T11:29:38.874Z" }, + { url = "https://files.pythonhosted.org/packages/85/b5/4c964d02634ba81f4d1c84838e5c5b18ab06d13ed568960f5d6318495ccc/mypy-2.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:adebc76aab4f3495a88b41d48aa4aff0c03f2822501da76625afcca5975f19e5", size = 10965113, upload-time = "2026-07-13T11:28:07.056Z" }, + { url = "https://files.pythonhosted.org/packages/2c/fa/fdc54fe583ba3cafbcedfb70eeeaf03849f75b1827a07096c7bd996f582d/mypy-2.3.0-py3-none-any.whl", hash = "sha256:6b1cdb579446b60432432b2b2403a6201b4b475a004d7f488511c9ba177c9e88", size = 2753292, upload-time = "2026-07-13T11:33:18.48Z" }, +] + +[[package]] +name = "mypy-extensions" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, +] + +[[package]] +name = "nh3" +version = "0.3.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5e/1b/ef84624f14954d270f74060a19fc550dd4f06656399447569afb584d8c06/nh3-0.3.6.tar.gz", hash = "sha256:f3736c9dd3d1856f80cd031715b84ca75cda2bbb1ac802c3da26bfce590838d7", size = 24684, upload-time = "2026-06-22T00:47:02.008Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/3e/6506aa4f23dc7b7993a2d0a45dca3ce864ec48380adfe15a173e643c63e8/nh3-0.3.6-cp314-cp314t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:2411e8c3cee81a1ddd62c2a5d50585c28aa5566d373ad1db92536b95ddb24ef2", size = 1421679, upload-time = "2026-06-22T00:46:20.248Z" }, + { url = "https://files.pythonhosted.org/packages/e3/e1/e96e7864a7a53bd6b6fab7e9632467382a2a2c1f3fed951918ad131542fb/nh3-0.3.6-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e196fa70c2ff2eb4de7d3df3108f8f358c1d69dff20d45b11f20a5aa227ffb6d", size = 792570, upload-time = "2026-06-22T00:46:22.179Z" }, + { url = "https://files.pythonhosted.org/packages/59/62/5b6108bedaef2b2637fed04c87bdbcb5967b9961758b41f0e466ef22a022/nh3-0.3.6-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:34d2b0d934156b87ee114f599a3ba9b8b9e17b5d79652ba3a13fa50903de965e", size = 842243, upload-time = "2026-06-22T00:46:23.801Z" }, + { url = "https://files.pythonhosted.org/packages/4b/4a/526f199626bfcb496bc01a268051b44737962005553b158e985ed7e64865/nh3-0.3.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2f14b7ae1fca99c4a66c981aac3974e7fbc1ca30a12673d223ae1df76680917", size = 1001468, upload-time = "2026-06-22T00:46:25.481Z" }, + { url = "https://files.pythonhosted.org/packages/49/09/0d8e3101636d9ad88cdefb2914e764cb8e876ebdbb4286bfc251277d9c67/nh3-0.3.6-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:889932a97fb4abb6f95fef1914c0d269ebfb60011e67121c1163059b9449dbb4", size = 1082933, upload-time = "2026-06-22T00:46:27.15Z" }, + { url = "https://files.pythonhosted.org/packages/09/a1/ea83abe738a3fbaa203dfdb836ca7cbab0e7e9609faaee4fe1d4652599c0/nh3-0.3.6-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:edb2b4a1a27523e6cc7c417f8d21ce3d005243548b93e56b762b66b0c7f589f9", size = 1043120, upload-time = "2026-06-22T00:46:28.89Z" }, + { url = "https://files.pythonhosted.org/packages/66/69/0654482b8635012fbae67826bd6c381abb05d841ac7388b9b4666300fdad/nh3-0.3.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:43bc1ed3fa0716295fabee29ba42b2667e4a51d140b0a68e092170a765474fa6", size = 1023824, upload-time = "2026-06-22T00:46:30.453Z" }, + { url = "https://files.pythonhosted.org/packages/ed/a6/1f7285ffadc8307c4dbeb08d21b920536d5117785056d1079e998c4dfa44/nh3-0.3.6-cp314-cp314t-win32.whl", hash = "sha256:597a8e843bea00b2eb5520658dc24a9bb032e7fc9e7c2c0c4cd29420220c9796", size = 599253, upload-time = "2026-06-22T00:46:32.072Z" }, + { url = "https://files.pythonhosted.org/packages/36/ea/5542f3c45da4c00290d9d67a65e996702e23e613c4b627de3e09cb9fe357/nh3-0.3.6-cp314-cp314t-win_amd64.whl", hash = "sha256:4713502748f564fee0633b37b3403783ce0a3af3a3d148ad91025a5bdadb7bc6", size = 612553, upload-time = "2026-06-22T00:46:33.53Z" }, + { url = "https://files.pythonhosted.org/packages/66/35/26bd47e6af5915a628281dccdac354ddf4e32f7397047894270acd8c9870/nh3-0.3.6-cp314-cp314t-win_arm64.whl", hash = "sha256:69bbb92865a693d909db3a700d3c01537533844d0948c1e9323561ce06ecda41", size = 595151, upload-time = "2026-06-22T00:46:34.878Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ab/a7653bce9a3b204be6a6931767a9e23595807bb84790ce6685e4d7e5bd08/nh3-0.3.6-cp38-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:a43ebd7543555c3ac1bc353023d0794e75cb76f6f18f19c32e95441496c0cc25", size = 1443564, upload-time = "2026-06-22T00:46:36.66Z" }, + { url = "https://files.pythonhosted.org/packages/41/21/e1084ab18eb589506335c7c7576f2d4643e9a0c0e33983ef0e549a256b96/nh3-0.3.6-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1b160831c9cdb06a6c79c2f9cdb11386602938f9af260d1c457a85add4f6f69", size = 838002, upload-time = "2026-06-22T00:46:38.101Z" }, + { url = "https://files.pythonhosted.org/packages/b0/94/f48d08e6f72a406300fa11d8acd929fea1a80d4bf750fa292cb10785f126/nh3-0.3.6-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d14bf7982e7a77c0c775634c29c07ce08b38a046df73e1c1f139b3e82f18a38e", size = 823045, upload-time = "2026-06-22T00:46:39.495Z" }, + { url = "https://files.pythonhosted.org/packages/25/bb/431615ba1d1d3eb63cde0f974f2114edf863a8a3f6049a12fed23fc241d3/nh3-0.3.6-cp38-abi3-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:44673b27010051ab5a5e438a86ec31bbda61d4a77d7e900af6b7be3037c1abae", size = 1093171, upload-time = "2026-06-22T00:46:41.21Z" }, + { url = "https://files.pythonhosted.org/packages/0e/24/a0d80182a18919665fefd19c1c06f1d1df1c9a6455d0252de40c034a0bc3/nh3-0.3.6-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e6b7beece07525dc6e6b0fc2f104442de2ba328360ad00e50cbe2e1fd620447d", size = 1049217, upload-time = "2026-06-22T00:46:42.804Z" }, + { url = "https://files.pythonhosted.org/packages/0a/13/6f1e302ca674ac74362e150848ad56a1be5145391204f74facdb8e94df12/nh3-0.3.6-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:455469a29951edc92bc48b47ac2281c3f2609e6c4f6a047056449f8c2c23facf", size = 917372, upload-time = "2026-06-22T00:46:44.495Z" }, + { url = "https://files.pythonhosted.org/packages/5b/67/314f6151bad77a93d751978a344033e1fc890822f05f0416079338e34231/nh3-0.3.6-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:905f877dc66dd7aea4a76e54bcb26acb5ff8216f720c0017ccf63e0e6035698e", size = 806699, upload-time = "2026-06-22T00:46:45.99Z" }, + { url = "https://files.pythonhosted.org/packages/3c/a6/bfaa00046e58603507dcfc266c4778e3ab7adf68a5dedd73b6274b8d9314/nh3-0.3.6-cp38-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:25c733bee928530556b1db0ea46c52cf5aa686146e38e60a6fc7cb801ef91cec", size = 835165, upload-time = "2026-06-22T00:46:47.617Z" }, + { url = "https://files.pythonhosted.org/packages/30/a8/fb2c38845efb703a9173bffdfc745fc64d2b0e55cfc73a3647d2f028250c/nh3-0.3.6-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2f90d9a0cfdbee218994fdaaeeb5a0fde62d08f35e4eef0378ec1e2200172fd0", size = 858282, upload-time = "2026-06-22T00:46:49.276Z" }, + { url = "https://files.pythonhosted.org/packages/68/17/06e72a18ee9b572914447338237ca7eb164c0df901f141bc10d1282247a2/nh3-0.3.6-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:82ca5bf427ad1b216b65ede1a2e2d87dc49bec417ceba0f297213107d3cd9d78", size = 1014328, upload-time = "2026-06-22T00:46:51.026Z" }, + { url = "https://files.pythonhosted.org/packages/11/f9/3966c61455668c08853bf5e33b4bed93c421f3194ce4de896dc248d6f6ce/nh3-0.3.6-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:f5ed5fe84aee7f39db95c214a7421bf0499fbf500fec6d86a4e29bfc37971438", size = 1098207, upload-time = "2026-06-22T00:46:52.674Z" }, + { url = "https://files.pythonhosted.org/packages/19/d3/479cb4ae440424825735d60525b53e3c77fd60fd6e6afc0e984f00eb0178/nh3-0.3.6-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:082675ff87b9385ec430ffe6d5847ba7456cc39b73720cd4add472f9f4cffd56", size = 1056961, upload-time = "2026-06-22T00:46:54.335Z" }, + { url = "https://files.pythonhosted.org/packages/17/0c/6cdb5ee1e127be50dc8391e54bddc1f64e87bf4bfad0c55633320e2e02db/nh3-0.3.6-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:36d06341bd501240d320f5942481ed5e6846136b666e1ba4faf802b78ebc875f", size = 1033829, upload-time = "2026-06-22T00:46:56.258Z" }, + { url = "https://files.pythonhosted.org/packages/e9/55/9de666ad975d6ccd77d799ea0add55ee2347aa81286ce21b2a97c070746b/nh3-0.3.6-cp38-abi3-win32.whl", hash = "sha256:5276ef17bdba9ad8040575c74072008b13aae429436e9d0429e718bb5f90f4da", size = 609081, upload-time = "2026-06-22T00:46:57.665Z" }, + { url = "https://files.pythonhosted.org/packages/82/fa/2b5d684e3edf1e81bfd02d298c78c3e3da77ca1d8a2be3183a79544a7548/nh3-0.3.6-cp38-abi3-win_amd64.whl", hash = "sha256:f338ac7d594c067679f1e99b4f5ec3906842979560f9d8f15d6bdfa39a353b10", size = 624461, upload-time = "2026-06-22T00:46:59.163Z" }, + { url = "https://files.pythonhosted.org/packages/7b/e5/7cafee2f0413ca4cb0ef3bd111e94d408a48810008b283ad8aee00dd1809/nh3-0.3.6-cp38-abi3-win_arm64.whl", hash = "sha256:69f365963f63a1e9bff53bdbb3c542c7c2efed3e163c9d5d83a772a2ac468c21", size = 603060, upload-time = "2026-06-22T00:47:00.596Z" }, +] + +[[package]] +name = "packaging" +version = "26.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" }, +] + +[[package]] +name = "pathspec" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + +[[package]] +name = "pydantic" +version = "2.13.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/18/a5/b60d21ac674192f8ab0ba4e9fd860690f9b4a6e51ca5df118733b487d8d6/pydantic-2.13.4.tar.gz", hash = "sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6", size = 844775, upload-time = "2026-05-06T13:43:05.343Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/7b/122376b1fd3c62c1ed9dc80c931ace4844b3c55407b6fb2d199377c9736f/pydantic-2.13.4-py3-none-any.whl", hash = "sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba", size = 472262, upload-time = "2026-05-06T13:43:02.641Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.46.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/08/f1ba952f1c8ae5581c70fa9c6da89f247b83e3dd8c09c035d5d7931fc23d/pydantic_core-2.46.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:a396dcc17e5a0b164dbe026896245a4fa9ff402edca1dff0be3d53a517f74de4", size = 2113146, upload-time = "2026-05-06T13:37:36.537Z" }, + { url = "https://files.pythonhosted.org/packages/56/c6/65f646c7ff09bd257f660434adb45c4dfcbbcebcc030562fecf6f5bf887d/pydantic_core-2.46.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:da4b951fe36dc7c3a1ccb4e3cd1747c3542b8c9ceede8fc86cae054e764485f5", size = 1949769, upload-time = "2026-05-06T13:37:46.365Z" }, + { url = "https://files.pythonhosted.org/packages/64/ba/bfb1d928fd5b49e1258935ff104ae356e9fd89384a55bf9f847e9193ad40/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb63e0198ca18aad131c089b9204c23079c3afa95487e561f4c522d519e55aba", size = 1974958, upload-time = "2026-05-06T13:37:28.611Z" }, + { url = "https://files.pythonhosted.org/packages/4e/74/76223bfb117b64af743c9b6670d1364516f5c0604f96b48f3272f6af6cc6/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f47286a97f0bc9b8859519809077b91b2cefe4ae47fcbf5e466a009c1c5d742b", size = 2042118, upload-time = "2026-05-06T13:36:55.216Z" }, + { url = "https://files.pythonhosted.org/packages/cb/7b/848732968bc8f48f3187542f08358b9d842db564147b256669426ebb1652/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:905a0ed8ea6f2d61c1738835f99b699348d7857379083e5fc497fa0c967a407c", size = 2222876, upload-time = "2026-05-06T13:38:25.455Z" }, + { url = "https://files.pythonhosted.org/packages/b5/2f/e90b63ee2e14bd8d3db8f705a6d75d64e6ee1b7c2c8833747ce706e1e0ce/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ea793e075b70290d89d8142074262885d3f7da19634845135751bd6344f73b50", size = 2286703, upload-time = "2026-05-06T13:37:53.304Z" }, + { url = "https://files.pythonhosted.org/packages/ba/1e/acc4d70f88a0a277e4a1fa77ebb985ceabaf900430f875bf9338e11c9420/pydantic_core-2.46.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:395aebd9183f9d112f569aeb5b2214d1a10a33bec8456447f7fbdfa51d38d4cd", size = 2092042, upload-time = "2026-05-06T13:38:46.981Z" }, + { url = "https://files.pythonhosted.org/packages/a9/da/0a422b57bf8504102bf3c4ccea9c41bab5a5cee6a54650acf8faf67f5a24/pydantic_core-2.46.4-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:b078afbc25f3a1436c7a1d2cd3e322497ee99615ba97c563566fdf46aff1ee01", size = 2117231, upload-time = "2026-05-06T13:39:23.146Z" }, + { url = "https://files.pythonhosted.org/packages/bd/2a/2ac13c3af305843e23c5078c53d135656b3f05a2fd78cb7bbbb12e97b473/pydantic_core-2.46.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f747929cf940cddb5b3668a390056ddd5ba2e5010615ea2dcf4f9c4f3ab8791d", size = 2168388, upload-time = "2026-05-06T13:40:08.06Z" }, + { url = "https://files.pythonhosted.org/packages/72/04/2beacf7e1607e93eefe4aed1b4709f079b905fb77530179d4f7c71745f22/pydantic_core-2.46.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:daa27d92c36f24388fe3ad306b174781c747627f134452e4f128ea00ce1fe8c4", size = 2184769, upload-time = "2026-05-06T13:38:13.901Z" }, + { url = "https://files.pythonhosted.org/packages/9e/29/d2b9fd9f539133548eaf622c06a4ce176cb46ac59f32d0359c4abc0de047/pydantic_core-2.46.4-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:19e51f073cd3df251856a8a4189fbdf1de4012c3ebacfb1884f94f1eb406079f", size = 2319312, upload-time = "2026-05-06T13:39:08.24Z" }, + { url = "https://files.pythonhosted.org/packages/7c/af/0f7a5b85fec6075bea96e3ef9187de38fccced0de92c1e7feda8d5cc7bb9/pydantic_core-2.46.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c1747f85cee84c26985853c6f3d9bd3e75da5212912443fa111c113b9c246f39", size = 2361817, upload-time = "2026-05-06T13:38:43.2Z" }, + { url = "https://files.pythonhosted.org/packages/25/a4/73363fec545fd3ec025490bdda2743c56d0dd5b6266b1a53bbe9e4265375/pydantic_core-2.46.4-cp310-cp310-win32.whl", hash = "sha256:2f84c03c8607173d16b5a854ec68a2f9079ae03237a54fb506d13af47e1d018d", size = 1987085, upload-time = "2026-05-06T13:39:25.497Z" }, + { url = "https://files.pythonhosted.org/packages/01/aa/62f082da2c91fac1c234bc9ee0066257ce83f0604abd72e4c9d5991f2d84/pydantic_core-2.46.4-cp310-cp310-win_amd64.whl", hash = "sha256:8358a950c8909158e3df31538a7e4edc2d7265a7c54b47f0864d9e5bae9dcebf", size = 2074311, upload-time = "2026-05-06T13:39:59.922Z" }, + { url = "https://files.pythonhosted.org/packages/5c/fa/6d7708d2cfc1a832acb6aeb0cd16e801902df8a0f583bb3b4b527fde022e/pydantic_core-2.46.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:0e96592440881c74a213e5ad528e2b24d3d4f940de2766bed9010ab1d9e51594", size = 2111872, upload-time = "2026-05-06T13:40:27.596Z" }, + { url = "https://files.pythonhosted.org/packages/ae/6f/aa064a3e74b5745afbdf250594f38e7ead05e2d651bcb35994b9417a0d4d/pydantic_core-2.46.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e0d65b8c354be7fb5f720c3caa8bc940bc2d20ce749c8e06135f07f8ed95dd7c", size = 1948255, upload-time = "2026-05-06T13:39:12.574Z" }, + { url = "https://files.pythonhosted.org/packages/43/3a/41114a9f7569b84b4d84e7a018c57c56347dac30c0d4a872946ec4e36c46/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7bfb192b3f4b9e8a89b6277b6ce787564f62cfd272055f6e685726b111dc7826", size = 1972827, upload-time = "2026-05-06T13:38:19.841Z" }, + { url = "https://files.pythonhosted.org/packages/ef/25/1ab42e8048fe551934d9884e8d64daa7e990ad386f310a15981aeb6a5b08/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9037063db01f09b09e237c282b6792bd4da634b5402c4e7f0c61effed7701a04", size = 2041051, upload-time = "2026-05-06T13:38:10.447Z" }, + { url = "https://files.pythonhosted.org/packages/94/c2/1a934597ddf08da410385b3b7aae91956a5a76c635effef456074fad7e88/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc010ab034c8c7452522748bf937df58020d256ccae0874463d1f4d01758af8e", size = 2221314, upload-time = "2026-05-06T13:40:13.089Z" }, + { url = "https://files.pythonhosted.org/packages/02/6d/9e8ad178c9c4df27ad3c8f25d1fe2a7ab0d2ba0559fad4aee5d3d1f16771/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8c5dac79fa1614d1e06ca695109c6105923bd9c7d1d6c918d4e637b7e6b32fd3", size = 2285146, upload-time = "2026-05-06T13:38:59.224Z" }, + { url = "https://files.pythonhosted.org/packages/80/50/540cd3aeefc041beb111125c4bff779831a2111fc6b15a9138cda277d32c/pydantic_core-2.46.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f9fa868638bf362d3d138ea55829cefb3d5f4b0d7f142234382a15e2485dbec4", size = 2089685, upload-time = "2026-05-06T13:38:17.762Z" }, + { url = "https://files.pythonhosted.org/packages/6b/a4/b440ad35f05f6a38f89fa0f149accb3f0e02be94ca5e15f3c449a61b4bc9/pydantic_core-2.46.4-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:17299feefe090f2caa5b8e37222bb5f663e4935a8bfa6931d4102e5df1a9f398", size = 2115420, upload-time = "2026-05-06T13:37:58.195Z" }, + { url = "https://files.pythonhosted.org/packages/99/61/de4f55db8dfd57bfdfa9a12ec90fe1b57c4f41062f7ca86f08586b3e0ac0/pydantic_core-2.46.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4c63ebc82684aa89d9a3bcbd13d515b3be44250dc68dd3bd81526c1cb31286c3", size = 2165122, upload-time = "2026-05-06T13:37:01.167Z" }, + { url = "https://files.pythonhosted.org/packages/f7/52/7c529d7bdb2d1068bd52f51fe32572c8301f9a4febf1948f10639f1436f5/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:aaa2a54443eff1950ba5ddc6b6ccda0d9c84a364276a62f969bdf2a390650848", size = 2182573, upload-time = "2026-05-06T13:38:45.04Z" }, + { url = "https://files.pythonhosted.org/packages/37/b3/7c40325848ba78247f2812dcf9c7274e38cd801820ca6dd9fe63bcfb0eb4/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:18e5ceec2ab67e6d5f1a9085e5a24c9c4e2ac4545730bfe668680bca05e555f3", size = 2317139, upload-time = "2026-05-06T13:37:15.539Z" }, + { url = "https://files.pythonhosted.org/packages/d9/37/f913f81a657c865b75da6c0dbed79876073c2a43b5bd9edbe8da785e4d49/pydantic_core-2.46.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:a0f62d0a58f4e7da165457e995725421e0064f2255d8eccebc49f41bbc23b109", size = 2360433, upload-time = "2026-05-06T13:37:30.099Z" }, + { url = "https://files.pythonhosted.org/packages/c4/67/6acaa1be2567f9256b056d8477158cac7240813956ce86e49deae8e173b4/pydantic_core-2.46.4-cp311-cp311-win32.whl", hash = "sha256:041bde0a48fd37cf71cab1c9d56d3e8625a3793fef1f7dd232b3ff37e978ecda", size = 1985513, upload-time = "2026-05-06T13:38:15.669Z" }, + { url = "https://files.pythonhosted.org/packages/aa/e6/c505f83dfeda9a2e5c995cfd872949e4d05e12f7feb3dca72f633daefa94/pydantic_core-2.46.4-cp311-cp311-win_amd64.whl", hash = "sha256:6f2eeda33a839975441c86a4119e1383c50b47faf0cbb5176985565c6bb02c33", size = 2071114, upload-time = "2026-05-06T13:40:35.416Z" }, + { url = "https://files.pythonhosted.org/packages/0f/da/7a263a96d965d9d0df5e8de8a475f33495451117035b09acb110288c381f/pydantic_core-2.46.4-cp311-cp311-win_arm64.whl", hash = "sha256:14f4c5d6db102bd796a627bbb3a17b4cf4574b9ae861d8b7c9a9661c6dd3362d", size = 2044298, upload-time = "2026-05-06T13:38:29.754Z" }, + { url = "https://files.pythonhosted.org/packages/ce/8c/af022f0af448d7747c5154288d46b5f2bc5f17366eaa0e23e9aa04d59f3b/pydantic_core-2.46.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2", size = 2106158, upload-time = "2026-05-06T13:38:57.215Z" }, + { url = "https://files.pythonhosted.org/packages/19/95/6195171e385007300f0f5574592e467c568becce2d937a0b6804f218bc49/pydantic_core-2.46.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f", size = 1951724, upload-time = "2026-05-06T13:37:02.697Z" }, + { url = "https://files.pythonhosted.org/packages/8e/bc/f47d1ff9cbb1620e1b5b697eef06010035735f07820180e74178226b27b3/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7", size = 1975742, upload-time = "2026-05-06T13:37:09.448Z" }, + { url = "https://files.pythonhosted.org/packages/5b/11/9b9a5b0306345664a2da6410877af6e8082481b5884b3ddd78d47c6013ce/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7", size = 2052418, upload-time = "2026-05-06T13:37:38.234Z" }, + { url = "https://files.pythonhosted.org/packages/f1/b7/a65fec226f5d78fc39f4a13c4cc0c768c22b113438f60c14adc9d2865038/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712", size = 2232274, upload-time = "2026-05-06T13:38:27.753Z" }, + { url = "https://files.pythonhosted.org/packages/68/f0/92039db98b907ef49269a8271f67db9cb78ae2fc68062ef7e4e77adb5f61/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4", size = 2309940, upload-time = "2026-05-06T13:38:05.353Z" }, + { url = "https://files.pythonhosted.org/packages/5f/97/2aab507d3d00ca626e8e57c1eac6a79e4e5fbcc63eb99733ff55d1717f65/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce", size = 2094516, upload-time = "2026-05-06T13:39:10.577Z" }, + { url = "https://files.pythonhosted.org/packages/22/37/a8aca44d40d737dde2bc05b3c6c07dff0de07ce6f82e9f3167aeaf4d5dea/pydantic_core-2.46.4-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987", size = 2136854, upload-time = "2026-05-06T13:40:22.59Z" }, + { url = "https://files.pythonhosted.org/packages/24/99/fcef1b79238c06a8cbec70819ac722ba76e02bc8ada9b0fd66eba40da01b/pydantic_core-2.46.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b", size = 2180306, upload-time = "2026-05-06T13:40:10.666Z" }, + { url = "https://files.pythonhosted.org/packages/ae/6c/fc44000918855b42779d007ae63b0532794739027b2f417321cddbc44f6a/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458", size = 2190044, upload-time = "2026-05-06T13:40:43.231Z" }, + { url = "https://files.pythonhosted.org/packages/6b/65/d9cadc9f1920d7a127ad2edba16c1db7916e59719285cd6c94600b0080ba/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b", size = 2329133, upload-time = "2026-05-06T13:39:57.365Z" }, + { url = "https://files.pythonhosted.org/packages/d0/cf/c873d91679f3a30bcf5e7ac280ce5573483e72295307685120d0d5ad3416/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c", size = 2374464, upload-time = "2026-05-06T13:38:06.976Z" }, + { url = "https://files.pythonhosted.org/packages/47/bd/6f2fc8188f31bf10590f1e98e7b306336161fac930a8c514cd7bd828c7dc/pydantic_core-2.46.4-cp312-cp312-win32.whl", hash = "sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894", size = 1974823, upload-time = "2026-05-06T13:40:47.985Z" }, + { url = "https://files.pythonhosted.org/packages/40/8c/985c1d41ea1107c2534abd9870e4ed5c8e7669b5c308297835c001e7a1c4/pydantic_core-2.46.4-cp312-cp312-win_amd64.whl", hash = "sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89", size = 2072919, upload-time = "2026-05-06T13:39:21.153Z" }, + { url = "https://files.pythonhosted.org/packages/c4/ba/f463d006e0c47373ca7ec5e1a261c59dc01ef4d62b2657af925fb0deee3a/pydantic_core-2.46.4-cp312-cp312-win_arm64.whl", hash = "sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a", size = 2027604, upload-time = "2026-05-06T13:39:03.753Z" }, + { url = "https://files.pythonhosted.org/packages/51/a2/5d30b469c5267a17b39dec53208222f76a8d351dfac4af661888c5aee77d/pydantic_core-2.46.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:5d5902252db0d3cedf8d4a1bc68f70eeb430f7e4c7104c8c476753519b423008", size = 2106306, upload-time = "2026-05-06T13:37:48.029Z" }, + { url = "https://files.pythonhosted.org/packages/c1/81/4fa520eaffa8bd7d1525e644cd6d39e7d60b1592bc5b516693c7340b50f1/pydantic_core-2.46.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c94f0688e7b8d0a67abf40e57a7eaaecd17cc9586706a31b76c031f63df052b4", size = 1951906, upload-time = "2026-05-06T13:37:17.012Z" }, + { url = "https://files.pythonhosted.org/packages/03/d5/fd02da45b659668b05923b17ba3a0100a0a3d5541e3bd8fcc4ecb711309e/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f027324c56cd5406ca49c124b0db10e56c69064fec039acc571c29020cc87c76", size = 1976802, upload-time = "2026-05-06T13:37:35.113Z" }, + { url = "https://files.pythonhosted.org/packages/21/f2/95727e1368be3d3ed485eaab7adbd7dda408f33f7a36e8b48e0144002b91/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e739fee756ba1010f8bcccb534252e85a35fe45ae92c295a06059ce58b74ccd3", size = 2052446, upload-time = "2026-05-06T13:37:12.313Z" }, + { url = "https://files.pythonhosted.org/packages/9c/86/5d99feea3f77c7234b8718075b23db11532773c1a0dbd9b9490215dc2eeb/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d56801be94b86a9da183e5f3766e6310752b99ff647e38b09a9500d88e46e76", size = 2232757, upload-time = "2026-05-06T13:39:01.149Z" }, + { url = "https://files.pythonhosted.org/packages/d2/3a/508ac615935ef7588cf6d9e9b91309fdc2da751af865e02a9098de88258c/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2412e734dcb48da14d4e4006b82b46b74f2518b8a26ee7e58c6844a6cd6d03c4", size = 2309275, upload-time = "2026-05-06T13:37:41.406Z" }, + { url = "https://files.pythonhosted.org/packages/07/f8/41db9de19d7987d6b04715a02b3b40aea467000275d9d758ffaa31af7d50/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9551187363ffc0de2a00b2e47c25aeaeb1020b69b668762966df15fc5659dd5a", size = 2094467, upload-time = "2026-05-06T13:39:18.847Z" }, + { url = "https://files.pythonhosted.org/packages/2c/e2/f35033184cb11d0052daf4416e8e10a502ea2ac006fc4f459aee872727d1/pydantic_core-2.46.4-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:0186750b482eefa11d7f435892b09c5c606193ef3375bcf94aa00ae6bfb66262", size = 2134417, upload-time = "2026-05-06T13:40:17.944Z" }, + { url = "https://files.pythonhosted.org/packages/7e/7b/6ceeb1cc90e193862f444ebe373d8fdf613f0a82572dde03fb10734c6c71/pydantic_core-2.46.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5855698a4856556d86e8e6cd8434bc3ac0314ee8e12089ae0e143f64c6256e4e", size = 2179782, upload-time = "2026-05-06T13:40:32.618Z" }, + { url = "https://files.pythonhosted.org/packages/5a/f2/c8d7773ede6af08036423a00ae0ceffce266c3c52a096c435d68c896083f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:cbaf13819775b7f769bf4a1f066cb6df7a28d4480081a589828ef190226881cd", size = 2188782, upload-time = "2026-05-06T13:36:51.018Z" }, + { url = "https://files.pythonhosted.org/packages/59/31/0c864784e31f09f05cdd87606f08923b9c9e7f6e51dd27f20f62f975ce9f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:633147d34cf4550417f12e2b1a0383973bdf5cdfde212cb09e9a581cf10820be", size = 2328334, upload-time = "2026-05-06T13:40:37.764Z" }, + { url = "https://files.pythonhosted.org/packages/c2/eb/4f6c8a41efa30baa755590f4141abf3a8c370fab610915733e74134a7270/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:82cf5301172168103724d49a1444d3378cb20cdee30b116a1bd6031236298a5d", size = 2372986, upload-time = "2026-05-06T13:39:34.152Z" }, + { url = "https://files.pythonhosted.org/packages/5b/24/b375a480d53113860c299764bfe9f349a3dc9108b3adc0d7f0d786492ebf/pydantic_core-2.46.4-cp313-cp313-win32.whl", hash = "sha256:9fa8ae11da9e2b3126c6426f147e0fba88d96d65921799bb30c6abd1cb2c97fb", size = 1973693, upload-time = "2026-05-06T13:37:55.072Z" }, + { url = "https://files.pythonhosted.org/packages/7e/e8/cff247591966f2d22ec8c003cd7587e27b7ba7b81ab2fb888e3ab75dc285/pydantic_core-2.46.4-cp313-cp313-win_amd64.whl", hash = "sha256:6b3ace8194b0e5204818c92802dcdca7fc6d88aabbb799d7c795540d9cd6d292", size = 2071819, upload-time = "2026-05-06T13:38:49.139Z" }, + { url = "https://files.pythonhosted.org/packages/c6/1a/f4aee670d5670e9e148e0c82c7db98d780be566c6e6a97ee8035528ca0b3/pydantic_core-2.46.4-cp313-cp313-win_arm64.whl", hash = "sha256:184c081504d17f1c1066e430e117142b2c77d9448a97f7b65c6ac9fd9aee238d", size = 2027411, upload-time = "2026-05-06T13:40:45.796Z" }, + { url = "https://files.pythonhosted.org/packages/8d/74/228a26ddad29c6672b805d9fd78e8d251cd04004fa7eed0e622096cd0250/pydantic_core-2.46.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:428e04521a40150c85216fc8b85e8d39fece235a9cf5e383761238c7fa9b96fb", size = 2102079, upload-time = "2026-05-06T13:38:41.019Z" }, + { url = "https://files.pythonhosted.org/packages/ad/1f/8970b150a4b4365623ae00fc88603491f763c627311ae8031e3111356d6e/pydantic_core-2.46.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23ace664830ee0bfe014a0c7bc248b1f7f25ed7ad103852c317624a1083af462", size = 1952179, upload-time = "2026-05-06T13:36:59.812Z" }, + { url = "https://files.pythonhosted.org/packages/95/30/5211a831ae054928054b2f79731661087a2bc5c01e825c672b3a4a8f1b3e/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce5c1d2a8b27468f433ca974829c44060b8097eedc39933e3c206a90ee49c4a9", size = 1978926, upload-time = "2026-05-06T13:37:39.933Z" }, + { url = "https://files.pythonhosted.org/packages/57/e9/689668733b1eb67adeef047db3c2e8788fcf65a7fd9c9e2b46b7744fe245/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7283d57845ecf5a163403eb0702dfc220cc4fbdd18919cb5ccea4f95ee1cdab4", size = 2046785, upload-time = "2026-05-06T13:38:01.995Z" }, + { url = "https://files.pythonhosted.org/packages/60/d9/6715260422ff50a2109878fd24d948a6c3446bb2664f34ee78cd972b3acd/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8daafc69c93ee8a0204506a3b6b30f586ef54028f52aeeeb5c4cfc5184fd5914", size = 2228733, upload-time = "2026-05-06T13:40:50.371Z" }, + { url = "https://files.pythonhosted.org/packages/18/ae/fdb2f64316afca925640f8e70bb1a564b0ec2721c1389e25b8eb4bf9a299/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd2213145bcc2ba85884d0ac63d222fece9209678f77b9b4d76f054c561adb28", size = 2307534, upload-time = "2026-05-06T13:37:21.531Z" }, + { url = "https://files.pythonhosted.org/packages/89/1d/8eff589b45bb8190a9d12c49cfad0f176a5cbd1534908a6b5125e2886239/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a5f930472650a82629163023e630d160863fce524c616f4e5186e5de9d9a49b", size = 2099732, upload-time = "2026-05-06T13:39:31.942Z" }, + { url = "https://files.pythonhosted.org/packages/06/d5/ee5a3366637fee41dee51a1fc91562dcf12ddbc68fda34e6b253da2324bb/pydantic_core-2.46.4-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:c1b3f518abeca3aa13c712fd202306e145abf59a18b094a6bafb2d2bbf59192c", size = 2129627, upload-time = "2026-05-06T13:37:25.033Z" }, + { url = "https://files.pythonhosted.org/packages/94/33/2414be571d2c6a6c4d08be21f9292b6d3fdb08949a97b6dfe985017821db/pydantic_core-2.46.4-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a7dd0b3ee80d90150e3495a3a13ac34dbcbfd4f012996a6a1d8900e91b5c0fb", size = 2179141, upload-time = "2026-05-06T13:37:14.046Z" }, + { url = "https://files.pythonhosted.org/packages/7b/79/7daa95be995be0eecc4cf75064cb33f9bbbfe3fe0158caf2f0d4a996a5c7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:3fb702cd90b0446a3a1c5e470bfa0dd23c0233b676a9099ddcc964fa6ca13898", size = 2184325, upload-time = "2026-05-06T13:36:53.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/cb/d0a382f5c0de8a222dc61c65348e0ce831b1f68e0a018450d31c2cace3a5/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b8458003118a712e66286df6a707db01c52c0f52f7db8e4a38f0da1d3b94fc4e", size = 2323990, upload-time = "2026-05-06T13:40:29.971Z" }, + { url = "https://files.pythonhosted.org/packages/05/db/d9ba624cc4a5aced1598e88c04fdbd8310c8a69b9d38b9a3d39ce3a61ed7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:372429a130e469c9cd698925ce5fc50940b7a1336b0d82038e63d5bbc4edc519", size = 2369978, upload-time = "2026-05-06T13:37:23.027Z" }, + { url = "https://files.pythonhosted.org/packages/f2/20/d15df15ba918c423461905802bfd2981c3af0bfa0e40d05e13edbfa48bc3/pydantic_core-2.46.4-cp314-cp314-win32.whl", hash = "sha256:85bb3611ff1802f3ee7fdd7dbff26b56f343fb432d57a4728fdd49b6ef35e2f4", size = 1966354, upload-time = "2026-05-06T13:38:03.499Z" }, + { url = "https://files.pythonhosted.org/packages/fc/b6/6b8de4c0a7d7ab3004c439c80c5c1e0a3e8d78bbae19379b01960383d9e5/pydantic_core-2.46.4-cp314-cp314-win_amd64.whl", hash = "sha256:811ff8e9c313ab425368bcbb36e5c4ebd7108c2bbf4e4089cfbb0b01eff63fac", size = 2072238, upload-time = "2026-05-06T13:39:40.807Z" }, + { url = "https://files.pythonhosted.org/packages/32/36/51eb763beec1f4cf59b1db243a7dcc39cbb41230f050a09b9d69faaf0a48/pydantic_core-2.46.4-cp314-cp314-win_arm64.whl", hash = "sha256:bfec22eab3c8cc2ceec0248aec886624116dc079afa027ecc8ad4a7e62010f8a", size = 2018251, upload-time = "2026-05-06T13:37:26.72Z" }, + { url = "https://files.pythonhosted.org/packages/e8/91/855af51d625b23aa987116a19e231d2aaef9c4a415273ddc189b79a45fee/pydantic_core-2.46.4-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:af8244b2bef6aaad6d92cda81372de7f8c8d36c9f0c3ea36e827c60e7d9467a0", size = 2099593, upload-time = "2026-05-06T13:39:47.682Z" }, + { url = "https://files.pythonhosted.org/packages/fb/1b/8784a54c65edb5f49f0a14d6977cf1b209bba85a4c77445b255c2de58ab3/pydantic_core-2.46.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a4330cdbc57162e4b3aa303f588ba752257694c9c9be3e7ebb11b4aca659b5d", size = 1935226, upload-time = "2026-05-06T13:40:40.428Z" }, + { url = "https://files.pythonhosted.org/packages/e8/e7/1955d28d1afc56dd4b3ad7cc0cf39df1b9852964cf16e5d13912756d6d6b/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29c61fc04a3d840155ff08e475a04809278972fe6aef51e2720554e96367e34b", size = 1974605, upload-time = "2026-05-06T13:37:32.029Z" }, + { url = "https://files.pythonhosted.org/packages/93/e2/3fedbf0ba7a22850e6e9fd78117f1c0f10f950182344d8a6c535d468fdd8/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c50f2528cf200c5eed56faf3f4e22fcd5f38c157a8b78576e6ba3168ec35f000", size = 2030777, upload-time = "2026-05-06T13:38:55.239Z" }, + { url = "https://files.pythonhosted.org/packages/f8/61/46be275fcaaba0b4f5b9669dd852267ce1ff616592dccf7a7845588df091/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0cbe8b01f948de4286c74cdd6c667aceb38f5c1e26f0693b3983d9d74887c65e", size = 2236641, upload-time = "2026-05-06T13:37:08.096Z" }, + { url = "https://files.pythonhosted.org/packages/60/db/12e93e46a8bac9988be3c016860f83293daea8c716c029c9ace279036f2f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:617d7e2ca7dcb8c5cf6bcb8c59b8832c94b36196bbf1cbd1bfb56ed341905edd", size = 2286404, upload-time = "2026-05-06T13:40:20.221Z" }, + { url = "https://files.pythonhosted.org/packages/e2/4a/4d8b19008f38d31c53b8219cfedc2e3d5de5fe99d90076b7e767de29274f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7027560ee92211647d0d34e3f7cd6f50da56399d26a9c8ad0da286d3869a53f3", size = 2109219, upload-time = "2026-05-06T13:38:12.153Z" }, + { url = "https://files.pythonhosted.org/packages/88/70/3cbc40978fefb7bb09c6708d40d4ad1a5d70fd7213c3d17f971de868ec1f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:f99626688942fb746e545232e7726926f3be91b5975f8b55327665fafda991c7", size = 2110594, upload-time = "2026-05-06T13:40:02.971Z" }, + { url = "https://files.pythonhosted.org/packages/9d/20/b8d36736216e29491125531685b2f9e61aa5b4b2599893f8268551da3338/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fc3e9034a63de20e15e8ade85358bc6efc614008cab72898b4b4952bea0509ff", size = 2159542, upload-time = "2026-05-06T13:39:27.506Z" }, + { url = "https://files.pythonhosted.org/packages/1d/a2/367df868eb584dacf6bf82a389272406d7178e301c4ac82545ab98bc2dd9/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:97e7cf2be5c77b7d1a9713a05605d49460d02c6078d38d8bef3cbe323c548424", size = 2168146, upload-time = "2026-05-06T13:38:31.93Z" }, + { url = "https://files.pythonhosted.org/packages/c1/b8/4460f77f7e201893f649a29ab355dddd3beee8a97bcb1a320db414f9a06e/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:3bf92c5d0e00fefaab325a4d27828fe6b6e2a21848686b5b60d2d9eeb09d76c6", size = 2306309, upload-time = "2026-05-06T13:37:44.717Z" }, + { url = "https://files.pythonhosted.org/packages/64/c4/be2639293acd87dc8ddbcec41a73cee9b2ebf996fe6d892a1a74e88ad3f7/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:3ecbc122d18468d06ca279dc26a8c2e2d5acb10943bb35e36ae92096dc3b5565", size = 2369736, upload-time = "2026-05-06T13:37:05.645Z" }, + { url = "https://files.pythonhosted.org/packages/30/a6/9f9f380dbb301f67023bf8f707aaa75daadf84f7152d95c410fd7e81d994/pydantic_core-2.46.4-cp314-cp314t-win32.whl", hash = "sha256:e846ae7835bf0703ae43f534ab79a867146dadd59dc9ca5c8b53d5c8f7c9ef02", size = 1955575, upload-time = "2026-05-06T13:38:51.116Z" }, + { url = "https://files.pythonhosted.org/packages/40/1f/f1eb9eb350e795d1af8586289746f5c5677d16043040d63710e22abc43c9/pydantic_core-2.46.4-cp314-cp314t-win_amd64.whl", hash = "sha256:2108ba5c1c1eca18030634489dc544844144ee36357f2f9f780b93e7ddbb44b5", size = 2051624, upload-time = "2026-05-06T13:38:21.672Z" }, + { url = "https://files.pythonhosted.org/packages/f6/d2/42dd53d0a85c27606f316d3aa5d2869c4e8470a5ed6dec30e4a1abe19192/pydantic_core-2.46.4-cp314-cp314t-win_arm64.whl", hash = "sha256:4fcbe087dbc2068af7eda3aa87634eba216dbda64d1ae73c8684b621d33f6596", size = 2017325, upload-time = "2026-05-06T13:40:52.723Z" }, + { url = "https://files.pythonhosted.org/packages/ee/a4/73995fd4ebbb46ba0ee51e6fa049b8f02c40daebb762208feda8a6b7894d/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:14d4edf427bdcf950a8a02d7cb44a08614388dd6e1bdcbf4f67504fa7887da9c", size = 2111589, upload-time = "2026-05-06T13:37:10.817Z" }, + { url = "https://files.pythonhosted.org/packages/fb/7f/f37d3a5e8bfcc2e403f5c57a730f2d815693fb42119e8ea48b3789335af1/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:0ce40cd7b21210e99342afafbd4d0f76d784eb5b1d60f3bdc566be4983c6c73b", size = 1944552, upload-time = "2026-05-06T13:36:56.717Z" }, + { url = "https://files.pythonhosted.org/packages/15/3c/d7eb777b3ff43e8433a4efb39a17aa8fd98a4ee8561a24a67ef5db07b2d6/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:90884113d8b48f760e9587002789ddd741e76ab9f89518cd1e43b1f1a52ec44b", size = 1982984, upload-time = "2026-05-06T13:39:06.207Z" }, + { url = "https://files.pythonhosted.org/packages/63/87/70b9f40170a81afd55ca26c9b2acb25c20d64bcfbf888fafecb3ba077d4c/pydantic_core-2.46.4-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66ce7632c22d837c95301830e111ad0128a32b8207533b60896a96c4915192ea", size = 2138417, upload-time = "2026-05-06T13:39:45.476Z" }, + { url = "https://files.pythonhosted.org/packages/9d/1d/8987ad40f65ae1432753072f214fb5c74fe47ffbd0698bb9cbbb585664f8/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7", size = 2095527, upload-time = "2026-05-06T13:39:52.283Z" }, + { url = "https://files.pythonhosted.org/packages/64/d3/84c282a7eee1d3ac4c0377546ef5a1ea436ce26840d9ac3b7ed54a377507/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df", size = 1936024, upload-time = "2026-05-06T13:40:15.671Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ca/eac61596cdeb4d7e174d3dc0bd8a6238f14f75f97a24e7b7db4c7e7340a0/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526", size = 1990696, upload-time = "2026-05-06T13:38:34.717Z" }, + { url = "https://files.pythonhosted.org/packages/fa/c3/7c8b240552251faf6b3a957db200fcfbbcec36763c050428b601e0c9b83b/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0", size = 2147590, upload-time = "2026-05-06T13:39:29.883Z" }, + { url = "https://files.pythonhosted.org/packages/11/cb/428de0385b6c8d44b716feba566abfacfbd23ee3c4439faa789a1456242f/pydantic_core-2.46.4-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:0c563b08bca408dc7f65f700633d8442fffb2421fc47b8101377e9fd65051ff0", size = 2112782, upload-time = "2026-05-06T13:37:04.016Z" }, + { url = "https://files.pythonhosted.org/packages/0b/b5/6a17bdadd0fc1f170adfd05a20d37c832f52b117b4d9131da1f41bb097ce/pydantic_core-2.46.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:db06ffe51636ffe9ca531fe9023dd64bdd794be8754cb5df57c5498ae5b518a7", size = 1952146, upload-time = "2026-05-06T13:39:43.092Z" }, + { url = "https://files.pythonhosted.org/packages/2a/dc/03734d80e362cd43ef65428e9de77c730ce7f2f11c60d2b1e1b39f0fbf99/pydantic_core-2.46.4-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:133878133d271ade3d41d1bfb2a45ec38dbdbda40bc065921c6b04e4630127e2", size = 2134492, upload-time = "2026-05-06T13:36:58.124Z" }, + { url = "https://files.pythonhosted.org/packages/de/df/5e5ffc085ed07cc22d298134d3d911c63e91f6a0eb91fe646750a3209910/pydantic_core-2.46.4-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9bc519fbf2b7578398853d815009ae5e4d4603d12f4e3f91da8c06852d3da3e9", size = 2156604, upload-time = "2026-05-06T13:37:49.88Z" }, + { url = "https://files.pythonhosted.org/packages/81/44/6e112a4253e56f5705467cbab7ab5e91ee7398ba3d56d358635958893d3e/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:c7a7bd4e39e8e4c12c39cd480356842b6a8a06e41b23a55a5e3e191718838ddf", size = 2183828, upload-time = "2026-05-06T13:37:43.053Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ad/5565071e937d8e752842ac241463944c9eb14c87e2d269f2658a5bd05e98/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:d396ec2b979760aaf3218e76c24e65bd0aca24983298653b3a9d7a45f9e47b30", size = 2310000, upload-time = "2026-05-06T13:37:56.694Z" }, + { url = "https://files.pythonhosted.org/packages/4f/c3/66883a5cec183e7fba4d024b4cbbe61851a63750ef606b0afecc46d1f2bf/pydantic_core-2.46.4-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:86e1a4418c6cd97d60c95c71164158eaf7324fae7b0923264016baa993eba6fc", size = 2361286, upload-time = "2026-05-06T13:40:05.667Z" }, + { url = "https://files.pythonhosted.org/packages/4b/2d/69abac8f838090bbecd5df894befb2c2619e7996a98ddb949db9f3b93225/pydantic_core-2.46.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:d51026d73fcfd93610abc7b27789c26b313920fcfb20e27462d74a7f8b06e983", size = 2193071, upload-time = "2026-05-06T13:38:08.682Z" }, +] + +[[package]] +name = "pygments" +version = "2.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" }, +] + +[[package]] +name = "pyproject-hooks" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", hash = "sha256:1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8", size = 19228, upload-time = "2024-09-29T09:24:13.293Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", hash = "sha256:9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913", size = 10216, upload-time = "2024-09-29T09:24:11.978Z" }, +] + +[[package]] +name = "pytest" +version = "9.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" }, +] + +[[package]] +name = "pywin32-ctypes" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471, upload-time = "2024-08-14T10:15:34.626Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" }, +] + +[[package]] +name = "readme-renderer" +version = "45.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "docutils" }, + { name = "nh3" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/51/d3a6ea424652c60f05600d8c2e01a55c913755e7cdad64afabbd1aa16f44/readme_renderer-45.0.tar.gz", hash = "sha256:030a8fac74904f8fba11ad1bb6964e3f76e896dc7e5e71f16af190c9056696d1", size = 36172, upload-time = "2026-06-09T21:05:17.37Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/97/1b/295bf2fa3e740131778065e5ffa2c481f0e7210182d408e9a2c244ff5b0c/readme_renderer-45.0-py3-none-any.whl", hash = "sha256:3385ed220117104a2bceb4a9dac8c5fdf6d1f96890d7ea2a9c7174fd5c84091f", size = 14134, upload-time = "2026-06-09T21:05:15.85Z" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "requests-toolbelt" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888, upload-time = "2023-05-01T04:11:33.229Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" }, +] + +[[package]] +name = "rfc3986" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/40/1520d68bfa07ab5a6f065a186815fb6610c86fe957bc065754e47f7b0840/rfc3986-2.0.0.tar.gz", hash = "sha256:97aacf9dbd4bfd829baad6e6309fa6573aaf1be3f6fa735c8ab05e46cecb261c", size = 49026, upload-time = "2022-01-10T00:52:30.832Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ff/9a/9afaade874b2fa6c752c36f1548f718b5b83af81ed9b76628329dab81c1b/rfc3986-2.0.0-py2.py3-none-any.whl", hash = "sha256:50b1502b60e289cb37883f3dfd34532b8873c7de9f49bb546641ce9cbd256ebd", size = 31326, upload-time = "2022-01-10T00:52:29.594Z" }, +] + +[[package]] +name = "rich" +version = "15.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" }, +] + +[[package]] +name = "ruff" +version = "0.16.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/70/25/7113f6d5498888c5fb7db34081cba7d5971c4cb1bfb26819966eee68f003/ruff-0.16.1.tar.gz", hash = "sha256:fedad7c801dabd3fb9741d76aca39246e6ddd9ca446a015875207bf19f1e6bc7", size = 4877500, upload-time = "2026-07-30T19:37:01.379Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1b/bd/694da69368e0973de65df2ddc73ab18d43c469d5963d9b150911de6bc513/ruff-0.16.1-py3-none-linux_armv6l.whl", hash = "sha256:58edb313b88f0c5460a26adf5f39a37a3be789494a15e3e411e35fa78b89f9a0", size = 10839126, upload-time = "2026-07-30T19:36:13.697Z" }, + { url = "https://files.pythonhosted.org/packages/3f/f0/b626e5d5bd0dd9576263658ef12885e2288afd1029a48e26ffed65ec1ac1/ruff-0.16.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:fde5a99e2f97479af66edd6622c6d5a2a7592c77cf4153d9e4428f5eeb55b60c", size = 11070253, upload-time = "2026-07-30T19:36:17.14Z" }, + { url = "https://files.pythonhosted.org/packages/83/63/f40acfb6b35b88623e71684942b552c3edd96035f5d98f313815f7b277de/ruff-0.16.1-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e0d4c20532fca4f7fa609369161d968dd28f65d83dabbd61d8e9c7edbf7001f6", size = 10561425, upload-time = "2026-07-30T19:36:20.04Z" }, + { url = "https://files.pythonhosted.org/packages/aa/dd/14ec0e9c2b4d315547dd38765004b4863e354e1b52cb308272215d9f6f6d/ruff-0.16.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:30affbcedf59ad5703d9c91f82266e02b47739f797e1a7b6e158e5526a6dae38", size = 10948879, upload-time = "2026-07-30T19:36:22.476Z" }, + { url = "https://files.pythonhosted.org/packages/33/e9/9d870cbae575030fdef595f04b4b97573c525b5497cce4f4498cf2f85446/ruff-0.16.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:24e9c631573cbca9d20f1283f8f479b2afa4a8503504822bd71a293889f16743", size = 10643691, upload-time = "2026-07-30T19:36:24.914Z" }, + { url = "https://files.pythonhosted.org/packages/c4/09/12743d544e2173f53ecd27217c65f90d2bc0f8424a66a60339e56bbc0457/ruff-0.16.1-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b41bdd48fb420987a9b5212e4957c26ad4abce401fa9ea9d4d85843727945f4f", size = 11435354, upload-time = "2026-07-30T19:36:28.447Z" }, + { url = "https://files.pythonhosted.org/packages/7f/89/a1652b2daee52083c9554a6333b678a8b01d0400f976827bb87857f9449a/ruff-0.16.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b0d1e1393b7648079e13669de1c1f4fde06d4583e84d8fd5c1551e0a77a2aa75", size = 12259033, upload-time = "2026-07-30T19:36:31.326Z" }, + { url = "https://files.pythonhosted.org/packages/16/96/ecdcb8c54ee7b123b487f807eb014e6e019155a0b81dfb669acd52f28ce3/ruff-0.16.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:07bf434b1c95f4e093be4532068ef4fcf00924eb2ade8796075980902d6fd54a", size = 11667981, upload-time = "2026-07-30T19:36:34.394Z" }, + { url = "https://files.pythonhosted.org/packages/cd/90/c52e12e0d862e9572f2a33aa227409143520abe53111e9a6babbac7b4af8/ruff-0.16.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39897739f112253ee4fdd2e8aa9a4f9ded99fb2be367d5f31dfa4ded6025584c", size = 11468183, upload-time = "2026-07-30T19:36:37.339Z" }, + { url = "https://files.pythonhosted.org/packages/2c/6b/4ffb7ad1d83eb16cf8cbb3c8815d3f11c88460fd162d4b372a2059be1c2a/ruff-0.16.1-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:82ae3c0c0d74daf17b968a10b7b3bb3ef297ab7de0c1f749646b25e690ccb150", size = 11470071, upload-time = "2026-07-30T19:36:39.91Z" }, + { url = "https://files.pythonhosted.org/packages/9c/72/32ae7db4c0b5e32ab611787caa19d1546800676d79f7483b7100a3561bf4/ruff-0.16.1-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:4d5f2ed10f8242d83fc08d521301089364e3375375705356f20c0e31606ef3ef", size = 10919503, upload-time = "2026-07-30T19:36:42.65Z" }, + { url = "https://files.pythonhosted.org/packages/f7/ca/3d901ba6ad6fc38da39c3448fc6c59ac945679293a17c3ceb6d6c1cba13e/ruff-0.16.1-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:a4665b309891f83f3e3c25447935f1213e9abbd4b5640af7a1f2def9f8d413c1", size = 10649861, upload-time = "2026-07-30T19:36:45.18Z" }, + { url = "https://files.pythonhosted.org/packages/92/79/894ef1ced26552d5f8c9cf6d85b0687840e1128c55aeab7b9c2d54a0d880/ruff-0.16.1-py3-none-musllinux_1_2_i686.whl", hash = "sha256:26e9ca5c9bc3971f20d3cf18a957f52ffd6a5f6564ff15c4912a144dcac22494", size = 11148137, upload-time = "2026-07-30T19:36:47.936Z" }, + { url = "https://files.pythonhosted.org/packages/2d/69/3609a09fa1cb46cc28b762363e440a354204e5dff01bd0c8d7437874d6b9/ruff-0.16.1-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:67e1e1e3fa4f0c82f0e36d4cd61e661f6e7a6196cb1aa92fe0828fa7b8f257cd", size = 11559211, upload-time = "2026-07-30T19:36:50.448Z" }, + { url = "https://files.pythonhosted.org/packages/fc/8a/fb22af2fd78a736e241fabf67e30ce1799a64244026377a49e133af90762/ruff-0.16.1-py3-none-win32.whl", hash = "sha256:d31765e131295b8445caf301e3e8a85b34d1b9b211b4109b7ba457888b051806", size = 10838258, upload-time = "2026-07-30T19:36:53.298Z" }, + { url = "https://files.pythonhosted.org/packages/d4/35/e57fd9fb5d423961df087a00b12d42c0a830288dc2f3b45ecca299158b4f/ruff-0.16.1-py3-none-win_amd64.whl", hash = "sha256:09b05e8b90c2cb06ad63464350e7a45e8e44a2dfe52072ebfba6666ca8d3f596", size = 11961111, upload-time = "2026-07-30T19:36:56.107Z" }, + { url = "https://files.pythonhosted.org/packages/cb/46/240ea004bf6dc4feb40e9832f2205a476a47dd5b8a3f8211a5fc5f95e20e/ruff-0.16.1-py3-none-win_arm64.whl", hash = "sha256:dbaadaac38c70239f056d306b7476f246b0bf000fa6b3876402acbf5b227eaf8", size = 11309414, upload-time = "2026-07-30T19:36:58.79Z" }, +] + +[[package]] +name = "secretstorage" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography" }, + { name = "jeepney" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/46/f5af3402b579fd5e11573ce652019a67074317e18c1935cc0b4ba9b35552/secretstorage-3.5.0-py3-none-any.whl", hash = "sha256:0ce65888c0725fcb2c5bc0fdb8e5438eece02c523557ea40ce0703c266248137", size = 15554, upload-time = "2025-11-23T19:02:51.545Z" }, +] + +[[package]] +name = "tomli" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" }, + { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" }, + { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" }, + { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" }, + { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" }, + { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" }, + { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" }, + { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" }, + { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" }, + { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" }, + { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" }, + { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" }, + { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" }, + { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" }, + { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" }, + { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" }, + { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" }, + { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" }, + { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" }, + { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" }, + { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" }, + { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" }, + { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" }, + { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" }, + { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" }, + { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" }, + { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" }, + { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" }, + { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" }, + { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" }, + { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" }, + { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" }, + { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" }, + { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" }, + { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" }, + { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" }, +] + +[[package]] +name = "twine" +version = "7.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "id" }, + { name = "keyring", marker = "platform_machine != 'ppc64le' and platform_machine != 's390x'" }, + { name = "packaging" }, + { name = "readme-renderer" }, + { name = "requests" }, + { name = "requests-toolbelt" }, + { name = "rfc3986" }, + { name = "rich" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/92/3c/58f808a359700f39a967dffede33efeac809262c03303fa3eec6afff8f49/twine-7.0.0.tar.gz", hash = "sha256:85cdb29c518efef867360ae4acd4b0dfd61c8654a22fca08e6f8539f05022177", size = 215032, upload-time = "2026-07-27T15:59:00.825Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/08/ddcdc06225eaad6de0e48e1002b06d919dbde20582d0662c7af51308e5d6/twine-7.0.0-py3-none-any.whl", hash = "sha256:b854164df26db268af05f49aa5c0344b10e27a494343ff05b1e0bad3b135f5a7", size = 43204, upload-time = "2026-07-27T15:58:59.26Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" }, +] + +[[package]] +name = "urllib3" +version = "2.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" }, +] + +[[package]] +name = "zipp" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b9/d8/eab98a517c14134c0b2eb4e2387bc5f457334293ec5d2dd3857ec2966802/zipp-4.1.0.tar.gz", hash = "sha256:4cb57381f544315db7688e976e922a2b18cdb513d21cc194eb42232ba2a3e602", size = 26214, upload-time = "2026-05-18T20:08:57.967Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/13/547360d81e6d88d58492968ffda9f9542854f11310ee556fef14260cc886/zipp-4.1.0-py3-none-any.whl", hash = "sha256:25ad4e16390cd314347dd8f1de67a2ac538ae658ed4ab9db16029c07c188e97f", size = 10238, upload-time = "2026-05-18T20:08:57.045Z" }, +] diff --git a/tests/python-codegen.test.ts b/tests/python-codegen.test.ts new file mode 100644 index 0000000..343a671 --- /dev/null +++ b/tests/python-codegen.test.ts @@ -0,0 +1,28 @@ +import fs from "node:fs"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; +import { describe, expect, it } from "vitest"; +import { pythonLiteral, typeName } from "../packages/modelparams-python/scripts/codegen.js"; + +const here = path.dirname(fileURLToPath(import.meta.url)); +const releaseWorkflow = fs.readFileSync( + path.resolve(here, "..", ".github", "workflows", "release-modelparams-python.yml"), + "utf8", +); + +describe("Python code generation", () => { + it("prefixes generated types when a model ID starts with a digit", () => { + expect(typeName({ model: "4o-mini", authType: "api_key" })).toBe("Model_4o_MiniParams"); + }); + + it("fails clearly for float enum values unsupported by typing.Literal", () => { + expect(() => pythonLiteral(0.5)).toThrow(/non-integer enum value 0.5/); + }); +}); + +describe("Python release workflow", () => { + it("publishes idempotently and tags the triggering commit", () => { + expect(releaseWorkflow).toContain("skip-existing: true"); + expect(releaseWorkflow).toContain("target_commitish: ${{ github.sha }}"); + }); +}); diff --git a/tests/python-package-version.test.ts b/tests/python-package-version.test.ts new file mode 100644 index 0000000..f8bb27e --- /dev/null +++ b/tests/python-package-version.test.ts @@ -0,0 +1,58 @@ +import { describe, expect, it } from "vitest"; +import { + compareVersions, + decidePythonRelease, +} from "../packages/modelparams-python/scripts/lib/version.js"; + +const unchanged = { + seedVersion: "0.0.1", + latestVersion: "0.2.3", + forcedLevel: null, + catalogChanged: false, + packageChanged: false, + hasParamRemovals: false, +} as const; + +describe("decidePythonRelease", () => { + it("uses the seed for the first independent Python release", () => { + expect(decidePythonRelease({ ...unchanged, latestVersion: null })).toEqual({ + level: "patch", + nextVersion: "0.0.1", + }); + }); + + it("patches for catalog and Python-only changes", () => { + expect(decidePythonRelease({ ...unchanged, catalogChanged: true }).nextVersion).toBe("0.2.4"); + expect(decidePythonRelease({ ...unchanged, packageChanged: true }).nextVersion).toBe("0.2.4"); + }); + + it("bumps major when an existing model parameter is removed", () => { + expect(decidePythonRelease({ ...unchanged, hasParamRemovals: true })).toEqual({ + level: "major", + nextVersion: "1.0.0", + }); + }); + + it("skips when nothing relevant changed", () => { + expect(decidePythonRelease(unchanged)).toEqual({ level: null, nextVersion: null }); + }); + + it("honors a forced release level", () => { + expect(decidePythonRelease({ ...unchanged, forcedLevel: "patch" })).toEqual({ + level: "patch", + nextVersion: "0.2.4", + }); + expect(decidePythonRelease({ ...unchanged, forcedLevel: "major" })).toEqual({ + level: "major", + nextVersion: "1.0.0", + }); + }); +}); + +describe("compareVersions", () => { + it("compares each semantic-version component independently", () => { + expect(compareVersions("0.1.1001", "0.2.0")).toBeLessThan(0); + expect(compareVersions("1.0.0", "0.9999.9999")).toBeGreaterThan(0); + expect(compareVersions("12.34.56", "12.34.56")).toBe(0); + }); +});