@llumiverse/common 1.1.0 → 1.2.0

package/src/options/bedrock.ts

@@ -1,6 +1,13 @@
-import { ModelOptionsInfo, ModelOptions, OptionType, ModelOptionInfoItem } from "../types.js";
-import { getMaxOutputTokens } from "./context-windows.js";
-import { textOptionsFallback } from "./fallback.js";
+import { type ModelOptionInfoItem, type ModelOptions, type ModelOptionsInfo, OptionType } from "../types.js";
+import {
+    buildClaudeCacheOptions,
+    buildClaudeCacheTtlOptions,
+    buildClaudeEffortOptions,
+    buildClaudeIncludeThoughtsOption,
+    buildClaudeThinkingBudgetOption,
+    getClaudeMaxTokensLimit,
+} from "./shared-parsing.js";
+import { hasSamplingParameterRestriction } from "./version-parsing.js";
 
 // Union type of all Bedrock options
 export type BedrockOptions = NovaCanvasOptions | BaseConverseOptions | BedrockClaudeOptions | BedrockPalmyraOptions | BedrockGptOssOptions | TwelvelabsPegasusOptions;
@@ -32,9 +39,9 @@ export interface BaseConverseOptions {
 export interface BedrockClaudeOptions extends BaseConverseOptions {
     _option_id: "bedrock-claude";
     top_k?: number;
-    thinking_mode?: boolean;
     thinking_budget_tokens?: number;
     include_thoughts?: boolean;
+    effort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     cache_enabled?: boolean;
     cache_ttl?: '5m' | '1h';
 }
@@ -61,11 +68,9 @@ export interface TwelvelabsPegasusOptions {
 }
 
 export function getMaxTokensLimitBedrock(model: string): number | undefined {
-    // Claude models — delegate to provider-agnostic limits,
-    // override only where Bedrock supports extended output (128K for 3.7)
+    // Claude models — delegate to shared limit logic (128K for 3.7 and Opus 4.7+)
     if (model.includes("claude")) {
-        if (model.includes("-3-7-")) return 128000;
-        return getMaxOutputTokens(model);
+        return getClaudeMaxTokensLimit(model);
     }
     // Amazon models
     else if (model.includes("amazon")) {
@@ -229,6 +234,9 @@ export function getBedrockOptions(model: string, option?: ModelOptions): ModelOp
     } else {
         const max_tokens_limit = getMaxTokensLimitBedrock(model);
         //Not canvas, i.e normal AWS bedrock converse
+        // 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);
         const baseConverseOptions: ModelOptionInfoItem[] = [
             {
                 name: "max_tokens",
@@ -239,31 +247,38 @@ export function getBedrockOptions(model: string, option?: ModelOptions): ModelOp
                 step: 200,
                 description: "The maximum number of tokens to generate",
             },
-            {
+        ];
+
+        // Opus 4.7+ models don't support temperature, top_p
+        if (!hasSamplingRestriction) {
+            baseConverseOptions.push({
                 name: "temperature",
                 type: OptionType.numeric,
                 min: 0.0,
                 default: 0.7,
                 step: 0.1,
                 description: "A higher temperature biases toward less likely tokens, making the model more creative"
-            },
-            {
+            });
+            baseConverseOptions.push({
                 name: "top_p",
                 type: OptionType.numeric,
                 min: 0,
                 max: 1,
                 step: 0.1,
                 description: "Limits token sampling to the cumulative probability of the top p tokens"
-            },
-            {
-                name: "stop_sequence",
-                type: OptionType.string_list,
-                value: [],
-                description: "The generation will halt if one of the stop sequences is output"
-            }];
+            });
+        }
+
+        baseConverseOptions.push({
+            name: "stop_sequence",
+            type: OptionType.string_list,
+            value: [],
+            description: "The generation will halt if one of the stop sequences is output"
+        });
 
         if (model.includes("claude")) {
-            const claudeConverseOptions: ModelOptionInfoItem[] = [
+            // Opus 4.7+ models don't support top_k
+            const claudeConverseOptions: ModelOptionInfoItem[] = hasSamplingRestriction ? [] : [
                 {
                     name: "top_k",
                     type: OptionType.numeric,
@@ -273,66 +288,18 @@ export function getBedrockOptions(model: string, option?: ModelOptions): ModelOp
                     description: "Limits token sampling to the top k tokens"
                 },
             ];
-            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 BedrockClaudeOptions)?.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 BedrockClaudeOptions)?.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: "If true, include the reasoning in the response"
-                    },
-                ] : [];
-
-                return {
-                    _option_id: "bedrock-claude",
-                    options: [
-                        ...baseConverseOptions,
-                        ...claudeConverseOptions,
-                        ...claudeModeOptions,
-                        ...claudeThinkingOptions,
-                        ...claudeCacheOptions,
-                        ...claudeCacheTtlOptions,
-                    ]
-                }
-            }
             return {
                 _option_id: "bedrock-claude",
-                options: [...baseConverseOptions, ...claudeConverseOptions, ...claudeCacheOptions, ...claudeCacheTtlOptions]
-            }
+                options: [
+                    ...baseConverseOptions,
+                    ...claudeConverseOptions,
+                    ...buildClaudeEffortOptions(model),
+                    ...buildClaudeThinkingBudgetOption(model),
+                    ...buildClaudeIncludeThoughtsOption(model),
+                    ...buildClaudeCacheOptions(),
+                    ...buildClaudeCacheTtlOptions((option as BedrockClaudeOptions)?.cache_enabled),
+                ],
+            };
         }
         else if (model.includes("amazon")) {
             //Titan models also exists but does not support any additional options
@@ -527,7 +494,7 @@ export function getBedrockOptions(model: string, option?: ModelOptions): ModelOp
                     _option_id: "bedrock-twelvelabs-pegasus",
                     options: pegasusOptions
                 };
-            } 
+            }
         }
 
         //Fallback to converse standard.
@@ -536,5 +503,4 @@ export function getBedrockOptions(model: string, option?: ModelOptions): ModelOp
             options: baseConverseOptions
         };
     }
-    return textOptionsFallback;
-}
+}

package/src/options/context-windows.ts

@@ -6,6 +6,7 @@
 export function getMaxOutputTokens(model: string): number {
     // Claude models
     if (model.includes('claude')) {
+        if (model.includes('opus-4-7')) return 128_000;
         if (model.includes('opus-4-6')) return 128_000;
         if (model.includes('opus-4-5')) return 64_000;
         if (model.includes('opus-')) return 32_768; // Opus 4.0, 4.1

package/src/options/openai.ts

@@ -1,4 +1,4 @@
-import { ModelOptionInfoItem, ModelOptions, ModelOptionsInfo, OptionType, SharedOptions } from "../types.js";
+import { ModelOptionInfoItem, ModelOptions, ModelOptionsInfo, OptionType, ReasoningEffort, SharedOptions } from "../types.js";
 import { textOptionsFallback } from "./fallback.js";
 
 // Union type of all OpenAI options
@@ -8,7 +8,8 @@ export interface OpenAiThinkingOptions {
     _option_id: "openai-thinking",
     max_tokens?: number,
     stop_sequence?: string[],
-    reasoning_effort?: "low" | "medium" | "high",
+    effort?: ReasoningEffort,
+    reasoning_effort?: ReasoningEffort,
     image_detail?: "low" | "high" | "auto",
 }
 
@@ -150,7 +151,7 @@ export function getOpenAiOptions(model: string, _option?: ModelOptions): ModelOp
         };
     }
 
-    if (model.includes("o1") || model.includes("o3")) {
+    if (isReasoningModel(model)) {
         //Is thinking text model
         let max_tokens_limit = 4096;
         if (model.includes("o1")) {
@@ -167,6 +168,9 @@ export function getOpenAiOptions(model: string, _option?: ModelOptions): ModelOp
         else if (model.includes("o3")) {
             max_tokens_limit = 100000;
         }
+        else if (model.includes("o4") || model.includes("gpt-5")) {
+            max_tokens_limit = 128000;
+        }
 
         const commonOptions: ModelOptionInfoItem[] = [
             {
@@ -179,9 +183,14 @@ export function getOpenAiOptions(model: string, _option?: ModelOptions): ModelOp
             },
         ];
 
-        const reasoningOptions: ModelOptionInfoItem[] = model.includes("o3") || isO1Full(model) ? [
+        const reasoningOptions: ModelOptionInfoItem[] = isGpt5ProModel(model) ? [
             {
-                name: "reasoning_effort", type: OptionType.enum, enum: { "Low": "low", "Medium": "medium", "High": "high" },
+                name: SharedOptions.effort, type: OptionType.enum, enum: { "High": "high" },
+                default: "high", description: "GPT-5 Pro only supports high reasoning effort."
+            },
+        ] : model.includes("o3") || model.includes("o4") || model.includes("gpt-5") || isO1Full(model) ? [
+            {
+                name: SharedOptions.effort, type: OptionType.enum, enum: { "Low": "low", "Medium": "medium", "High": "high" },
                 default: "medium", description: "How much effort the model should put into reasoning, lower values result in faster responses and less tokens used."
             },
         ] : [];
@@ -265,10 +274,23 @@ function isO1Full(model: string): boolean {
     return false;
 }
 
+function isReasoningModel(model: string): boolean {
+    const normalized = model.toLowerCase();
+    return normalized.includes("o1")
+        || normalized.includes("o3")
+        || normalized.includes("o4")
+        || normalized.includes("gpt-5");
+}
+
+function isGpt5ProModel(model: string): boolean {
+    const modelName = model.toLowerCase().split('/').pop() ?? model.toLowerCase();
+    return /^gpt-5(?:\.\d+)?-pro/.test(modelName);
+}
+
 function isVisionModel(model: string): boolean {
     return model.includes("gpt-4o") || isO1Full(model) || model.includes("gpt-4-turbo");
 }
 
 function isImageModel(model: string): boolean {
     return model.includes("dall-e") || model.includes("gpt-image") || model.includes("chatgpt-image");
-}
+}

package/src/options/shared-parsing.ts

@@ -0,0 +1,144 @@
+/**
+ * Shared Claude option builders used by multiple providers (Bedrock, VertexAI, …).
+ *
+ * Centralising these helpers means a single edit propagates to all drivers, and
+ * the per-provider files stay focused on provider-specific concerns (base options,
+ * max-tokens limits for non-Claude models, etc.).
+ */
+
+import { type ModelOptionInfoItem, OptionType } from "../types.js";
+import { getMaxOutputTokens } from "./context-windows.js";
+import {
+    getAvailableEffortLevels,
+    isClaudeVersionGTE,
+    supportsAdaptiveThinking,
+} from "./version-parsing.js";
+
+// ============================================================================
+// Max tokens
+// ============================================================================
+
+/**
+ * Canonical max output-tokens limit for Claude models, shared by all providers.
+ *
+ * - Claude 3.7:   128 K (all providers support extended output)
+ * - Claude Opus 4.7+: 128 K
+ * - All others:   delegated to {@link getMaxOutputTokens}
+ */
+export function getClaudeMaxTokensLimit(model: string): number {
+    if (model.includes('-3-7')) return 128000;
+    if (model.includes('opus-4-7')) return 128000;
+    return getMaxOutputTokens(model);
+}
+
+// ============================================================================
+// Cache options
+// ============================================================================
+
+/** cache_enabled toggle — identical across providers. */
+export function buildClaudeCacheOptions(): ModelOptionInfoItem[] {
+    return [
+        {
+            name: "cache_enabled",
+            type: OptionType.boolean,
+            default: false,
+            description: "Enable prompt caching. Injects cache breakpoints at the system prompt, tools, and conversation pivot.",
+        },
+    ];
+}
+
+/**
+ * cache_ttl selector — only shown when caching is enabled.
+ * Pass `option?.cache_enabled` from the current saved options.
+ */
+export function buildClaudeCacheTtlOptions(cacheEnabled?: boolean): ModelOptionInfoItem[] {
+    if (!cacheEnabled) return [];
+    return [
+        {
+            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.",
+        },
+    ];
+}
+
+// ============================================================================
+// Effort option
+// ============================================================================
+
+/**
+ * Effort selector — shown only for models that support it (Opus 4.5+, Sonnet 4.6+, all 4.7+).
+ * Returns an empty array for unsupported models.
+ */
+export function buildClaudeEffortOptions(model: string): ModelOptionInfoItem[] {
+    const effortLevels = getAvailableEffortLevels(model);
+    if (!effortLevels) return [];
+    return [
+        {
+            name: "effort",
+            type: OptionType.enum,
+            enum: effortLevels,
+            description: "Controls how many tokens Claude uses when responding. Lower effort trades thoroughness for speed and cost savings.",
+        },
+    ];
+}
+
+// ============================================================================
+// Thinking / reasoning options
+// ============================================================================
+
+/**
+ * Thinking budget option — shown for non-adaptive Claude thinking models (3.7, 4.5).
+ * Setting this enables extended thinking with the given token budget.
+ *
+ * Returns an empty array for models that don't support extended thinking or that
+ * use adaptive thinking instead (where effort is the control knob).
+ */
+export function buildClaudeThinkingBudgetOption(model: string): ModelOptionInfoItem[] {
+    // Adaptive-only models (Opus 4.7+) don't accept budget_tokens at all.
+    // Adaptive models (Opus/Sonnet 4.6) still accept budget_tokens but it's deprecated;
+    // those models should use effort instead. Show budget only for non-adaptive thinking models.
+    if (!isClaudeVersionGTE(model, 3, 7) || supportsAdaptiveThinking(model)) return [];
+    return [
+        {
+            name: "thinking_budget_tokens",
+            type: OptionType.numeric,
+            min: 1024,
+            integer: true,
+            step: 1024,
+            description: "Token budget for extended thinking. Enables thinking when set.",
+        },
+    ];
+}
+
+/**
+ * include_thoughts display toggle — shown for all Claude thinking-capable models.
+ * Controls whether thinking content is returned in the response.
+ * This does not enable thinking; set thinking_budget_tokens (extended) or effort (adaptive).
+ *
+ * Returns an empty array for models with no thinking support.
+ */
+export function buildClaudeIncludeThoughtsOption(model: string): ModelOptionInfoItem[] {
+    if (!isClaudeVersionGTE(model, 3, 7)) return [];
+    return [
+        {
+            name: "include_thoughts",
+            type: OptionType.boolean,
+            default: false,
+            description: "Include the model's thinking content in the response.",
+        },
+    ];
+}
+
+/**
+ * @deprecated Use buildClaudeThinkingBudgetOption and buildClaudeIncludeThoughtsOption separately.
+ * Kept for backwards compatibility — delegates to the two new helpers.
+ */
+export function buildClaudeThinkingOptions(model: string): ModelOptionInfoItem[] {
+    return [
+        ...buildClaudeThinkingBudgetOption(model),
+        ...buildClaudeIncludeThoughtsOption(model),
+    ];
+}