@llumiverse/common 0.20.0 → 0.22.0

package/src/options/azure_foundry.ts

@@ -0,0 +1,485 @@
+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;
+    }
+    // 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.ts

@@ -3,18 +3,24 @@ import { getGroqOptions } from "./options/groq.js";
 import { getOpenAiOptions } from "./options/openai.js";
 import { getVertexAiOptions } from "./options/vertexai.js";
 import { textOptionsFallback } from "./options/fallback.js";
-import { ModelOptionsInfo, ModelOptions } from "./types.js";
+import { ModelOptionsInfo, ModelOptions, Providers } from "./types.js";
+import { getAzureFoundryOptions } from "./options/azure_foundry.js";
 
-export function getOptions(model: string, provider?: string, options?: ModelOptions): ModelOptionsInfo {
-    switch (provider?.toLowerCase()) {
-        case "bedrock":
-            return getBedrockOptions(model ?? "", options);
-        case "vertexai":
-            return getVertexAiOptions(model ?? "", options);
-        case "openai":
-            return getOpenAiOptions(model ?? "", options);
-        case "groq":
-            return getGroqOptions(model ?? "", options);
+export function getOptions(model: string, provider?: string | Providers, options?: ModelOptions): ModelOptionsInfo {
+    if(!provider) {
+        return textOptionsFallback;
+    }
+    switch (provider.toLowerCase()) {
+        case Providers.bedrock:
+            return getBedrockOptions(model, options);
+        case Providers.vertexai:
+            return getVertexAiOptions(model, options);
+        case Providers.openai:
+            return getOpenAiOptions(model, options);
+        case Providers.groq:
+            return getGroqOptions(model, options);
+        case Providers.azure_foundry:
+            return getAzureFoundryOptions(model, options);
         default:
             return textOptionsFallback;
     }

package/src/types.ts

@@ -4,6 +4,119 @@ import { GroqOptions } from './options/groq.js';
 import { OpenAiOptions } from './options/openai.js';
 import { VertexAIOptions } from './options/vertexai.js';
 
+// ============== Provider details ===============
+
+export enum Providers {
+    openai = 'openai',
+    azure_openai = 'azure_openai',
+    azure_foundry = 'azure_foundry',
+    huggingface_ie = 'huggingface_ie',
+    replicate = 'replicate',
+    bedrock = 'bedrock',
+    vertexai = 'vertexai',
+    togetherai = 'togetherai',
+    mistralai = 'mistralai',
+    groq = 'groq',
+    watsonx = 'watsonx'
+}
+
+export interface ProviderParams {
+    id: Providers;
+    name: string;
+    requiresApiKey: boolean;
+    requiresEndpointUrl: boolean;
+    endpointPlaceholder?: string;
+    supportSearch?: boolean;
+}
+
+export const ProviderList: Record<Providers, ProviderParams> = {
+    openai:
+    {
+        id: Providers.openai,
+        name: "OpenAI",
+        requiresApiKey: true,
+        requiresEndpointUrl: false,
+        supportSearch: false,
+    },
+    azure_openai:
+    {
+        id: Providers.azure_openai,
+        name: "Azure OpenAI",
+        requiresApiKey: false,
+        requiresEndpointUrl: true,
+        supportSearch: false,
+    },
+    azure_foundry:
+    {
+        id: Providers.azure_foundry,
+        name: "Azure Foundry",
+        requiresApiKey: true,
+        requiresEndpointUrl: true,
+        supportSearch: false,
+    },
+    huggingface_ie:
+    {
+        id: Providers.huggingface_ie,
+        name: "HuggingFace Inference Endpoint",
+        requiresApiKey: true,
+        requiresEndpointUrl: true,
+    },
+    replicate:
+    {
+        id: Providers.replicate,
+        name: "Repicate",
+        requiresApiKey: true,
+        requiresEndpointUrl: false,
+        supportSearch: true,
+    },
+    bedrock:
+    {
+        id: Providers.bedrock,
+        name: "AWS Bedrock",
+        requiresApiKey: false,
+        requiresEndpointUrl: false,
+        endpointPlaceholder: "region name (eg. us-east-1)",
+        supportSearch: false,
+    },
+    vertexai: {
+        id: Providers.vertexai,
+        name: "Google Vertex AI",
+        requiresApiKey: false,
+        requiresEndpointUrl: false,
+        supportSearch: false,
+    },
+    togetherai: {
+        id: Providers.togetherai,
+        name: "Together AI",
+        requiresApiKey: false,
+        requiresEndpointUrl: false,
+        supportSearch: false,
+    },
+    mistralai: {
+        id: Providers.mistralai,
+        name: "Mistral AI",
+        requiresApiKey: false,
+        requiresEndpointUrl: false,
+        supportSearch: false,
+    },
+    groq: {
+        id: Providers.groq,
+        name: "Groq Cloud",
+        requiresApiKey: false,
+        requiresEndpointUrl: false,
+        supportSearch: false,
+    },
+    watsonx: {
+        id: Providers.watsonx,
+        name: "IBM WatsonX",
+        requiresApiKey: true,
+        requiresEndpointUrl: true,
+        supportSearch: false
+    },
+}
+
+// ============== Embeddings ===============
+
 export interface EmbeddingsOptions {
     /**
      * The text to generate the embeddings for. One of text or image is required.