@llumiverse/common 1.1.0 → 1.2.0

package/src/options/version-parsing.ts

@@ -0,0 +1,360 @@
+/**
+ * Version parsing utilities for Claude and Gemini models.
+ *
+ * Provides version detection helpers that are forward-compatible with future
+ * model releases (e.g., Haiku 4.7, Sonnet 4.7, Opus 4.8, Opus 5).
+ *
+ * These helpers are used to:
+ * - Control option visibility in the UI
+ * - Construct appropriate API payloads for each model version
+ *
+ * Note: llumiverse does NOT validate options here. Errors from invalid
+ * parameters propagate to the provider side.
+ */
+
+// ============================================================================
+// Claude Version Parsing
+// ============================================================================
+
+/**
+ * Parsed Claude model version information.
+ */
+export interface ClaudeVersion {
+    /** Major version number (e.g., 3, 4, 5) */
+    major: number;
+    /** Minor version number (e.g., 5, 6, 7) */
+    minor: number;
+    /** Model variant: opus, sonnet, or haiku */
+    variant: 'opus' | 'sonnet' | 'haiku';
+}
+
+/**
+ * Parse Claude model version from a model string.
+ *
+ * Examples:
+ * - "claude-opus-4-7" -> { major: 4, minor: 7, variant: 'opus' }
+ * - "claude-sonnet-4-6" -> { major: 4, minor: 6, variant: 'sonnet' }
+ * - "claude-3-7-sonnet-20250219" -> { major: 3, minor: 7, variant: 'sonnet' }
+ * - "claude-opus-4-6" -> { major: 4, minor: 6, variant: 'opus' }
+ *
+ * @param modelString - The model identifier string
+ * @returns Parsed version info, or null if not parseable
+ */
+export function parseClaudeVersion(modelString: string): ClaudeVersion | null {
+    // Match pattern: claude-[variant-]-{major}-[optional minor]
+    // The minor version is limited to 1-2 digits to avoid matching dates (YYYYMMDD format)
+    const match = modelString.match(/claude-(opus|sonnet|haiku)-?(\d+)(?:-(\d{1,2}))?(?:-|\b)/i);
+    if (match) {
+        const variant = match[1].toLowerCase() as 'opus' | 'sonnet' | 'haiku';
+        const major = parseInt(match[2], 10);
+        const minor = match[3] ? parseInt(match[3], 10) : 0;
+        return { major, minor, variant };
+    }
+
+    // Fallback for older format: claude-3-7-sonnet-20250219
+    const fallbackMatch = modelString.match(/claude-(\d+)-(\d+)-(\w+)/i);
+    if (fallbackMatch) {
+        const major = parseInt(fallbackMatch[1], 10);
+        const minor = parseInt(fallbackMatch[2], 10);
+        const variant = fallbackMatch[3].toLowerCase() as 'opus' | 'sonnet' | 'haiku';
+        return { major, minor, variant };
+    }
+
+    return null;
+}
+
+/**
+ * Check if a Claude model version is greater than or equal to a target version.
+ *
+ * @param modelString - The model identifier string
+ * @param targetMajor - Target major version
+ * @param targetMinor - Target minor version
+ * @returns true if the model version is >= target version, false otherwise
+ */
+export function isClaudeVersionGTE(modelString: string, targetMajor: number, targetMinor: number): boolean {
+    const version = parseClaudeVersion(modelString);
+    if (!version) {
+        return false;
+    }
+    if (version.major > targetMajor) {
+        return true;
+    }
+    if (version.major === targetMajor && version.minor >= targetMinor) {
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Check if a Claude variant model version is greater than or equal to a target version.
+ *
+ * @param modelString - The model identifier string
+ * @param variant - Model variant: "opus" or "sonnet"
+ * @param targetMajor - Target major version
+ * @param targetMinor - Target minor version
+ * @returns true if the model matches the variant and version >= target
+ */
+function isClaudeVariantVersionGTE(
+    modelString: string,
+    variant: "opus" | "sonnet",
+    targetMajor: number,
+    targetMinor: number
+): boolean {
+    const version = parseClaudeVersion(modelString);
+    if (!version) return false;
+    if (version.variant.toLowerCase() !== variant) return false;
+    return version.major > targetMajor || (version.major === targetMajor && version.minor >= targetMinor);
+}
+
+/**
+ * Check if a model requires sampling parameter removal (behavior: sampling params removed on Opus 4.7+).
+ *
+ * This includes:
+ * - claude-opus-4-7
+ * - Future Opus 4.x with minor >= 7
+ * - Future Opus 5.x+
+ *
+ * @param modelString - The model identifier string
+ * @returns true if Opus 4.7+ or equivalent future model
+ */
+export function hasSamplingParameterRemoval(modelString: string): boolean {
+    return isClaudeVariantVersionGTE(modelString, "opus", 4, 7);
+}
+
+/**
+ * Check if a model requires adaptive thinking (behavior: adaptive thinking required on Opus 4.6+).
+ *
+ * This includes:
+ * - claude-opus-4-6
+ * - claude-opus-4-7
+ * - Future Opus 4.x with minor >= 6
+ * - Future Opus 5.x+
+ *
+ * @param modelString - The model identifier string
+ * @returns true if Opus 4.6+ or equivalent future model
+ */
+export function requiresAdaptiveThinking(modelString: string): boolean {
+    return isClaudeVariantVersionGTE(modelString, "opus", 4, 6);
+}
+
+/**
+ * Check if a model supports adaptive thinking.
+ *
+ * Adaptive thinking was introduced in:
+ * - Claude Opus 4.6
+ * - Claude Sonnet 4.6
+ *
+ * @param modelString - The model identifier string
+ * @returns true if the model supports adaptive thinking
+ */
+export function supportsAdaptiveThinking(modelString: string): boolean {
+    return requiresAdaptiveThinking(modelString) || isClaudeVariantVersionGTE(modelString, "sonnet", 4, 6);
+}
+
+/**
+ * Check if extended thinking is deprecated for this model.
+ *
+ * Extended thinking (thinking.type: "enabled" with budget_tokens) is deprecated
+ * but still functional on:
+ * - Claude Opus 4.6+
+ * - Claude Sonnet 4.6+
+ *
+ * @param modelString - The model identifier string
+ * @returns true if extended thinking is deprecated (adaptive thinking recommended)
+ */
+export function isExtendedThinkingDeprecated(modelString: string): boolean {
+    return supportsAdaptiveThinking(modelString);
+}
+
+/**
+ * Check if a model requires adaptive thinking ONLY (extended thinking removed).
+ *
+ * On Opus 4.7+, extended thinking returns a 400 error. Only adaptive thinking is supported.
+ * Future models (Sonnet 4.7+, Haiku 4.7+, any 5.0+) follow the same pattern.
+ *
+ * @param modelString - The model identifier string
+ * @returns true if extended thinking is removed (returns 400 error)
+ */
+export function requiresAdaptiveThinkingOnly(modelString: string): boolean {
+    return hasSamplingParameterRestriction(modelString);
+}
+
+/**
+ * Check if a model has sampling parameter restrictions.
+ *
+ * On Opus 4.7+, setting temperature, top_p, or top_k to any non-default value
+ * returns a 400 error. Future models following the same pattern will also match:
+ * - Opus 4.7+ (current restriction)
+ * - Sonnet 4.7+, Haiku 4.7+ (future minor versions >= 7)
+ * - Sonnet 5.0+, Haiku 5.0+, Opus 5.0+ (future major versions)
+ *
+ * @param modelString - The model identifier string
+ * @returns true if sampling parameters are restricted
+ */
+export function hasSamplingParameterRestriction(modelString: string): boolean {
+    const version = parseClaudeVersion(modelString);
+    if (!version) {
+        return false;
+    }
+
+    // Future major versions (5.0+) follow the same pattern as 4.7
+    if (version.major > 4) {
+        return true;
+    }
+
+    // Version 4.7+ (Opus 4.7, Sonnet 4.7, Haiku 4.7, etc.)
+    if (version.major === 4 && version.minor >= 7) {
+        return true;
+    }
+
+    return false;
+}
+
+// ============================================================================
+// Claude Effort Parameter Support
+// ============================================================================
+
+/** Available effort levels for Claude models. */
+export type ClaudeEffortLevel = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+
+/**
+ * Check if a model supports the effort parameter.
+ *
+ * Effort is supported on:
+ * - Claude Opus 4.5+
+ * - Claude Opus 4.6+
+ * - Claude Sonnet 4.6+
+ * - All variants at 4.7+ (Opus, Sonnet, Haiku)
+ * - All variants at 5.0+
+ *
+ * @param modelString - The model identifier string
+ * @returns true if the model supports the effort parameter
+ */
+export function supportsEffort(modelString: string): boolean {
+    // All 4.7+ variants support effort (covers future Sonnet 4.7, Haiku 4.7, etc.)
+    if (hasSamplingParameterRestriction(modelString)) {
+        return true;
+    }
+    // Opus 4.5+ supports effort
+    if (isClaudeVariantVersionGTE(modelString, "opus", 4, 5)) {
+        return true;
+    }
+    // Sonnet 4.6+ supports effort
+    if (isClaudeVariantVersionGTE(modelString, "sonnet", 4, 6)) {
+        return true;
+    }
+    return false;
+}
+
+/**
+ * Check if a model supports the xhigh effort level.
+ *
+ * xhigh is only available on Opus 4.7+.
+ *
+ * @param modelString - The model identifier string
+ * @returns true if the model supports xhigh effort
+ */
+export function supportsXHighEffort(modelString: string): boolean {
+    return isClaudeVariantVersionGTE(modelString, "opus", 4, 7);
+}
+
+/**
+ * Get the available effort levels for a given Claude model.
+ *
+ * - Opus 4.7+: low, medium, high, xhigh, max
+ * - Opus 4.5+, Opus 4.6+, Sonnet 4.6+: low, medium, high, max
+ * - Other models: empty (effort not supported)
+ *
+ * @param modelString - The model identifier string
+ * @returns Record of display label to effort level value, or null if not supported
+ */
+export function getAvailableEffortLevels(modelString: string): Record<string, ClaudeEffortLevel> | null {
+    if (!supportsEffort(modelString)) {
+        return null;
+    }
+    const levels: Record<string, ClaudeEffortLevel> = {
+        "Low": "low",
+        "Medium": "medium",
+        "High (default)": "high",
+        "Max": "max",
+    };
+    if (supportsXHighEffort(modelString)) {
+        // Insert xhigh between high and max
+        return {
+            "Low": "low",
+            "Medium": "medium",
+            "High (default)": "high",
+            "Extra High": "xhigh",
+            "Max": "max",
+        };
+    }
+    return levels;
+}
+
+// ============================================================================
+// Gemini Version Parsing
+// ============================================================================
+
+/**
+ * Extract Gemini version from a model ID.
+ *
+ * Examples:
+ * - "locations/global/publishers/google/models/gemini-2.5-flash" -> "2.5"
+ * - "publishers/google/models/gemini-3-pro-image-preview" -> "3"
+ * - "gemini-3.1-flash-lite-preview" -> "3.1"
+ *
+ * @param modelId - The model identifier string
+ * @returns Version string (e.g., "2.5", "3", "3.1"), or undefined if not parseable
+ */
+export function getGeminiModelVersion(modelId: string): string | undefined {
+    const modelName = modelId.split('/').pop() ?? modelId;
+    const match = modelName.match(/^gemini-(\d+(?:\.\d+)?)/i);
+    return match?.[1];
+}
+
+/**
+ * Parse a version string into major.minor components.
+ *
+ * @param version - Version string (e.g., "2.5", "3", "3.1")
+ * @returns Parsed version, or undefined if not parseable
+ */
+export function parseGeminiVersion(version: string): { major: number; minor: number } | undefined {
+    const match = version.match(/^(\d+)(?:\.(\d+))?$/);
+    if (!match) {
+        return undefined;
+    }
+
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2] ?? '0'),
+    };
+}
+
+/**
+ * Check if a Gemini model version is greater than or equal to a minimum version.
+ *
+ * @param modelId - The model identifier string
+ * @param minVersion - Minimum version string (e.g., "2.5", "3.0")
+ * @returns true if model version >= min version
+ */
+export function isGeminiModelVersionGte(modelId: string, minVersion: string): boolean {
+    const modelVersion = getGeminiModelVersion(modelId);
+    if (!modelVersion) {
+        return false;
+    }
+
+    const current = parseGeminiVersion(modelVersion);
+    const target = parseGeminiVersion(minVersion);
+    if (!current || !target) {
+        return false;
+    }
+
+    if (current.major > target.major) {
+        return true;
+    }
+    if (current.major < target.major) {
+        return false;
+    }
+
+    return current.minor >= target.minor;
+}

package/src/options/vertexai.ts

@@ -1,6 +1,17 @@
-import { ModelOptionInfoItem, ModelOptions, ModelOptionsInfo, OptionType, SharedOptions } from "../types.js";
-import { getMaxOutputTokens } from "./context-windows.js";
+import { type ModelOptionInfoItem, type ModelOptions, type ModelOptionsInfo, OptionType, SharedOptions } from "../types.js";
 import { textOptionsFallback } from "./fallback.js";
+import {
+    buildClaudeCacheOptions,
+    buildClaudeCacheTtlOptions,
+    buildClaudeEffortOptions,
+    buildClaudeIncludeThoughtsOption,
+    buildClaudeThinkingBudgetOption,
+    getClaudeMaxTokensLimit,
+} from "./shared-parsing.js";
+import {
+    hasSamplingParameterRestriction,
+    isGeminiModelVersionGte,
+} from "./version-parsing.js";
 
 // Union type of all VertexAI options
 export type VertexAIOptions = ImagenOptions | VertexAIClaudeOptions | VertexAIGeminiOptions;
@@ -67,7 +78,7 @@ export interface VertexAIClaudeOptions {
     top_p?: number;
     top_k?: number;
     stop_sequence?: string[];
-    thinking_mode?: boolean;
+    effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     thinking_budget_tokens?: number;
     include_thoughts?: boolean;
     cache_enabled?: boolean;
@@ -84,6 +95,7 @@ export interface VertexAIGeminiOptions {
     presence_penalty?: number;
     frequency_penalty?: number;
     seed?: number;
+    effort?: 'low' | 'medium' | 'high';
     include_thoughts?: boolean;
     thinking_budget_tokens?: number;
     thinking_level?: ThinkingLevel;
@@ -124,142 +136,6 @@ export function getVertexAiOptions(model: string, option?: ModelOptions): ModelO
     return textOptionsFallback;
 }
 
-/**
- * Extract Gemini version from a model ID.
- *
- * Examples:
- * - locations/global/publishers/google/models/gemini-2.5-flash -> 2.5
- * - publishers/google/models/gemini-3-pro-image-preview -> 3
- */
-export function getGeminiModelVersion(modelId: string): string | undefined {
-    const modelName = modelId.split('/').pop() ?? modelId;
-    const match = modelName.match(/^gemini-(\d+(?:\.\d+)?)/i);
-    return match?.[1];
-}
-
-function parseVersion(version: string): { major: number; minor: number } | undefined {
-    const match = version.match(/^(\d+)(?:\.(\d+))?$/);
-    if (!match) {
-        return undefined;
-    }
-
-    return {
-        major: Number(match[1]),
-        minor: Number(match[2] ?? '0'),
-    };
-}
-
-export function isGeminiModelVersionGte(modelId: string, minVersion: string): boolean {
-    const modelVersion = getGeminiModelVersion(modelId);
-    if (!modelVersion) {
-        return false;
-    }
-
-    const current = parseVersion(modelVersion);
-    const target = parseVersion(minVersion);
-    if (!current || !target) {
-        return false;
-    }
-
-    if (current.major > target.major) {
-        return true;
-    }
-    if (current.major < target.major) {
-        return false;
-    }
-
-    return current.minor >= target.minor;
-}
-
-function getGeminiThinkingLevels(model: string): {
-    levels: Record<string, ThinkingLevel>;
-    defaultLevel: ThinkingLevel;
-} {
-    const normalized = model.toLowerCase();
-    const isGemini3OrLater = isGeminiModelVersionGte(model, "3.0");
-    const isGemini31OrLater = isGeminiModelVersionGte(model, "3.1");
-    const isFlashLite = normalized.includes("flash-lite");
-    const isFlash = normalized.includes("flash") && !isFlashLite;
-    const isPro = normalized.includes("pro");
-
-    // Gemini 3 / 3.1 thinking_level support summary:
-    // - MINIMAL: Gemini 3 Flash and Gemini 3.1 Flash-Lite only.
-    //   Gemini 3.1 Flash-Lite defaults to MINIMAL.
-    // - LOW: Supported by Gemini 3+ models.
-    // - MEDIUM: Gemini 3 Flash, Gemini 3.1 Pro, Gemini 3.1 Flash-Lite.
-    // - HIGH: Supported by Gemini 3+ models.
-    // - Thinking cannot be turned off for Gemini 3 Pro and Gemini 3.1 Pro.
-    if (isFlashLite && isGemini31OrLater) {
-        return {
-            levels: {
-                "Minimal": ThinkingLevel.MINIMAL,
-                "Low": ThinkingLevel.LOW,
-                "Medium": ThinkingLevel.MEDIUM,
-                "High": ThinkingLevel.HIGH,
-            },
-            defaultLevel: ThinkingLevel.MINIMAL,
-        };
-    }
-
-    // Gemini 3+ Flash supports MINIMAL and MEDIUM in addition to LOW/HIGH.
-    if (isFlash) {
-        return {
-            levels: {
-                "Minimal": ThinkingLevel.MINIMAL,
-                "Low": ThinkingLevel.LOW,
-                "Medium": ThinkingLevel.MEDIUM,
-                "High": ThinkingLevel.HIGH,
-            },
-            defaultLevel: ThinkingLevel.MINIMAL,
-        };
-    }
-
-    // Gemini 3.1 Pro adds MEDIUM, but does not support turning thinking off.
-    if (isPro && isGemini31OrLater) {
-        return {
-            levels: {
-                "Low": ThinkingLevel.LOW,
-                "Medium": ThinkingLevel.MEDIUM,
-                "High": ThinkingLevel.HIGH,
-            },
-            defaultLevel: ThinkingLevel.LOW,
-        };
-    }
-
-    // Gemini 3 Pro supports LOW/HIGH. Thinking cannot be turned off.
-    if (isPro) {
-        return {
-            levels: {
-                "Low": ThinkingLevel.LOW,
-                "High": ThinkingLevel.HIGH,
-            },
-            defaultLevel: ThinkingLevel.LOW,
-        };
-    }
-
-    // Fallback for unknown Gemini 3+/4+ families:
-    // prefer future-safe propagation by enabling the guaranteed baseline levels.
-    if (isGemini3OrLater) {
-        return {
-            levels: {
-                "Low": ThinkingLevel.LOW,
-                "Medium": ThinkingLevel.MEDIUM,
-                "High": ThinkingLevel.HIGH,
-            },
-            defaultLevel: ThinkingLevel.LOW,
-        };
-    }
-
-    // Non-3.x models should not reach this helper in normal flow.
-    return {
-        levels: {
-            "Low": ThinkingLevel.LOW,
-            "High": ThinkingLevel.HIGH,
-        },
-        defaultLevel: ThinkingLevel.LOW,
-    };
-}
-
 function getImagenOptions(model: string, option?: ModelOptions): ModelOptionsInfo {
     const commonOptions: ModelOptionInfoItem[] = [
         {
@@ -414,8 +290,17 @@ function getImagenOptions(model: string, option?: ModelOptions): ModelOptionsInf
     return textOptionsFallback;
 }
 
+function getGeminiEffortOptions(model: string): Record<string, string> {
+    if (model.includes("gemini-3-pro-image")) {
+        return { "High": "high" };
+    }
+    if (model.includes("gemini-3.1-flash-image")) {
+        return { "Low": "low", "High": "high" };
+    }
+    return { "Low": "low", "Medium": "medium", "High": "high" };
+}
+
 function getGeminiThinkingOptionItems(model: string): ModelOptionInfoItem[] {
-    const thinkingLevelConfig = getGeminiThinkingLevels(model);
     return [
         {
             name: "include_thoughts",
@@ -424,10 +309,9 @@ function getGeminiThinkingOptionItems(model: string): ModelOptionInfoItem[] {
             description: "Include the model's reasoning process in the response"
         },
         {
-            name: "thinking_level",
+            name: SharedOptions.effort,
             type: OptionType.enum,
-            enum: thinkingLevelConfig.levels,
-            default: thinkingLevelConfig.defaultLevel,
+            enum: getGeminiEffortOptions(model),
             description: "Higher thinking levels may improve quality, but increase response times and token costs"
         }
     ];
@@ -669,77 +553,35 @@ function getGeminiOptions(model: string, option?: ModelOptions): ModelOptionsInf
 function getClaudeOptions(model: string, option?: ModelOptions): ModelOptionsInfo {
     const max_tokens_limit = getClaudeMaxTokensLimit(model);
     const excludeOptions = ["max_tokens", "presence_penalty", "frequency_penalty"];
-    const commonOptions = textOptionsFallback.options.filter((option) => !excludeOptions.includes(option.name));
+    let commonOptions = textOptionsFallback.options.filter((option) => !excludeOptions.includes(option.name));
+
+    // Opus 4.7+ models no longer support temperature, top_p, top_k (returns 400 error)
+    // Opus 4.6 and Sonnet 4.6 still support these parameters
+    const hasSamplingRestriction = hasSamplingParameterRestriction(model);
+    if (hasSamplingRestriction) {
+        commonOptions = commonOptions.filter((option) =>
+            option.name !== SharedOptions.temperature &&
+            option.name !== SharedOptions.top_p &&
+            option.name !== "top_k"
+        );
+    }
+
     const max_tokens: ModelOptionInfoItem[] = [{
         name: SharedOptions.max_tokens, type: OptionType.numeric, min: 1, max: max_tokens_limit,
         integer: true, step: 200, description: "The maximum number of tokens to generate"
     }];
 
-    const claudeCacheOptions: ModelOptionInfoItem[] = [
-        {
-            name: "cache_enabled",
-            type: OptionType.boolean,
-            default: false,
-            description: "Enable prompt caching. Injects cache breakpoints at the system prompt, tools, and conversation pivot.",
-        },
-    ];
-    const claudeCacheTtlOptions: ModelOptionInfoItem[] = (option as VertexAIClaudeOptions)?.cache_enabled ? [
-        {
-            name: "cache_ttl",
-            type: OptionType.enum,
-            enum: { "5 minutes (default)": "5m", "1 hour": "1h" },
-            default: "5m",
-            description: "TTL for cache breakpoints. '1h' requires extended caching to be enabled on your account.",
-        }
-    ] : [];
-
-    if (model.includes("-3-7") || model.includes("-4")) {
-        const claudeModeOptions: ModelOptionInfoItem[] = [
-            {
-                name: "thinking_mode",
-                type: OptionType.boolean,
-                default: false,
-                description: "If true, use the extended reasoning mode"
-            },
-        ];
-        const claudeThinkingOptions: ModelOptionInfoItem[] = (option as VertexAIClaudeOptions)?.thinking_mode ? [
-            {
-                name: "thinking_budget_tokens",
-                type: OptionType.numeric,
-                min: 1024,
-                default: 1024,
-                integer: true,
-                step: 100,
-                description: "The target number of tokens to use for reasoning, not a hard limit."
-            },
-            {
-                name: "include_thoughts",
-                type: OptionType.boolean,
-                default: false,
-                description: "Include the model's reasoning process in the response"
-            }
-        ] : [];
-
-        return {
-            _option_id: "vertexai-claude",
-            options: [
-                ...max_tokens,
-                ...commonOptions,
-                ...claudeModeOptions,
-                ...claudeThinkingOptions,
-                ...claudeCacheOptions,
-                ...claudeCacheTtlOptions,
-            ]
-        };
-    }
     return {
         _option_id: "vertexai-claude",
         options: [
             ...max_tokens,
             ...commonOptions,
-            ...claudeCacheOptions,
-            ...claudeCacheTtlOptions,
-        ]
+            ...buildClaudeEffortOptions(model),
+            ...buildClaudeThinkingBudgetOption(model),
+            ...buildClaudeIncludeThoughtsOption(model),
+            ...buildClaudeCacheOptions(),
+            ...buildClaudeCacheTtlOptions((option as VertexAIClaudeOptions)?.cache_enabled),
+        ],
     };
 }
 
@@ -788,13 +630,6 @@ function getGeminiMaxTokensLimit(model: string): number {
     return 8192;
 }
 
-// Delegate to provider-agnostic limits,
-// override only where VertexAI supports extended output (128K for 3.7)
-function getClaudeMaxTokensLimit(model: string): number {
-    if (model.includes('-3-7')) return 128000;
-    return getMaxOutputTokens(model);
-}
-
 function getLlamaMaxTokensLimit(_model: string): number {
     return 8192;
 }

package/src/types.ts

@@ -82,7 +82,7 @@ export const ProviderList: Record<Providers, ProviderParams> = {
     },
     vertexai: {
         id: Providers.vertexai,
-        name: "Google Vertex AI",
+        name: "Google Agent Platform (Vertex AI)",
         requiresApiKey: false,
         requiresEndpointUrl: false,
         supportSearch: false,
@@ -559,6 +559,7 @@ export enum SharedOptions {
     presence_penalty = "presence_penalty",
     frequency_penalty = "frequency_penalty",
     stop_sequence = "stop_sequence",
+    effort = "effort",
 
     //Image
     seed = "seed",
@@ -572,6 +573,8 @@ export enum OptionType {
     string_list = "string_list"
 }
 
+export type ReasoningEffort = "low" | "medium" | "high";
+
 // ============== Model Options ===============
 
 export type ModelOptions = TextFallbackOptions | VertexAIOptions | BedrockOptions | OpenAiOptions | GroqOptions;