@llumiverse/common 0.22.0-dev.1 → 0.22.1

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 | BedrockGptOssOptions;
+export type BedrockOptions = NovaCanvasOptions | BaseConverseOptions | BedrockClaudeOptions | BedrockPalmyraOptions | BedrockGptOssOptions | TwelvelabsPegasusOptions;
 
 export interface NovaCanvasOptions {
     _option_id: "bedrock-nova-canvas"
@@ -51,6 +51,12 @@ export interface BedrockGptOssOptions extends BaseConverseOptions {
     presence_penalty?: number;
 }
 
+export interface TwelvelabsPegasusOptions {
+    _option_id: "bedrock-twelvelabs-pegasus";
+    temperature?: number;
+    max_tokens?: number;
+}
+
 export function getMaxTokensLimitBedrock(model: string): number | undefined {
     // Claude models
     if (model.includes("claude")) {
@@ -135,6 +141,14 @@ export function getMaxTokensLimitBedrock(model: string): number | undefined {
     if (model.includes("gpt-oss")) {
         return 128000;
     }
+    // TwelveLabs models
+    else if (model.includes("twelvelabs")) {
+        if (model.includes("pegasus")) {
+            return 4096; // Max output tokens for Pegasus
+        }
+        // Marengo is an embedding model, doesn't generate text
+        return undefined;
+    }
 
     // Default fallback
     return undefined;
@@ -476,6 +490,34 @@ export function getBedrockOptions(model: string, option?: ModelOptions): ModelOp
                 options: [...baseConverseOptionsNoStop, ...gptOssOptions]
             };
         }
+        else if (model.includes("twelvelabs")) {
+            if (model.includes("pegasus")) {
+                const pegasusOptions: ModelOptionInfoItem[] = [
+                    {
+                        name: "temperature",
+                        type: OptionType.numeric,
+                        min: 0.0,
+                        max: 1.0,
+                        default: 0.2,
+                        step: 0.1,
+                        description: "Controls randomness in the output"
+                    },
+                    {
+                        name: "max_tokens",
+                        type: OptionType.numeric,
+                        min: 1,
+                        max: 4096,
+                        integer: true,
+                        step: 100,
+                        description: "The maximum number of tokens to generate"
+                    }
+                ];
+                return {
+                    _option_id: "bedrock-twelvelabs-pegasus",
+                    options: pegasusOptions
+                };
+            } 
+        }
 
         //Fallback to converse standard.
         return {

package/src/options/vertexai.ts

@@ -75,6 +75,7 @@ export interface VertexAIGeminiOptions {
     seed?: number;
     include_thoughts?: boolean;
     thinking_budget_tokens?: number;
+    image_aspect_ratio?: "1:1" | "2:3" | "3:2" | "3:4" | "4:3" | "9:16" | "16:9" | "21:9";
 }
 
 export function getVertexAiOptions(model: string, option?: ModelOptions): ModelOptionsInfo {
@@ -247,46 +248,57 @@ 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"
+        const max_tokens_limit = 32768;
+        const excludeOptions = ["max_tokens", "presence_penalty", "frequency_penalty", "seed", "top_k"];
+        let commonOptions = textOptionsFallback.options.filter((option) => !excludeOptions.includes(option.name));
+
+        // Set max temperature to 2.0 for gemini-2.5-flash-image
+        commonOptions = commonOptions.map((option) => {
+            if (
+                option.name === SharedOptions.temperature &&
+                option.type === OptionType.numeric
+            ) {
+                return {
+                    ...option,
+                    max: 2.0,
+                };
             }
-        ];
+            return option;
+        });
+
+        const max_tokens: ModelOptionInfoItem[] = [{
+            name: SharedOptions.max_tokens,
+            type: OptionType.numeric,
+            min: 1,
+            max: max_tokens_limit,
+            integer: true,
+            step: 200,
+            description: "Maximum output tokens"
+        }];
+
+        const imageAspectRatio: ModelOptionInfoItem[] = [{
+            name: "image_aspect_ratio",
+            type: OptionType.enum,
+            enum: {
+                "1:1": "1:1",
+                "2:3": "2:3",
+                "3:2": "3:2",
+                "3:4": "3:4",
+                "4:3": "4:3",
+                "9:16": "9:16",
+                "16:9": "16:9",
+                "21:9": "21:9"
+            },
+            description: "Aspect ratio of the generated images"
+        }];
+
         return {
             _option_id: "vertexai-gemini",
-            options
+            options: [
+                ...max_tokens,
+                ...commonOptions,
+                ...imageAspectRatio,
+            ]
         };
     }
     const max_tokens_limit = getGeminiMaxTokensLimit(model);

package/src/types.ts

@@ -178,56 +178,6 @@ export interface ImageResult extends BaseResult {
 
 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);
-    }
-}
 
 //Internal structure used in driver implementation.
 export interface CompletionChunkObject {