@aj-archipelago/cortex 1.3.67 → 1.4.0

package/server/plugins/gemini25ImagePlugin.js

@@ -0,0 +1,155 @@
+import Gemini15VisionPlugin from './gemini15VisionPlugin.js';
+import logger from '../../lib/logger.js';
+import CortexResponse from '../../lib/cortexResponse.js';
+
+class Gemini25ImagePlugin extends Gemini15VisionPlugin {
+
+    constructor(pathway, model) {
+        super(pathway, model);
+    }
+
+    // Override getRequestParameters to add Gemini 2.5 specific response_modalities support
+    getRequestParameters(text, parameters, prompt, cortexRequest) {
+        const baseParameters = super.getRequestParameters(text, parameters, prompt, cortexRequest);
+        
+        // Add Gemini 2.5 specific response_modalities support
+        let responseModalities = parameters?.response_modalities;
+        if (typeof responseModalities === 'string') {
+            try {
+                responseModalities = JSON.parse(responseModalities);
+            } catch (e) {
+                responseModalities = null;
+            }
+        }
+
+        // Also check pathway parameters
+        if (!responseModalities && cortexRequest?.pathway?.response_modalities) {
+            responseModalities = cortexRequest.pathway.response_modalities;
+        }
+
+        // Set up generation_config with response_modalities if specified
+        if (responseModalities && Array.isArray(responseModalities)) {
+            baseParameters.generationConfig.response_modalities = responseModalities;
+        }
+
+        return baseParameters;
+    }
+
+
+    // Override parseResponse to add Gemini 2.5 image artifact support
+    parseResponse(data) {
+        // First, let the parent Gemini15VisionPlugin handle the response
+        const baseResponse = super.parseResponse(data);
+        
+        // If the parent already created a CortexResponse (for tool calls, safety blocks, etc.),
+        // we need to add image artifacts to it
+        if (baseResponse && typeof baseResponse === 'object' && baseResponse.constructor && baseResponse.constructor.name === 'CortexResponse') {
+            // Check for image artifacts in the raw data
+            if (data?.candidates?.[0]?.content?.parts) {
+                const parts = data.candidates[0].content.parts;
+                let imageContent = [];
+
+                for (const part of parts) {
+                    if (part.inlineData) {
+                        // Handle generated image content
+                        imageContent.push({
+                            type: "image",
+                            data: part.inlineData.data,
+                            mimeType: part.inlineData.mimeType
+                        });
+                    }
+                }
+
+                // If we have image artifacts, add them to the existing CortexResponse
+                if (imageContent.length > 0) {
+                    baseResponse.artifacts = imageContent;
+                }
+            }
+            
+            return baseResponse;
+        }
+        
+        // If the parent returned a string or other non-CortexResponse, check for image artifacts
+        if (data?.candidates?.[0]?.content?.parts) {
+            const parts = data.candidates[0].content.parts;
+            let imageContent = [];
+            let textContent = '';
+
+            for (const part of parts) {
+                if (part.inlineData) {
+                    // Handle generated image content
+                    imageContent.push({
+                        type: "image",
+                        data: part.inlineData.data,
+                        mimeType: part.inlineData.mimeType
+                    });
+                } else if (part.text) {
+                    textContent += part.text;
+                }
+            }
+
+            // If we have image artifacts, create a new CortexResponse object
+            if (imageContent.length > 0) {
+                return new CortexResponse({
+                    output_text: textContent || baseResponse || '',
+                    artifacts: imageContent,
+                    finishReason: data?.candidates?.[0]?.finishReason || 'stop',
+                    usage: data?.usage || null
+                });
+            }
+        }
+
+        return baseResponse;
+    }
+
+
+    // Override processStreamEvent to add Gemini 2.5 image artifact streaming
+    processStreamEvent(event, requestProgress) {
+        const baseProgress = super.processStreamEvent(event, requestProgress);
+        
+        // Add image artifact streaming for Gemini 2.5
+        const eventData = JSON.parse(event.data);
+        if (eventData.candidates?.[0]?.content?.parts) {
+            const parts = eventData.candidates[0].content.parts;
+            
+            for (const part of parts) {
+                if (part.inlineData) {
+                    // Handle generated image content in streaming
+                    // For now, we'll accumulate images and send them at the end
+                    // This could be enhanced to stream image data if needed
+                    if (!requestProgress.artifacts) {
+                        requestProgress.artifacts = [];
+                    }
+                    const inlineData = part.inlineData;
+                    requestProgress.artifacts.push({
+                        type: "image",
+                        data: inlineData.data,
+                        mimeType: inlineData.mimeType
+                    });
+                }
+            }
+        }
+
+        return baseProgress;
+    }
+
+    // Override logRequestData to properly handle CortexResponse objects
+    logRequestData(data, responseData, prompt) {
+        // Check if responseData is a CortexResponse object
+        if (responseData && typeof responseData === 'object' && responseData.constructor && responseData.constructor.name === 'CortexResponse') {
+            const { length, units } = this.getLength(responseData.output_text || '');
+            logger.info(`[response received containing ${length} ${units}]`);
+            if (responseData.artifacts && responseData.artifacts.length > 0) {
+                logger.info(`[response contains ${responseData.artifacts.length} image artifact(s)]`);
+            }
+            logger.verbose(`${this.shortenContent(responseData.output_text || '')}`);
+            return;
+        }
+
+        // Fall back to parent implementation for non-CortexResponse objects
+        super.logRequestData(data, responseData, prompt);
+    }
+
+}
+
+export default Gemini25ImagePlugin;

package/server/plugins/modelPlugin.js

@@ -6,6 +6,7 @@ import { getFirstNToken } from '../chunker.js';
 import logger, { obscureUrlParams } from '../../lib/logger.js';
 import { config } from '../../config.js';
 import axios from 'axios';
+import { extractValueFromTypeSpec } from '../typeDef.js';
 
 const DEFAULT_MAX_TOKENS = 4096;
 const DEFAULT_MAX_RETURN_TOKENS = 256;
@@ -28,11 +29,11 @@ class ModelPlugin {
 
         // Make all of the parameters defined on the pathway itself available to the prompt
         for (const [k, v] of Object.entries(pathway)) {
-            this.promptParameters[k] = v?.default ?? v;
+            this.promptParameters[k] = extractValueFromTypeSpec(v?.default ?? v);
         }
         if (pathway.inputParameters) {
             for (const [k, v] of Object.entries(pathway.inputParameters)) {
-                this.promptParameters[k] = v?.default ?? v;
+                this.promptParameters[k] = extractValueFromTypeSpec(v?.default ?? v);
             }
         }
 

package/server/plugins/openAiChatPlugin.js

@@ -48,12 +48,12 @@ class OpenAIChatPlugin extends ModelPlugin {
         const { modelPromptText, modelPromptMessages, tokenLength, modelPrompt } = this.getCompiledPrompt(text, parameters, prompt);
         let { stream, tools, functions } = parameters;
 
-        if (typeof tools === 'string') {
-            tools = JSON.parse(tools);
-        }
-        
-        if (typeof functions === 'string') {
-            functions = JSON.parse(functions);
+        try {    
+            tools = (tools && typeof tools === 'string' && tools !== '' ? JSON.parse(tools) : tools);
+            functions = (functions && typeof functions === 'string' && functions !== '' ? JSON.parse(functions) : functions);
+        } catch (e) {
+            tools = [];
+            functions = [];
         }
 
         // Define the model's max token length

package/server/plugins/replicateApiPlugin.js

@@ -1,5 +1,6 @@
 // replicateApiPlugin.js
 import ModelPlugin from "./modelPlugin.js";
+import CortexResponse from "../../lib/cortexResponse.js";
 import logger from "../../lib/logger.js";
 import axios from "axios";
 
@@ -92,6 +93,122 @@ class ReplicateApiPlugin extends ModelPlugin {
         };
         break;
       }
+      case "replicate-qwen-image": {
+        const aspectRatio = combinedParameters.aspect_ratio ?? combinedParameters.aspectRatio ?? "16:9";
+        const imageSize = combinedParameters.image_size ?? combinedParameters.imageSize ?? "optimize_for_quality";
+        const outputFormat = combinedParameters.output_format ?? combinedParameters.outputFormat ?? "webp";
+        const outputQuality = combinedParameters.output_quality ?? combinedParameters.outputQuality ?? 80;
+        const loraScale = combinedParameters.lora_scale ?? combinedParameters.loraScale ?? 1;
+        const enhancePrompt = combinedParameters.enhance_prompt ?? combinedParameters.enhancePrompt ?? false;
+        const negativePrompt = combinedParameters.negative_prompt ?? combinedParameters.negativePrompt ?? " ";
+        const numInferenceSteps = combinedParameters.num_inference_steps ?? combinedParameters.steps ?? 50;
+        const goFast = combinedParameters.go_fast ?? combinedParameters.goFast ?? true;
+        const guidance = combinedParameters.guidance ?? 4;
+        const strength = combinedParameters.strength ?? 0.9;
+        const numOutputs = combinedParameters.num_outputs ?? combinedParameters.numberResults;
+        const disableSafetyChecker = combinedParameters.disable_safety_checker ?? combinedParameters.disableSafetyChecker ?? false;
+
+        requestParameters = {
+          input: {
+            prompt: modelPromptText,
+            go_fast: goFast,
+            guidance,
+            strength,
+            image_size: imageSize,
+            lora_scale: loraScale,
+            aspect_ratio: aspectRatio,
+            output_format: outputFormat,
+            enhance_prompt: enhancePrompt,
+            output_quality: outputQuality,
+            negative_prompt: negativePrompt,
+            num_inference_steps: numInferenceSteps,
+            disable_safety_checker: disableSafetyChecker,
+            ...(numOutputs ? { num_outputs: numOutputs } : {}),
+            ...(combinedParameters.seed && Number.isInteger(combinedParameters.seed) ? { seed: combinedParameters.seed } : {}),
+            ...(combinedParameters.image ? { image: combinedParameters.image } : {}),
+            ...(combinedParameters.input_image ? { input_image: combinedParameters.input_image } : {}),
+          },
+        };
+        break;
+      }
+      case "replicate-qwen-image-edit-plus": {
+        const aspectRatio = combinedParameters.aspect_ratio ?? combinedParameters.aspectRatio ?? "match_input_image";
+        const outputFormat = combinedParameters.output_format ?? combinedParameters.outputFormat ?? "webp";
+        const outputQuality = combinedParameters.output_quality ?? combinedParameters.outputQuality ?? 95;
+        const goFast = combinedParameters.go_fast ?? combinedParameters.goFast ?? true;
+        const disableSafetyChecker = combinedParameters.disable_safety_checker ?? combinedParameters.disableSafetyChecker ?? false;
+
+        const collectImages = (candidate, accumulator) => {
+          if (!candidate) return;
+          if (Array.isArray(candidate)) {
+            candidate.forEach((item) => collectImages(item, accumulator));
+            return;
+          }
+          accumulator.push(candidate);
+        };
+
+        const imageCandidates = [];
+        collectImages(combinedParameters.image, imageCandidates);
+        collectImages(combinedParameters.images, imageCandidates);
+        collectImages(combinedParameters.input_image, imageCandidates);
+        collectImages(combinedParameters.input_images, imageCandidates);
+        collectImages(combinedParameters.input_image_1, imageCandidates);
+        collectImages(combinedParameters.input_image_2, imageCandidates);
+        collectImages(combinedParameters.input_image_3, imageCandidates);
+        collectImages(combinedParameters.image_1, imageCandidates);
+        collectImages(combinedParameters.image_2, imageCandidates);
+
+        const normalizeImageEntry = (entry) => {
+          if (!entry) return null;
+          if (typeof entry === "string") {
+            return entry; // Return the URL string directly
+          }
+          if (typeof entry === "object") {
+            if (Array.isArray(entry)) {
+              return null;
+            }
+            if (entry.value) {
+              return entry.value; // Return the value as a string
+            }
+            if (entry.url) {
+              return entry.url; // Return the URL as a string
+            }
+            if (entry.path) {
+              return entry.path; // Return the path as a string
+            }
+          }
+          return null;
+        };
+
+        const normalizedImages = imageCandidates
+          .map((candidate) => normalizeImageEntry(candidate))
+          .filter((candidate) => candidate && typeof candidate === 'string');
+
+        const omitUndefined = (obj) =>
+          Object.fromEntries(
+            Object.entries(obj).filter(([, value]) => value !== undefined && value !== null),
+          );
+
+        const basePayload = omitUndefined({
+          prompt: modelPromptText,
+          go_fast: goFast,
+          aspect_ratio: aspectRatio,
+          output_format: outputFormat,
+          output_quality: outputQuality,
+          disable_safety_checker: disableSafetyChecker,
+        });
+
+        // For qwen-image-edit-plus, always include the image array if we have images
+        const inputPayload = {
+          ...basePayload,
+          ...(normalizedImages.length > 0 ? { image: normalizedImages } : {})
+        };
+
+        requestParameters = {
+          input: inputPayload,
+        };
+        break;
+      }
       case "replicate-flux-kontext-pro":
       case "replicate-flux-kontext-max": {
         const validRatios = [
@@ -110,7 +227,7 @@ class ReplicateApiPlugin extends ModelPlugin {
             input_image: combinedParameters.input_image,
             aspect_ratio: validRatios.includes(combinedParameters.aspectRatio) ? combinedParameters.aspectRatio : "1:1",
             safety_tolerance: safetyTolerance,
-            ...(combinedParameters.seed && Number.isInteger(combinedParameters.seed && combinedParameters.seed > 0) ? { seed: combinedParameters.seed } : {}),
+            ...(combinedParameters.seed && Number.isInteger(combinedParameters.seed) && combinedParameters.seed > 0 ? { seed: combinedParameters.seed } : {}),
           },
         };
         break;
@@ -133,7 +250,7 @@ class ReplicateApiPlugin extends ModelPlugin {
             input_image_2: combinedParameters.input_image_2,
             aspect_ratio: validRatios.includes(combinedParameters.aspectRatio) ? combinedParameters.aspectRatio : "1:1",
             safety_tolerance: safetyTolerance,
-            ...(combinedParameters.seed && Number.isInteger(combinedParameters.seed && combinedParameters.seed > 0) ? { seed: combinedParameters.seed } : {}),
+            ...(combinedParameters.seed && Number.isInteger(combinedParameters.seed) && combinedParameters.seed > 0 ? { seed: combinedParameters.seed } : {}),
           },
         };
         break;
@@ -148,7 +265,7 @@ class ReplicateApiPlugin extends ModelPlugin {
             prompt: modelPromptText,
             resolution: validResolutions.includes(combinedParameters.resolution) ? combinedParameters.resolution : "1080p",
             aspect_ratio: validRatios.includes(combinedParameters.aspectRatio) ? combinedParameters.aspectRatio : "16:9",
-            ...(combinedParameters.seed && Number.isInteger(combinedParameters.seed && combinedParameters.seed > 0) ? { seed: combinedParameters.seed } : {}),
+            ...(combinedParameters.seed && Number.isInteger(combinedParameters.seed) && combinedParameters.seed > 0 ? { seed: combinedParameters.seed } : {}),
             fps: validFps.includes(combinedParameters.fps) ? combinedParameters.fps : 24,
             camera_fixed: combinedParameters.camera_fixed || false,
             duration: combinedParameters.duration || 5,
@@ -157,6 +274,86 @@ class ReplicateApiPlugin extends ModelPlugin {
         };
         break;
       }
+      case "replicate-seedream-4": {
+        const validSizes = ["1K", "2K", "4K", "custom"];
+        const validRatios = ["1:1", "4:3", "3:4", "16:9", "9:16", "match_input_image"];
+        const validSequentialModes = ["disabled", "auto"];
+
+        // Collect input images from multiple parameter sources (same pattern as qwen-image-edit-plus)
+        const collectImages = (candidate, accumulator) => {
+          if (!candidate) return;
+          if (Array.isArray(candidate)) {
+            candidate.forEach((item) => collectImages(item, accumulator));
+            return;
+          }
+          accumulator.push(candidate);
+        };
+
+        const imageCandidates = [];
+        collectImages(combinedParameters.image, imageCandidates);
+        collectImages(combinedParameters.images, imageCandidates);
+        collectImages(combinedParameters.input_image, imageCandidates);
+        collectImages(combinedParameters.input_images, imageCandidates);
+        collectImages(combinedParameters.input_image_1, imageCandidates);
+        collectImages(combinedParameters.input_image_2, imageCandidates);
+        collectImages(combinedParameters.input_image_3, imageCandidates);
+        collectImages(combinedParameters.image_1, imageCandidates);
+        collectImages(combinedParameters.image_2, imageCandidates);
+        collectImages(combinedParameters.imageInput, imageCandidates);
+
+        const normalizeImageEntry = (entry) => {
+          if (!entry) return null;
+          if (typeof entry === "string") {
+            return entry; // Return the URL string directly
+          }
+          if (typeof entry === "object") {
+            if (Array.isArray(entry)) {
+              return null;
+            }
+            if (entry.value) {
+              return entry.value; // Return the value as a string
+            }
+            if (entry.url) {
+              return entry.url; // Return the URL as a string
+            }
+            if (entry.path) {
+              return entry.path; // Return the path as a string
+            }
+          }
+          return null;
+        };
+
+        const normalizedImages = imageCandidates
+          .map((candidate) => normalizeImageEntry(candidate))
+          .filter((candidate) => candidate && typeof candidate === 'string');
+
+        const omitUndefined = (obj) =>
+          Object.fromEntries(
+            Object.entries(obj).filter(([, value]) => value !== undefined && value !== null),
+          );
+
+        const basePayload = omitUndefined({
+          prompt: modelPromptText,
+          size: validSizes.includes(combinedParameters.size) ? combinedParameters.size : "2K",
+          width: combinedParameters.width || 2048,
+          height: combinedParameters.height || 2048,
+          max_images: combinedParameters.maxImages || combinedParameters.numberResults || 1,
+          aspect_ratio: validRatios.includes(combinedParameters.aspectRatio) ? combinedParameters.aspectRatio : "4:3",
+          sequential_image_generation: validSequentialModes.includes(combinedParameters.sequentialImageGeneration) ? combinedParameters.sequentialImageGeneration : "disabled",
+          ...(combinedParameters.seed && Number.isInteger(combinedParameters.seed) && combinedParameters.seed > 0 ? { seed: combinedParameters.seed } : {}),
+        });
+
+        // For seedream-4, include the image_input array if we have images
+        const inputPayload = {
+          ...basePayload,
+          ...(normalizedImages.length > 0 ? { image_input: normalizedImages } : {})
+        };
+
+        requestParameters = {
+          input: inputPayload,
+        };
+        break;
+      }
     }
 
     return requestParameters;
@@ -174,12 +371,14 @@ class ReplicateApiPlugin extends ModelPlugin {
     cortexRequest.params = requestParameters.params;
 
     // Make initial request to start prediction
-    const stringifiedResponse = await this.executeRequest(cortexRequest);
-    const parsedResponse = JSON.parse(stringifiedResponse);
+    const response = await this.executeRequest(cortexRequest);
+    
+    // Parse the response to get the actual Replicate data
+    const parsedResponse = JSON.parse(response.output_text);
 
-    // If we got a completed response, return it
+    // If we got a completed response, return it as CortexResponse
     if (parsedResponse?.status === "succeeded") {
-      return stringifiedResponse;
+      return this.createCortexResponse(response);
     }
     
     logger.info("Replicate API returned a non-completed response.");
@@ -211,7 +410,9 @@ class ReplicateApiPlugin extends ModelPlugin {
         
         if (status === "succeeded") {
           logger.info("Replicate API returned a completed response after polling");
-          return JSON.stringify(pollResponse.data);
+          // Parse the polled response to extract artifacts
+          const parsedResponse = this.parseResponse(pollResponse.data);
+          return this.createCortexResponse(parsedResponse);
         } else if (status === "failed" || status === "canceled") {
           throw new Error(`Prediction ${status}: ${pollResponse.data?.error || "Unknown error"}`);
         }
@@ -227,12 +428,67 @@ class ReplicateApiPlugin extends ModelPlugin {
     throw new Error(`Prediction ${predictionId} timed out after ${maxAttempts * pollInterval / 1000} seconds`);
   }
 
-  // Stringify the response from the Replicate API
+  // Parse the response from the Replicate API and extract image artifacts
   parseResponse(data) {
-    if (data.data) {
-      return JSON.stringify(data.data);
+    const responseData = data.data || data;
+    const stringifiedResponse = JSON.stringify(responseData);
+    
+    // Extract image URLs from Replicate response for artifacts
+    const imageArtifacts = [];
+    if (responseData?.output && Array.isArray(responseData.output)) {
+      for (const outputItem of responseData.output) {
+        if (typeof outputItem === 'string' && outputItem.match(/\.(jpg|jpeg|png|gif|webp)$/i)) {
+          // This is an image URL from Replicate
+          imageArtifacts.push({
+            type: "image",
+            url: outputItem,
+            mimeType: this.getMimeTypeFromUrl(outputItem)
+          });
+        }
+      }
+    }
+    
+    return {
+      output_text: stringifiedResponse,
+      artifacts: imageArtifacts
+    };
+  }
+
+  // Create a CortexResponse from parsed response data
+  createCortexResponse(parsedResponse) {
+    if (typeof parsedResponse === 'string') {
+      // Handle string response (backward compatibility)
+      return new CortexResponse({
+        output_text: parsedResponse,
+        artifacts: []
+      });
+    } else if (parsedResponse && typeof parsedResponse === 'object') {
+      // Handle object response with artifacts
+      return new CortexResponse({
+        output_text: parsedResponse.output_text,
+        artifacts: parsedResponse.artifacts || []
+      });
+    } else {
+      throw new Error('Unexpected response format');
+    }
+  }
+
+  // Helper method to determine MIME type from URL extension
+  getMimeTypeFromUrl(url) {
+    const extension = url.split('.').pop().toLowerCase();
+    switch (extension) {
+      case 'jpg':
+      case 'jpeg':
+        return 'image/jpeg';
+      case 'png':
+        return 'image/png';
+      case 'gif':
+        return 'image/gif';
+      case 'webp':
+        return 'image/webp';
+      default:
+        return 'image/jpeg'; // Default fallback
     }
-    return JSON.stringify(data);
   }
 
   // Override the logging function to display the request and response

package/server/plugins/veoVideoPlugin.js

@@ -19,7 +19,8 @@ class VeoVideoPlugin extends ModelPlugin {
     // Available Veo models
     const availableModels = {
       'veo-2.0-generate': 'GA',
-      'veo-3.0-generate': 'Preview'
+      'veo-3.0-generate': 'Preview',
+      'veo-3.0-fast-generate': 'Preview'
     };
 
     // Get the model ID from the pathway or use default
@@ -51,6 +52,7 @@ class VeoVideoPlugin extends ModelPlugin {
         ...(combinedParameters.enhancePrompt !== undefined && { enhancePrompt: combinedParameters.enhancePrompt }),
         // generateAudio is required for 3.0 and not supported by 2.0
         ...(model === 'veo-3.0-generate' && { generateAudio: combinedParameters.generateAudio !== undefined ? combinedParameters.generateAudio : true }),
+        ...(model === 'veo-3.0-fast-generate' && { generateAudio: combinedParameters.generateAudio !== undefined ? combinedParameters.generateAudio : true }),
         ...(combinedParameters.negativePrompt && { negativePrompt: combinedParameters.negativePrompt }),
         ...(combinedParameters.personGeneration && { personGeneration: combinedParameters.personGeneration }),
         ...(combinedParameters.sampleCount && { sampleCount: combinedParameters.sampleCount }),
@@ -69,6 +71,9 @@ class VeoVideoPlugin extends ModelPlugin {
       if (model === 'veo-3.0-generate' && parameters.durationSeconds !== 8) {
         throw new Error(`Veo 3.0 only supports durationSeconds: 8, got: ${parameters.durationSeconds}`);
       }
+      if (model === 'veo-3.0-fast-generate' && parameters.durationSeconds !== 8) {
+        throw new Error(`Veo 3.0 only supports durationSeconds: 8, got: ${parameters.durationSeconds}`);
+      }
       if (model === 'veo-2.0-generate' && (parameters.durationSeconds < 5 || parameters.durationSeconds > 8)) {
         throw new Error(`Veo 2.0 supports durationSeconds between 5-8, got: ${parameters.durationSeconds}`);
       }
@@ -82,6 +87,12 @@ class VeoVideoPlugin extends ModelPlugin {
       if (parameters.video) {
         throw new Error('video parameter is not supported in Veo 3.0');
       }
+      if (model === 'veo-3.0-fast-generate' && parameters.lastFrame) {
+        throw new Error('lastFrame parameter is not supported in Veo 3.0');
+      }
+      if (model === 'veo-3.0-fast-generate' && parameters.video) {
+        throw new Error('video parameter is not supported in Veo 3.0');
+      }
     }
 
     // generateAudio constraints
@@ -91,6 +102,9 @@ class VeoVideoPlugin extends ModelPlugin {
     if (model === 'veo-3.0-generate' && parameters.generateAudio === undefined) {
       logger.warn('generateAudio is required for Veo 3.0, defaulting to true');
     }
+    if (model === 'veo-3.0-fast-generate' && parameters.generateAudio === undefined) {
+      logger.warn('generateAudio is required for Veo 3.0, defaulting to true');
+    }
   }
 
   // Execute the request to the Veo API

package/server/rest.js

@@ -139,6 +139,8 @@ const processRestRequest = async (server, req, pathway, name, parameterMap = {})
             return Boolean(value);
         } else if (type === 'Int') {
             return parseInt(value, 10);
+        } else if (type === 'Float') {
+            return parseFloat(value);
         } else if (type === '[MultiMessage]' && Array.isArray(value)) {
             return value.map(msg => ({
                 ...msg,