@llumiverse/common 0.20.0 → 0.22.0-dev.1

package/src/options/azure_foundry.ts

@@ -0,0 +1,488 @@
+import { ModelOptionsInfo, ModelOptionInfoItem, ModelOptions, OptionType, SharedOptions } from "../types.js";
+
+// Helper function to parse composite model IDs
+function parseAzureFoundryModelId(compositeId: string): { deploymentName: string; baseModel: string } {
+    const parts = compositeId.split('::');
+    if (parts.length === 2) {
+        return {
+            deploymentName: parts[0],
+            baseModel: parts[1]
+        };
+    }
+
+    // Backwards compatibility: if no delimiter found, treat as deployment name
+    return {
+        deploymentName: compositeId,
+        baseModel: compositeId
+    };
+}
+
+// Union type of all Azure Foundry options
+export type AzureFoundryOptions = AzureFoundryOpenAIOptions | AzureFoundryDeepSeekOptions | AzureFoundryThinkingOptions | AzureFoundryTextOptions | AzureFoundryImageOptions;
+
+export interface AzureFoundryOpenAIOptions {
+    _option_id: "azure-foundry-openai";
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    presence_penalty?: number;
+    frequency_penalty?: number;
+    stop_sequence?: string[];
+    image_detail?: "low" | "high" | "auto";
+    reasoning_effort?: "low" | "medium" | "high";
+}
+
+export interface AzureFoundryDeepSeekOptions {
+    _option_id: "azure-foundry-deepseek";
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    stop_sequence?: string[];
+}
+
+export interface AzureFoundryThinkingOptions {
+    _option_id: "azure-foundry-thinking";
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    stop_sequence?: string[];
+    reasoning_effort?: "low" | "medium" | "high";
+    image_detail?: "low" | "high" | "auto";
+}
+
+export interface AzureFoundryTextOptions {
+    _option_id: "azure-foundry-text";
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    top_k?: number;
+    presence_penalty?: number;
+    frequency_penalty?: number;
+    stop_sequence?: string[];
+    seed?: number;
+}
+
+export interface AzureFoundryImageOptions {
+    _option_id: "azure-foundry-image";
+    width?: number;
+    height?: number;
+    quality?: "standard" | "hd";
+    style?: "vivid" | "natural";
+    response_format?: "url" | "b64_json";
+    size?: "256x256" | "512x512" | "1024x1024" | "1792x1024" | "1024x1792";
+}
+
+export function getMaxTokensLimitAzureFoundry(model: string): number | undefined {
+    // Extract base model from composite ID (deployment::baseModel)
+    const { baseModel } = parseAzureFoundryModelId(model);
+    const modelLower = baseModel.toLowerCase();
+    // GPT models
+    if (modelLower.includes("gpt-4o")) {
+        if (modelLower.includes("mini")) {
+            return 16384;
+        }
+        return 16384;
+    }
+    if (modelLower.includes("gpt-4")) {
+        if (modelLower.includes("turbo")) {
+            return 4096;
+        }
+        if (modelLower.includes("32k")) {
+            return 32768;
+        }
+        return 8192;
+    }
+    if (modelLower.includes("gpt-35") || modelLower.includes("gpt-3.5")) {
+        return 4096;
+    }
+    if (model.includes("gpt-5")) {
+        return 128000;
+    }
+    // O-series models
+    if (modelLower.includes("o1")) {
+        if (modelLower.includes("preview")) {
+            return 32768;
+        }
+        if (modelLower.includes("mini")) {
+            return 65536;
+        }
+        return 100000;
+    }
+    if (modelLower.includes("o3")) {
+        if (modelLower.includes("mini")) {
+            return 100000;
+        }
+        return 100000;
+    }
+    if (modelLower.includes("o4")) {
+        return 100000;
+    }
+    // DeepSeek models
+    if (modelLower.includes("deepseek")) {
+        if (modelLower.includes("r1")) {
+            return 163840;
+        }
+        if (modelLower.includes("v3")) {
+            return 131072;
+        }
+    }
+    // Claude models
+    if (modelLower.includes("claude")) {
+        if (modelLower.includes("3-5") || modelLower.includes("3-7")) {
+            return 8192;
+        }
+        if (modelLower.includes("3")) {
+            return 4096;
+        }
+        return 4096;
+    }
+    // Llama models
+    if (modelLower.includes("llama")) {
+        if (modelLower.includes("3.1") || modelLower.includes("3.3")) {
+            return 8192;
+        }
+        if (modelLower.includes("4")) {
+            return 1000000; // 1M context
+        }
+        return 8192;
+    }
+    // Mistral models
+    if (modelLower.includes("mistral")) {
+        if (modelLower.includes("large")) {
+            return 4096;
+        }
+        if (modelLower.includes("small")) {
+            return 4096;
+        }
+        return 4096;
+    }
+    // Phi models
+    if (modelLower.includes("phi")) {
+        return 4096;
+    }
+    // AI21 Jamba models
+    if (modelLower.includes("jamba")) {
+        return 4096;
+    }
+    // Cohere models
+    if (modelLower.includes("cohere")) {
+        if (modelLower.includes("command-a")) {
+            return 8000;
+        }
+        return 4096;
+    }
+    // Grok models
+    if (modelLower.includes("grok")) {
+        return 131072;
+    }
+    return undefined;
+}
+
+export function getAzureFoundryOptions(model: string, _option?: ModelOptions): ModelOptionsInfo {
+    // Extract base model from composite ID (deployment::baseModel)
+    const { baseModel } = parseAzureFoundryModelId(model);
+    const modelLower = baseModel.toLowerCase();
+    const max_tokens_limit = getMaxTokensLimitAzureFoundry(model);
+    // Image generation models
+    if (modelLower.includes("dall-e") || modelLower.includes("gpt-image")) {
+        return {
+            _option_id: "azure-foundry-image",
+            options: [
+                {
+                    name: "size",
+                    type: OptionType.enum,
+                    enum: {
+                        "256x256": "256x256",
+                        "512x512": "512x512",
+                        "1024x1024": "1024x1024",
+                        "1792x1024": "1792x1024",
+                        "1024x1792": "1024x1792"
+                    },
+                    default: "1024x1024",
+                    description: "The size of the generated image"
+                },
+                {
+                    name: "quality",
+                    type: OptionType.enum,
+                    enum: { "Standard": "standard", "HD": "hd" },
+                    default: "standard",
+                    description: "The quality of the generated image"
+                },
+                {
+                    name: "style",
+                    type: OptionType.enum,
+                    enum: { "Vivid": "vivid", "Natural": "natural" },
+                    default: "vivid",
+                    description: "The style of the generated image"
+                },
+                {
+                    name: "response_format",
+                    type: OptionType.enum,
+                    enum: { "URL": "url", "Base64 JSON": "b64_json" },
+                    default: "url",
+                    description: "The format of the response"
+                }
+            ]
+        };
+    }
+    // Vision model options
+    const visionOptions: ModelOptionInfoItem[] = isVisionModel(modelLower) ? [
+        {
+            name: "image_detail",
+            type: OptionType.enum,
+            enum: { "Low": "low", "High": "high", "Auto": "auto" },
+            default: "auto",
+            description: "Controls how the model processes input images"
+        }
+    ] : [];
+    // O-series and thinking models
+    if (modelLower.includes("o1") || modelLower.includes("o3") || modelLower.includes("o4")) {
+        const reasoningOptions: ModelOptionInfoItem[] = (modelLower.includes("o3") || isO1Full(modelLower)) ? [
+            {
+                name: "reasoning_effort",
+                type: OptionType.enum,
+                enum: { "Low": "low", "Medium": "medium", "High": "high" },
+                default: "medium",
+                description: "How much effort the model should put into reasoning"
+            }
+        ] : [];
+        return {
+            _option_id: "azure-foundry-thinking",
+            options: [
+                {
+                    name: SharedOptions.max_tokens,
+                    type: OptionType.numeric,
+                    min: 1,
+                    max: max_tokens_limit,
+                    integer: true,
+                    description: "The maximum number of tokens to generate"
+                },
+                {
+                    name: SharedOptions.temperature,
+                    type: OptionType.numeric,
+                    min: 0.0,
+                    max: 2.0,
+                    default: 1.0,
+                    step: 0.1,
+                    description: "Controls randomness in the output"
+                },
+                {
+                    name: SharedOptions.top_p,
+                    type: OptionType.numeric,
+                    min: 0,
+                    max: 1,
+                    step: 0.1,
+                    description: "Nucleus sampling parameter"
+                },
+                {
+                    name: SharedOptions.stop_sequence,
+                    type: OptionType.string_list,
+                    value: [],
+                    description: "Sequences where the model will stop generating"
+                },
+                ...reasoningOptions,
+                ...visionOptions
+            ]
+        };
+    }
+    // DeepSeek R1 models
+    if (modelLower.includes("deepseek") && modelLower.includes("r1")) {
+        return {
+            _option_id: "azure-foundry-deepseek",
+            options: [
+                {
+                    name: SharedOptions.max_tokens,
+                    type: OptionType.numeric,
+                    min: 1,
+                    max: max_tokens_limit,
+                    integer: true,
+                    description: "The maximum number of tokens to generate"
+                },
+                {
+                    name: SharedOptions.temperature,
+                    type: OptionType.numeric,
+                    min: 0.0,
+                    max: 2.0,
+                    default: 0.7,
+                    step: 0.1,
+                    description: "Lower temperatures recommended for DeepSeek R1 (0.3-0.7)"
+                },
+                {
+                    name: SharedOptions.top_p,
+                    type: OptionType.numeric,
+                    min: 0,
+                    max: 1,
+                    step: 0.1,
+                    description: "Nucleus sampling parameter"
+                },
+                {
+                    name: SharedOptions.stop_sequence,
+                    type: OptionType.string_list,
+                    value: [],
+                    description: "Sequences where the model will stop generating"
+                }
+            ]
+        };
+    }
+    // OpenAI models (GPT-4, GPT-4o, GPT-3.5)
+    if (modelLower.includes("gpt-")) {
+        return {
+            _option_id: "azure-foundry-openai",
+            options: [
+                {
+                    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"
+                },
+                {
+                    name: SharedOptions.temperature,
+                    type: OptionType.numeric,
+                    min: 0.0,
+                    max: 2.0,
+                    default: 0.7,
+                    step: 0.1,
+                    description: "Controls randomness in the output"
+                },
+                {
+                    name: SharedOptions.top_p,
+                    type: OptionType.numeric,
+                    min: 0,
+                    max: 1,
+                    step: 0.1,
+                    description: "Nucleus sampling parameter"
+                },
+                {
+                    name: SharedOptions.presence_penalty,
+                    type: OptionType.numeric,
+                    min: -2.0,
+                    max: 2.0,
+                    step: 0.1,
+                    description: "Penalize new tokens based on their presence in the text"
+                },
+                {
+                    name: SharedOptions.frequency_penalty,
+                    type: OptionType.numeric,
+                    min: -2.0,
+                    max: 2.0,
+                    step: 0.1,
+                    description: "Penalize new tokens based on their frequency in the text"
+                },
+                {
+                    name: SharedOptions.stop_sequence,
+                    type: OptionType.string_list,
+                    value: [],
+                    description: "Sequences where the model will stop generating"
+                },
+                ...visionOptions
+            ]
+        };
+    }
+    // General text models (Claude, Llama, Mistral, Phi, etc.)
+    const baseOptions: 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"
+        },
+        {
+            name: SharedOptions.temperature,
+            type: OptionType.numeric,
+            min: 0.0,
+            max: 2.0,
+            default: 0.7,
+            step: 0.1,
+            description: "Controls randomness in the output"
+        },
+        {
+            name: SharedOptions.top_p,
+            type: OptionType.numeric,
+            min: 0,
+            max: 1,
+            step: 0.1,
+            description: "Nucleus sampling parameter"
+        },
+        {
+            name: SharedOptions.stop_sequence,
+            type: OptionType.string_list,
+            value: [],
+            description: "Sequences where the model will stop generating"
+        }
+    ];
+    // Add model-specific options
+    const additionalOptions: ModelOptionInfoItem[] = [];
+    // Add top_k for certain models
+    if (modelLower.includes("claude") || modelLower.includes("mistral") || modelLower.includes("phi")) {
+        additionalOptions.push({
+            name: SharedOptions.top_k,
+            type: OptionType.numeric,
+            min: 1,
+            integer: true,
+            step: 1,
+            description: "Limits token sampling to the top k tokens"
+        });
+    }
+
+    // Add penalty options for certain models
+    if (modelLower.includes("claude") || modelLower.includes("jamba") || modelLower.includes("cohere")) {
+        additionalOptions.push(
+            {
+                name: SharedOptions.presence_penalty,
+                type: OptionType.numeric,
+                min: -2.0,
+                max: 2.0,
+                step: 0.1,
+                description: "Penalize new tokens based on their presence in the text"
+            },
+            {
+                name: SharedOptions.frequency_penalty,
+                type: OptionType.numeric,
+                min: -2.0,
+                max: 2.0,
+                step: 0.1,
+                description: "Penalize new tokens based on their frequency in the text"
+            }
+        );
+    }
+    // Add seed option for certain models
+    if (modelLower.includes("mistral") || modelLower.includes("phi") || modelLower.includes("gemini")) {
+        additionalOptions.push({
+            name: SharedOptions.seed,
+            type: OptionType.numeric,
+            integer: true,
+            description: "Random seed for reproducible generation"
+        });
+    }
+    return {
+        _option_id: "azure-foundry-text",
+        options: [
+            ...baseOptions,
+            ...additionalOptions,
+            ...visionOptions
+        ]
+    };
+}
+
+function isVisionModel(modelLower: string): boolean {
+    return modelLower.includes("gpt-4o") ||
+        modelLower.includes("gpt-4-turbo") ||
+        modelLower.includes("claude-3") ||
+        modelLower.includes("llama-3.2") ||
+        modelLower.includes("llama-4") ||
+        modelLower.includes("gemini") ||
+        isO1Full(modelLower);
+}
+
+function isO1Full(modelLower: string): boolean {
+    if (modelLower.includes("o1")) {
+        return !modelLower.includes("mini") && !modelLower.includes("preview");
+    }
+    return false;
+}

package/src/options/bedrock.ts

@@ -2,7 +2,7 @@ import { ModelOptionsInfo, ModelOptions, OptionType, ModelOptionInfoItem } from
 import { textOptionsFallback } from "./fallback.js";
 
 // Union type of all Bedrock options
-export type BedrockOptions = NovaCanvasOptions | BaseConverseOptions | BedrockClaudeOptions | BedrockPalmyraOptions;
+export type BedrockOptions = NovaCanvasOptions | BaseConverseOptions | BedrockClaudeOptions | BedrockPalmyraOptions | BedrockGptOssOptions;
 
 export interface NovaCanvasOptions {
     _option_id: "bedrock-nova-canvas"
@@ -21,7 +21,7 @@ export interface NovaCanvasOptions {
 }
 
 export interface BaseConverseOptions {
-    _option_id: "bedrock-converse" | "bedrock-claude" | "bedrock-nova" | "bedrock-mistral" | "bedrock-ai21" | "bedrock-cohere-command" | "bedrock-palmyra";
+    _option_id: "bedrock-converse" | "bedrock-claude" | "bedrock-nova" | "bedrock-mistral" | "bedrock-ai21" | "bedrock-cohere-command" | "bedrock-palmyra" | "bedrock-gpt-oss";
     max_tokens?: number;
     temperature?: number;
     top_p?: number;
@@ -44,6 +44,13 @@ export interface BedrockPalmyraOptions extends BaseConverseOptions {
     presence_penalty?: number;
 }
 
+export interface BedrockGptOssOptions extends BaseConverseOptions {
+    _option_id: "bedrock-gpt-oss";
+    reasoning_effort?: "low" | "medium" | "high";
+    frequency_penalty?: number;
+    presence_penalty?: number;
+}
+
 export function getMaxTokensLimitBedrock(model: string): number | undefined {
     // Claude models
     if (model.includes("claude")) {
@@ -124,6 +131,10 @@ export function getMaxTokensLimitBedrock(model: string): number | undefined {
             return 8192;
         }
     }
+    // OpenAI gpt-oss models
+    if (model.includes("gpt-oss")) {
+        return 128000;
+    }
 
     // Default fallback
     return undefined;
@@ -442,6 +453,29 @@ export function getBedrockOptions(model: string, option?: ModelOptions): ModelOp
                 options: [...baseConverseOptions, ...palmyraConverseOptions]
             }
         }
+        else if (model.includes("gpt-oss")) {
+            const gptOssOptions: ModelOptionInfoItem[] = [
+                {
+                    name: "reasoning_effort",
+                    type: OptionType.enum,
+                    enum: {
+                        "low": "low",
+                        "medium": "medium",
+                        "high": "high"
+                    },
+                    default: "medium",
+                    description: "The reasoning effort of the model, which affects the quality and speed of the response"
+                },
+            ];
+
+            const baseConverseOptionsNoStop: ModelOptionInfoItem[] = [...baseConverseOptions];
+            // Remove stop_sequence for gpt-oss
+            baseConverseOptionsNoStop.splice(baseConverseOptionsNoStop.findIndex(o => o.name === "stop_sequence"), 1);
+            return {
+                _option_id: "bedrock-gpt-oss",
+                options: [...baseConverseOptionsNoStop, ...gptOssOptions]
+            };
+        }
 
         //Fallback to converse standard.
         return {

package/src/options/openai.ts

@@ -93,6 +93,9 @@ export function getOpenAiOptions(model: string, _option?: ModelOptions): ModelOp
         else if (model.includes("gpt-3-5")) {
             max_tokens_limit = 4096;
         }
+        else if (model.includes("gpt-5")) {
+            max_tokens_limit = 128000;
+        }
 
         //Is non-thinking text model
         const commonOptions: ModelOptionInfoItem[] = [

package/src/options/vertexai.ts

@@ -245,9 +245,53 @@ function getImagenOptions(model: string, option?: ModelOptions): ModelOptionsInf
 }
 
 function getGeminiOptions(model: string, _option?: ModelOptions): ModelOptionsInfo {
+    // Special handling for gemini-2.5-flash-image
+    if (model.includes("gemini-2.5-flash-image")) {
+        const options: ModelOptionInfoItem[] = [
+            {
+                name: SharedOptions.temperature,
+                type: OptionType.numeric,
+                min: 0.0,
+                max: 2.0,
+                default: 0.7,
+                step: 0.01,
+                description: "Sampling temperature"
+            },
+            {
+                name: SharedOptions.top_p,
+                type: OptionType.numeric,
+                min: 0.0,
+                max: 1.0,
+                step: 0.01,
+                description: "Nucleus sampling probability"
+            },
+            {
+                name: "candidate_count",
+                type: OptionType.numeric,
+                min: 1,
+                max: 8,
+                default: 1,
+                integer: true,
+                description: "Number of candidates to generate"
+            },
+            {
+                name: SharedOptions.max_tokens,
+                type: OptionType.numeric,
+                min: 1,
+                max: 32768,
+                integer: true,
+                step: 200,
+                description: "Maximum output tokens"
+            }
+        ];
+        return {
+            _option_id: "vertexai-gemini",
+            options
+        };
+    }
     const max_tokens_limit = getGeminiMaxTokensLimit(model);
     const excludeOptions = ["max_tokens"];
-    let commonOptions = textOptionsFallback.options.filter((option) => !excludeOptions.includes(option.name));
+    const commonOptions = textOptionsFallback.options.filter((option) => !excludeOptions.includes(option.name));
 
     const max_tokens: ModelOptionInfoItem[] = [{
         name: SharedOptions.max_tokens, type: OptionType.numeric, min: 1, max: max_tokens_limit,
@@ -260,7 +304,7 @@ function getGeminiOptions(model: string, _option?: ModelOptions): ModelOptionsIn
 
     if (model.includes("-2.5-")) {
         // Gemini 2.5 thinking models
-        
+
         // Set budget token ranges based on model variant
         let budgetMin = -1;
         let budgetMax = 24576;
@@ -287,7 +331,7 @@ function getGeminiOptions(model: string, _option?: ModelOptions): ModelOptionsIn
                 "Range: 128-32768 tokens. " +
                 "Cannot disable thinking - minimum 128 tokens. Set to -1 for dynamic thinking.";
         }
-        
+
         const geminiThinkingOptions: ModelOptionInfoItem[] = [
             {
                 name: "include_thoughts",
@@ -331,7 +375,7 @@ function getGeminiOptions(model: string, _option?: ModelOptions): ModelOptionsIn
 function getClaudeOptions(model: string, option?: ModelOptions): ModelOptionsInfo {
     const max_tokens_limit = getClaudeMaxTokensLimit(model);
     const excludeOptions = ["max_tokens", "presence_penalty", "frequency_penalty"];
-    let commonOptions = textOptionsFallback.options.filter((option) => !excludeOptions.includes(option.name));
+    const commonOptions = textOptionsFallback.options.filter((option) => !excludeOptions.includes(option.name));
     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"
@@ -391,7 +435,7 @@ function getLlamaOptions(model: string): ModelOptionsInfo {
         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"
     }];
-    
+
     // Set max temperature to 1.0 for Llama models
     commonOptions = commonOptions.map((option) => {
         if (
@@ -416,6 +460,9 @@ function getLlamaOptions(model: string): ModelOptionsInfo {
 }
 
 function getGeminiMaxTokensLimit(model: string): number {
+    if (model.includes("gemini-2.5-flash-image")) {
+        return 32768;
+    }
     if (model.includes("thinking") || model.includes("-2.5-")) {
         return 65536;
     }
@@ -427,7 +474,7 @@ function getGeminiMaxTokensLimit(model: string): number {
 
 function getClaudeMaxTokensLimit(model: string): number {
     if (model.includes("-4-")) {
-        if(model.includes("opus-")) {
+        if (model.includes("opus-")) {
             return 32768;
         }
         return 65536;