@aj-archipelago/cortex 1.3.54 → 1.3.56

package/config/default.example.json

@@ -37,7 +37,7 @@
         },
         "gemini-pro-15-vision": {
             "type": "GEMINI-VISION",
-            "url": "https://us-central1-aiplatform.googleapis.com/v1/projects/project-id/locations/us-central1/publishers/google/models/gemini-1.5-pro-preview-0215:streamGenerateContent",
+            "url": "https://us-central1-aiplatform.googleapis.com/v1/projects/project-id/locations/us-central1/publishers/google/models/gemini-1.5-pro:streamGenerateContent",
             "headers": {
                 "Content-Type": "application/json"
             },
@@ -48,7 +48,7 @@
         },
         "gemini-pro-25-vision": {
             "type": "GEMINI-VISION",
-            "url": "https://us-central1-aiplatform.googleapis.com/v1/projects/project-id/locations/us-central1/publishers/google/models/gemini-2.5-pro-exp-03-25:streamGenerateContent",
+            "url": "https://us-central1-aiplatform.googleapis.com/v1/projects/project-id/locations/us-central1/publishers/google/models/gemini-2.5-pro:streamGenerateContent",
             "headers": {
                 "Content-Type": "application/json"
             },

package/config.js

@@ -290,6 +290,15 @@ var config = convict({
                     "Content-Type": "application/json"
                 },
             },
+            "replicate-seedance-1-pro": {
+                "type": "REPLICATE-API",
+                "url": "https://api.replicate.com/v1/models/bytedance/seedance-1-pro/predictions",
+                "headers": {
+                    "Prefer": "wait",
+                    "Authorization": "Token {{REPLICATE_API_KEY}}",
+                    "Content-Type": "application/json"
+                },
+            },
             "replicate-flux-11-pro": {
                 "type": "REPLICATE-API",
                 "url": "https://api.replicate.com/v1/models/black-forest-labs/flux-1.1-pro/predictions",
@@ -344,6 +353,15 @@ var config = convict({
                     "Content-Type": "application/json"
                 },
             },
+            "replicate-multi-image-kontext-max": {
+                "type": "REPLICATE-API",
+                "url": "https://api.replicate.com/v1/models/flux-kontext-apps/multi-image-kontext-max/predictions",
+                "headers": {
+                    "Prefer": "wait",
+                    "Authorization": "Token {{REPLICATE_API_KEY}}",
+                    "Content-Type": "application/json"
+                },
+            },
             "azure-video-translate": {
                 "type": "AZURE-VIDEO-TRANSLATE",
                 "url": "https://eastus.api.cognitive.microsoft.com/videotranslation",

package/lib/entityConstants.js

@@ -120,6 +120,8 @@ term~N                 (Match terms similar to "term", edit distance N)
 
     AI_GROUNDING_INSTRUCTIONS: "# Grounding Responses\n\nIf you base part or all of your response on one or more search results, you MUST cite the source using a custom markdown directive of the form :cd_source[searchResultId]. There is NO other valid way to cite a source and a good UX depends on you using this directive correctly. Do not include other clickable links to the sourcewhen using the :cd_source[searchResultId] directive. Every search result has a unique searchResultId. You must include it verbatim, copied directly from the search results. Place the directives at the end of the phrase, sentence or paragraph that is grounded in that particular search result. If you are citing multiple search results, use multiple individual :cd_source[searchResultId] directives (e.g. :cd_source[searchResultId1] :cd_source[searchResultId2] :cd_source[searchResultId3] etc.)",
 
+    AI_AVAILABLE_FILES: "# Available Files\n\nThe following files are available for you to use in your tool calls or responses:\n{{{availableFiles}}}\n",
+
     AI_MEMORY_INSTRUCTIONS: `# Memory Instructions
 
 You have a memory system that contains important details, instructions, and context. Consult your memories when formulating a response to ensure your answers reflect previous learnings and context.

package/lib/util.js

@@ -310,6 +310,60 @@ function removeImageAndFileFromMessage(message) {
     return modifiedMessage;
 }
 
+// Helper function to extract file URLs from a content object
+function extractFileUrlsFromContent(contentObj) {
+    const urls = [];
+    if (contentObj.type === 'image_url' && contentObj.image_url?.url) {
+        urls.push(contentObj.image_url.url);
+    } else if (contentObj.type === 'file' && contentObj.file) {
+        urls.push(contentObj.file);
+    }
+    return urls;
+}
+
+function getAvailableFiles(chatHistory) {
+    const availableFiles = [];
+    
+    if (!chatHistory || !Array.isArray(chatHistory)) {
+        return availableFiles;
+    }
+    
+    for (const message of chatHistory) {
+        if (!message || !message.content) {
+            continue;
+        }
+        
+        // Handle array content
+        if (Array.isArray(message.content)) {
+            for (const content of message.content) {
+                try {
+                    const contentObj = typeof content === 'string' ? JSON.parse(content) : content;
+                    availableFiles.push(...extractFileUrlsFromContent(contentObj));
+                } catch (e) {
+                    // Not JSON or couldn't be parsed, continue
+                    continue;
+                }
+            }
+        }
+        // Handle string content
+        else if (typeof message.content === 'string') {
+            try {
+                const contentObj = JSON.parse(message.content);
+                availableFiles.push(...extractFileUrlsFromContent(contentObj));
+            } catch (e) {
+                // Not JSON or couldn't be parsed, continue
+                continue;
+            }
+        }
+        // Handle object content
+        else if (typeof message.content === 'object') {
+            availableFiles.push(...extractFileUrlsFromContent(message.content));
+        }
+    }
+    
+    return availableFiles;
+}
+
 export { 
     getUniqueId,
     getSearchResultId,
@@ -322,5 +376,6 @@ export {
     alignSubtitles,
     getMediaChunks,
     markCompletedForCleanUp,
-    removeOldImageAndFileContent
+    removeOldImageAndFileContent,
+    getAvailableFiles
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.3.54",
+  "version": "1.3.56",
   "description": "Cortex is a GraphQL API for AI. It provides a simple, extensible interface for using AI services from OpenAI, Azure and others.",
   "private": false,
   "repository": {

package/pathways/image_flux.js

@@ -14,5 +14,6 @@ export default {
     output_quality: 80,
     steps: 4,
     input_image: "", // URL to input image for models that support it
+    input_image_2: "", // URL to second input image for models that support it
   },
 };

package/pathways/system/entity/sys_entity_agent.js

@@ -5,7 +5,7 @@ const MAX_TOOL_CALLS = 50;
 import { callPathway, callTool, say } from '../../../lib/pathwayTools.js';
 import logger from '../../../lib/logger.js';
 import { config } from '../../../config.js';
-import { chatArgsHasImageUrl, removeOldImageAndFileContent } from '../../../lib/util.js';
+import { chatArgsHasImageUrl, removeOldImageAndFileContent, getAvailableFiles } from '../../../lib/util.js';
 import { Prompt } from '../../../server/prompt.js';
 import { getToolsForEntity, loadEntityConfig } from './tools/shared/sys_entity_tools.js';
 
@@ -275,7 +275,7 @@ export default {
         const instructionTemplates = entityInstructions ? (entityInstructions + '\n\n') : `{{renderTemplate AI_COMMON_INSTRUCTIONS}}\n\n{{renderTemplate AI_EXPERTISE}}\n\n`;
 
         const promptMessages = [
-            {"role": "system", "content": `${promptPrefix}${instructionTemplates}{{renderTemplate AI_TOOLS}}\n\n{{renderTemplate AI_SEARCH_RULES}}\n\n{{renderTemplate AI_SEARCH_SYNTAX}}\n\n{{renderTemplate AI_GROUNDING_INSTRUCTIONS}}\n\n${memoryTemplates}{{renderTemplate AI_DATETIME}}`},
+            {"role": "system", "content": `${promptPrefix}${instructionTemplates}{{renderTemplate AI_TOOLS}}\n\n{{renderTemplate AI_SEARCH_RULES}}\n\n{{renderTemplate AI_SEARCH_SYNTAX}}\n\n{{renderTemplate AI_GROUNDING_INSTRUCTIONS}}\n\n${memoryTemplates}{{renderTemplate AI_AVAILABLE_FILES}}\n\n{{renderTemplate AI_DATETIME}}`},
             "{{chatHistory}}",
         ];
 
@@ -294,6 +294,8 @@ export default {
             args.chatHistory = args.chatHistory.slice(-20);
         }
 
+        const availableFiles = getAvailableFiles(args.chatHistory);
+
         // remove old image and file content
         const visionContentPresent = chatArgsHasImageUrl(args);
         visionContentPresent && (args.chatHistory = removeOldImageAndFileContent(args.chatHistory));
@@ -327,6 +329,7 @@ export default {
             let response = await runAllPrompts({
                 ...args,
                 chatHistory: currentMessages,
+                availableFiles,
                 tools: entityToolsOpenAiFormat,
                 tool_choice: memoryLookupRequired ? "required" : "auto"
             });

package/pathways/system/entity/tools/sys_tool_image.js

@@ -41,13 +41,17 @@ export default {
         icon: "🔄",
         function: {
             name: "ModifyImage",
-            description: "Use when asked to modify, transform, or edit an existing image. This tool can apply various transformations like style changes, artistic effects, or specific modifications to an image that has been previously uploaded or generated.",
+            description: "Use when asked to modify, transform, or edit an existing image. This tool can apply various transformations like style changes, artistic effects, or specific modifications to an image that has been previously uploaded or generated. It takes up to two input images as a reference and outputs a new image based on the instructions.",
             parameters: {
                 type: "object",
                 properties: {
                     inputImage: {
                         type: "string",
-                        description: "The URL of the input image to modify. This should be a publicly accessible URL of an image that has been previously uploaded or generated."
+                        description: "The first image URL copied exactly from an image_url field in your chat context."
+                    },
+                    inputImage2: {
+                        type: "string",
+                        description: "The second input image URL copied exactly from an image_url field in your chat context if there is one."
                     },
                     detailedInstructions: {
                         type: "string",
@@ -77,6 +81,11 @@ export default {
                 model = "replicate-flux-kontext-max";
             }
 
+            // If we have two input images, use the multi-image-kontext-max model
+            if (args.inputImage2) {
+                model = "replicate-multi-image-kontext-max";
+            }
+
             pathwayResolver.tool = JSON.stringify({ toolUsed: "image" });
             return await callPathway('image_flux', {
                 ...args, 
@@ -85,7 +94,8 @@ export default {
                 numberResults, 
                 model, 
                 stream: false,
-                input_image: args.inputImage
+                input_image: args.inputImage,
+                input_image_2: args.inputImage2,
             });
 
         } catch (e) {

package/pathways/system/sys_test_response_reasonableness.js

@@ -0,0 +1,20 @@
+import { Prompt } from '../../server/prompt.js';
+
+export default {
+    prompt: [
+        new Prompt({
+            messages: [
+                { "role": "system", "content": "Assistant is a response quality evaluator. When given a chat history and a response to evaluate, assistant will carefully analyze whether the response is reasonable given the context of the conversation. Primarily the assistant is trying to detect errors and hallucinations in the underlying models. As long as the response looks basically correct and relevant, even if it's not ideal or complete or contradicts some rules, it should be isReasonable: true.\n\nAssistant will return a JSON object with the following structure:\n{\n  \"isReasonable\": boolean,\n  \"score\": number (0-10),\n  \"reasoning\": string\n}\n\nWhere:\n- isReasonable: Overall judgment of whether the response is reasonable\n- score: Numerical score from 0-10 (10 being excellent)\n- reasoning: Brief explanation of the judgment" },
+                "{{chatHistory}}",
+                { "role": "user", "content": `The response to the above conversation from the model was: '{{{modelResponse}}}'. Is that response acceptable?`},
+            ]
+        })
+    ],
+    inputParameters: {
+        chatHistory: [{role: '', content: []}],
+        modelResponse: '',
+    },
+    model: 'oai-gpt4o-mini',
+    enableDuplicateRequests: false,
+    json: true
+} 

package/pathways/video_seedance.js

@@ -0,0 +1,17 @@
+export default {
+  prompt: ["{{text}}"],
+
+  enableDuplicateRequests: false,
+  inputParameters: {
+    model: "replicate-seedance-1-pro",
+    resolution: "1080p",
+    aspectRatio: "16:9",
+    fps: 24,
+    duration: 5,
+    image: "",
+    camera_fixed: false,
+    seed: -1,
+  },
+
+  timeout: 60 * 30, // 30 minutes
+};

package/pathways/video_veo.js

@@ -0,0 +1,31 @@
+// video_veo.js
+// Pathway for generating videos using Google's Veo model via Vertex AI
+//
+// Model-specific constraints:
+// - Veo 2.0: durationSeconds 5-8, no generateAudio, supports lastFrame/video
+// - Veo 3.0: durationSeconds always 8, generateAudio required, no lastFrame/video
+
+export default {
+  prompt: ["Generate a video based on the following description: {{text}}"],
+  
+  enableDuplicateRequests: false,
+  inputParameters: {
+    text: "",
+    image: "",
+    video: "",
+    lastFrame: "",
+    model: "veo-2.0-generate",
+    aspectRatio: "16:9",
+    durationSeconds: 8, // 5-8 for 2.0, always 8 for 3.0
+    enhancePrompt: true,
+    generateAudio: false, // not supported in 2.0, required in 3.0
+    negativePrompt: "",
+    personGeneration: "allow_all",
+    sampleCount: 1,
+    storageUri: "",
+    location: "us-central1",
+    seed: -1,
+  },
+
+  timeout: 60 * 30, // 30 minutes
+}; 

package/server/modelExecutor.js

@@ -29,6 +29,7 @@ import ReplicateApiPlugin from './plugins/replicateApiPlugin.js';
 import AzureVideoTranslatePlugin from './plugins/azureVideoTranslatePlugin.js';
 import OllamaChatPlugin from './plugins/ollamaChatPlugin.js';
 import OllamaCompletionPlugin from './plugins/ollamaCompletionPlugin.js';
+import VeoVideoPlugin from './plugins/veoVideoPlugin.js';
 
 class ModelExecutor {
     constructor(pathway, model) {
@@ -117,6 +118,9 @@ class ModelExecutor {
             case 'OLLAMA-COMPLETION':
                 plugin = new OllamaCompletionPlugin(pathway, model);
                 break;
+            case 'VEO-VIDEO':
+                plugin = new VeoVideoPlugin(pathway, model);
+                break;
             default:
                 throw new Error(`Unsupported model type: ${model.type}`);
         }

package/server/plugins/replicateApiPlugin.js

@@ -35,6 +35,7 @@ class ReplicateApiPlugin extends ModelPlugin {
             height: combinedParameters.height,
             size: combinedParameters.size || "1024x1024",
             style: combinedParameters.style || "realistic_image",
+            ...(combinedParameters.seed && Number.isInteger(combinedParameters.seed) ? { seed: combinedParameters.seed } : {}),
           },
         };
         break;
@@ -98,11 +99,60 @@ class ReplicateApiPlugin extends ModelPlugin {
           '5:4', '3:4', '4:3', '9:16', '9:21', 'match_input_image'
         ];
 
+        let safetyTolerance = combinedParameters.safety_tolerance || 3;
+        if(combinedParameters.input_image){
+          safetyTolerance = Math.min(safetyTolerance, 2);
+        }
+
         requestParameters = {
           input: {
             prompt: modelPromptText,
             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 } : {}),
+          },
+        };
+        break;
+      }
+      case "replicate-multi-image-kontext-max": {
+        const validRatios = [
+          '1:1', '16:9', '21:9', '3:2', '2:3', '4:5',
+          '5:4', '3:4', '4:3', '9:16', '9:21', 'match_input_image'
+        ];
+
+        let safetyTolerance = combinedParameters.safety_tolerance || 3;
+        if(combinedParameters.input_image_1 || combinedParameters.input_image) {
+          safetyTolerance = Math.min(safetyTolerance, 2);
+        }
+
+        requestParameters = {
+          input: {
+            prompt: modelPromptText,
+            input_image_1: combinedParameters.input_image_1 || combinedParameters.input_image,
+            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 } : {}),
+          },
+        };
+        break;
+      }
+      case "replicate-seedance-1-pro": {
+        const validResolutions = ["480p", "1080p"];
+        const validRatios = ["16:9", "4:3", "9:16", "1:1", "3:4", "21:9", "9:21"];
+        const validFps = [24];
+
+        requestParameters = {
+          input: {
+            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 } : {}),
+            fps: validFps.includes(combinedParameters.fps) ? combinedParameters.fps : 24,
+            camera_fixed: combinedParameters.camera_fixed || false,
+            duration: combinedParameters.duration || 5,
+            ...(combinedParameters.image ? { image: combinedParameters.image } : {}),
           },
         };
         break;

package/server/plugins/veoVideoPlugin.js

@@ -0,0 +1,218 @@
+import ModelPlugin from "./modelPlugin.js";
+import logger from "../../lib/logger.js";
+import axios from "axios";
+
+class VeoVideoPlugin extends ModelPlugin {
+  constructor(pathway, model) {
+    super(pathway, model);
+  }
+
+  // Set up parameters specific to the Veo API
+  getRequestParameters(text, parameters, prompt) {
+    const combinedParameters = { ...this.promptParameters, ...parameters };
+    const { modelPromptText } = this.getCompiledPrompt(
+      text,
+      parameters,
+      prompt,
+    );
+
+    // Available Veo models
+    const availableModels = {
+      'veo-2.0-generate': 'GA',
+      'veo-3.0-generate': 'Preview'
+    };
+
+    // Get the model ID from the pathway or use default
+    const model = combinedParameters.model || 'veo-2.0-generate';
+    
+    if (!availableModels[model]) {
+      throw new Error(`Invalid Veo model ID: ${model}. Available models: ${Object.keys(availableModels).join(', ')}`);
+    }
+
+    // Validate model-specific parameter constraints
+    this.validateModelSpecificParameters(combinedParameters, model);
+
+    // Build the request parameters based on Veo API documentation
+    const requestParameters = {
+      instances: [
+        {
+          prompt: modelPromptText,
+          // Optional input media fields
+          ...(combinedParameters.image && { image: JSON.parse(combinedParameters.image) }),
+          // lastFrame and video are only supported in 2.0
+          ...(model === 'veo-2.0-generate' && combinedParameters.lastFrame && { lastFrame: JSON.parse(combinedParameters.lastFrame) }),
+          ...(model === 'veo-2.0-generate' && combinedParameters.video && { video: JSON.parse(combinedParameters.video) }),
+        }
+      ],
+      parameters: {
+        // Generation parameters
+        ...(combinedParameters.aspectRatio && { aspectRatio: combinedParameters.aspectRatio }),
+        ...(combinedParameters.durationSeconds && { durationSeconds: combinedParameters.durationSeconds }),
+        ...(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 }),
+        ...(combinedParameters.negativePrompt && { negativePrompt: combinedParameters.negativePrompt }),
+        ...(combinedParameters.personGeneration && { personGeneration: combinedParameters.personGeneration }),
+        ...(combinedParameters.sampleCount && { sampleCount: combinedParameters.sampleCount }),
+        ...(combinedParameters.seed && Number.isInteger(combinedParameters.seed && combinedParameters.seed > 0) ? { seed: combinedParameters.seed } : {}),
+        ...(combinedParameters.storageUri && { storageUri: combinedParameters.storageUri }),
+      }
+    };
+
+    return requestParameters;
+  }
+
+  // Validate model-specific parameter constraints
+  validateModelSpecificParameters(parameters, model) {
+    // Duration constraints
+    if (parameters.durationSeconds !== undefined) {
+      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-2.0-generate' && (parameters.durationSeconds < 5 || parameters.durationSeconds > 8)) {
+        throw new Error(`Veo 2.0 supports durationSeconds between 5-8, got: ${parameters.durationSeconds}`);
+      }
+    }
+
+    // lastFrame and video constraints
+    if (model === 'veo-3.0-generate') {
+      if (parameters.lastFrame) {
+        throw new Error('lastFrame parameter is not supported in Veo 3.0');
+      }
+      if (parameters.video) {
+        throw new Error('video parameter is not supported in Veo 3.0');
+      }
+    }
+
+    // generateAudio constraints
+    if (model === 'veo-2.0-generate' && parameters.generateAudio) {
+      throw new Error('generateAudio parameter is not supported in Veo 2.0');
+    }
+    if (model === 'veo-3.0-generate' && parameters.generateAudio === undefined) {
+      logger.warn('generateAudio is required for Veo 3.0, defaulting to true');
+    }
+  }
+
+  // Execute the request to the Veo API
+  async execute(text, parameters, prompt, cortexRequest) {
+    const requestParameters = this.getRequestParameters(
+      text,
+      parameters,
+      prompt,
+    );
+
+    cortexRequest.data = requestParameters;
+    cortexRequest.params = requestParameters.params;
+
+    // Get the model ID for the URL
+    const model = parameters.model || 'veo-2.0-generate';
+    
+    // Use the URL from the model configuration (cortexRequest.url is set by Cortex)
+    const baseUrl = cortexRequest.url;
+    const predictUrl = `${baseUrl}:predictLongRunning`;
+
+    // Set up the request
+    const requestConfig = {
+      method: 'POST',
+      url: predictUrl,
+      headers: {
+        'Content-Type': 'application/json',
+        ...cortexRequest.headers
+      },
+      data: requestParameters
+    };
+
+    // Get authentication token
+    const gcpAuthTokenHelper = this.config.get('gcpAuthTokenHelper');
+    const authToken = await gcpAuthTokenHelper.getAccessToken();
+    requestConfig.headers.Authorization = `Bearer ${authToken}`;
+
+    logger.info(`Starting Veo video generation with model: ${model}`);
+
+    try {
+      // Make initial request to start video generation
+      const response = await axios(requestConfig);
+      const operationName = response.data.name;
+
+      if (!operationName) {
+        throw new Error("No operation name returned from Veo API");
+      }
+
+      logger.info(`Veo video generation started. Operation: ${operationName}`);
+
+      // Poll for results
+      const maxAttempts = 120; // 10 minutes with 5 second intervals
+      const pollInterval = 5000;
+      
+      for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+          // Poll the operation status
+          const pollResponse = await axios.post(
+            `${baseUrl}:fetchPredictOperation`,
+            { operationName },
+            {
+              headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${authToken}`
+              }
+            }
+          );
+
+          const operationData = pollResponse.data;
+          logger.info(`Polling Veo operation ${operationName} - attempt ${attempt + 1}, done: ${operationData.done || false}`);
+
+          if (operationData.done) {
+            if (operationData.response && operationData.response.videos) {
+              logger.info(`Veo video generation completed successfully`);
+              return JSON.stringify(operationData);
+            } else {
+              throw new Error(`Veo operation completed but no videos returned: ${JSON.stringify(operationData)}`);
+            }
+          }
+
+          // Wait before next poll
+          await new Promise(resolve => setTimeout(resolve, pollInterval));
+        } catch (error) {
+          logger.error(`Error polling Veo operation: ${error.message}`);
+          throw error;
+        }
+      }
+
+      throw new Error(`Veo video generation timed out after ${maxAttempts * pollInterval / 1000} seconds`);
+    } catch (error) {
+      logger.error(`Veo video generation failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // Parse the response from the Veo API
+  parseResponse(data) {
+    if (data.response && data.response.videos) {
+      // Return the videos array with GCS URIs
+      return JSON.stringify({
+        videos: data.response.videos,
+        operationName: data.name,
+        status: 'completed'
+      });
+    }
+    return JSON.stringify(data);
+  }
+
+  // Override the logging function to display the request and response
+  logRequestData(data, responseData, prompt) {
+    const modelInput = data?.instances?.[0]?.prompt;
+    const model = this.model || 'veo-2.0-generate';
+    const parameters = data?.parameters || {};
+
+    logger.verbose(`Veo Model: ${model}`);
+    logger.verbose(`Prompt: ${modelInput}`);
+    logger.verbose(`Parameters: ${JSON.stringify(parameters)}`);
+    logger.verbose(`Response: ${this.parseResponse(responseData)}`);
+
+    prompt &&
+      prompt.debugInfo &&
+      (prompt.debugInfo += `\n${JSON.stringify(data)}`);
+  }
+}
+
+export default VeoVideoPlugin; 

package/helper-apps/cortex-file-handler/src/hashUtils.js

@@ -1,91 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { v4 as uuidv4 } from 'uuid';
-
-import {
-    getFileStoreMap,
-    removeFromFileStoreMap,
-    setFileStoreMap,
-} from './redis.js';
-
-/**
- * Retrieve a hash entry from Redis and ensure that the referenced files
- * still exist in at least one configured storage provider. If one copy is
- * missing it will try to restore it from the other provider (when possible).
- *
- * If the entry is completely invalid (no files found) it is removed from
- * the store and `null` is returned.
- *
- * The function also updates the timestamp of the entry so that active hashes
- * stay fresh in Redis.
- *
- * @param {object} context   – Azure Function context for logging
- * @param {string} hash      – The hash / key in the FileStoreMap
- * @param {StorageService} storageService – An initialised StorageService instance
- * @returns {object|null} The (possibly refreshed) entry or null when invalid
- */
-export async function getValidHashEntry(context, hash, storageService) {
-    if (!hash) return null;
-
-    let entry = await getFileStoreMap(hash);
-    if (!entry) return null;
-
-    try {
-        const primaryExists = entry?.url ? await storageService.fileExists(entry.url) : false;
-        const gcsExists = entry?.gcs ? await storageService.fileExists(entry.gcs) : false;
-
-        // If neither storage has the file, remove the entry and abort
-        if (!primaryExists && !gcsExists) {
-            await removeFromFileStoreMap(hash);
-            return null;
-        }
-
-        // Restore missing GCS copy when primary exists
-        if (primaryExists && !gcsExists) {
-            try {
-                entry = await storageService.ensureGCSUpload(context, entry);
-            } catch (err) {
-                context.log(`getValidHashEntry: failed to restore GCS copy – ${err}`);
-            }
-        }
-
-        // Restore missing primary copy when GCS exists and a primary provider is configured
-        if (!primaryExists && gcsExists && storageService.backupProvider?.isConfigured()) {
-            let tempDir;
-            let downloadedFile;
-            try {
-                tempDir = path.join(os.tmpdir(), `${uuidv4()}`);
-                fs.mkdirSync(tempDir);
-                downloadedFile = path.join(tempDir, path.basename(entry.gcs));
-
-                // Download from GCS, then upload to primary storage
-                await storageService.downloadFile(entry.gcs, downloadedFile);
-                const res = await storageService.uploadFile(context, downloadedFile, hash);
-                entry.url = res.url;
-            } catch (err) {
-                context.log(`getValidHashEntry: failed to restore primary copy – ${err}`);
-            } finally {
-                // Clean temp artefacts
-                try {
-                    if (downloadedFile && fs.existsSync(downloadedFile)) {
-                        fs.unlinkSync(downloadedFile);
-                    }
-                    if (tempDir && fs.existsSync(tempDir)) {
-                        fs.rmSync(tempDir, { recursive: true, force: true });
-                    }
-                } catch (_) {
-                    /* noop */
-                }
-            }
-        }
-
-        // Update timestamp so the entry stays fresh
-        await setFileStoreMap(hash, entry);
-        return entry;
-    } catch (err) {
-        context.log(`getValidHashEntry: error during validation – ${err}`);
-        await removeFromFileStoreMap(hash);
-        return null;
-    }
-}