@llumiverse/common 0.21.0 → 0.22.0-dev.1

package/src/options/azure_foundry.ts

@@ -95,6 +95,9 @@ export function getMaxTokensLimitAzureFoundry(model: string): number | undefined
     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")) {

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;

package/src/types.ts

@@ -64,7 +64,7 @@ export const ProviderList: Record<Providers, ProviderParams> = {
     replicate:
     {
         id: Providers.replicate,
-        name: "Repicate",
+        name: "Replicate",
         requiresApiKey: true,
         requiresEndpointUrl: false,
         supportSearch: true,
@@ -152,20 +152,90 @@ export interface EmbeddingsResult {
 export interface ResultValidationError {
     code: 'validation_error' | 'json_error' | 'content_policy_violation';
     message: string;
-    data?: string;
+    data?: CompletionResult[];
+}
+
+// ============== Result Types ===============
+
+export interface BaseResult {
+    type: "text" | "json" | "image";
+    value: any;
+}
+
+export interface TextResult extends BaseResult {
+    type: "text";
+    value: string;
+}
+
+export interface JsonResult extends BaseResult {
+    type: "json";
+}
+
+export interface ImageResult extends BaseResult {
+    type: "image";
+    value: string; // base64 data url or real url
+}
+
+export type CompletionResult = TextResult | JsonResult | ImageResult;
+
+/**
+ * Output as string
+ */
+export function completionResultToString(result: CompletionResult): string {
+    switch (result.type) {
+        case "text":
+            return result.value;
+        case "json":
+            return JSON.stringify(result.value, null, 2);
+        case "image":
+            return result.value;
+    }
+}
+
+/**
+ * Output as JSON, only handles the first JSON result or tries to parse text as JSON
+ * Expects the text to be pure JSON if no JSON result is found
+ * Throws if no JSON result is found or if parsing fails
+ */
+export function parseCompletionResultsToJson(results: CompletionResult[]): any {
+    const jsonResults = results.filter(r => r.type === "json");
+    if (jsonResults.length >= 1) {
+        return jsonResults[0].value;
+        //TODO: Handle multiple json type results
+    }
+
+    const textResults = results.filter(r => r.type === "text").join();
+    if (textResults.length === 0) {
+        throw new Error("No JSON result found or failed to parse text");
+    }
+    try {
+        return JSON.parse(textResults);
+    }
+    catch {
+        throw new Error("No JSON result found or failed to parse text");
+    }
+}
+
+/**
+ * Output as JSON if possible, otherwise as concatenated text
+ * Joins text results with the specified separator, default is empty string
+ * If multiple JSON results are found only the first one is returned
+ */
+export function parseCompletionResults(result: CompletionResult[], separator: string = ""): any {
+    try {
+        return parseCompletionResultsToJson(result);
+    } catch {
+        return result.map(completionResultToString).join(separator);
+    }
 }
 
-//ResultT should be either JSONObject or string
 //Internal structure used in driver implementation.
-export interface CompletionChunkObject<ResultT = any> {
-    result: ResultT;
+export interface CompletionChunkObject {
+    result: CompletionResult[];
     token_usage?: ExecutionTokenUsage;
     finish_reason?: "stop" | "length" | string;
 }
 
-//Internal structure used in driver implementation.
-export type CompletionChunk = CompletionChunkObject | string;
-
 export interface ToolDefinition {
     name: string,
     description?: string,
@@ -185,10 +255,9 @@ export interface ToolUse<ParamsT = JSONObject> {
     tool_input: ParamsT | null
 }
 
-//ResultT should be either JSONObject or string
-export interface Completion<ResultT = any> {
+export interface Completion {
     // the driver impl must return the result and optionally the token_usage. the execution time is computed by the extended abstract driver
-    result: ResultT;
+    result: CompletionResult[];
     token_usage?: ExecutionTokenUsage;
     /**
      * Contains the tools from which the model awaits information.
@@ -216,12 +285,6 @@ export interface Completion<ResultT = any> {
     conversation?: unknown;
 }
 
-export interface ImageGeneration {
-
-    images?: string[];
-
-}
-
 export interface ExecutionResponse<PromptT = any> extends Completion {
     prompt: PromptT;
     /**
@@ -533,7 +596,7 @@ export interface TrainingOptions {
 
 export interface TrainingPromptOptions {
     segments: PromptSegment[];
-    completion: string | JSONObject;
+    completion: CompletionResult[]
     model: string; // the model to train
     schema?: JSONSchema; // the result schema f any
 }