@aj-archipelago/cortex 1.4.4 → 1.4.6

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

@@ -16,7 +16,16 @@ import {
   generateBlobName,
 } from "./utils/filenameUtils.js";
 import { publicFolder, port, ipAddress } from "./start.js";
-import { CONVERTED_EXTENSIONS, AZURITE_ACCOUNT_NAME } from "./constants.js";
+import { 
+  CONVERTED_EXTENSIONS, 
+  AZURITE_ACCOUNT_NAME,
+  parseContainerNames,
+  getCurrentContainerNames,
+  AZURE_STORAGE_CONTAINER_NAMES,
+  getDefaultContainerName,
+  GCS_BUCKETNAME,
+  isValidContainerName
+} from "./constants.js";
 import { FileConversionService } from "./services/FileConversionService.js";
 import { StorageFactory } from "./services/storage/StorageFactory.js";
 
@@ -70,28 +79,6 @@ if (!GCP_PROJECT_ID || !GCP_SERVICE_ACCOUNT) {
   }
 }
 
-// Parse comma-separated container names from environment variable
-const parseContainerNames = () => {
-  const containerStr = process.env.AZURE_STORAGE_CONTAINER_NAME || "whispertempfiles";
-  return containerStr.split(',').map(name => name.trim());
-};
-
-// Helper function to get current container names at runtime
-export const getCurrentContainerNames = () => {
-  return parseContainerNames();
-};
-
-export const AZURE_STORAGE_CONTAINER_NAMES = parseContainerNames();
-export const DEFAULT_AZURE_STORAGE_CONTAINER_NAME = AZURE_STORAGE_CONTAINER_NAMES[0];
-export const GCS_BUCKETNAME = process.env.GCS_BUCKETNAME || "cortextempfiles";
-
-// Validate if a container name is allowed
-export const isValidContainerName = (containerName) => {
-  // Read from environment at runtime to support dynamically changing env in tests
-  const currentContainerNames = getCurrentContainerNames();
-  return currentContainerNames.includes(containerName);
-};
-
 function isEncoded(str) {
   // Checks for any percent-encoded sequence
   return /%[0-9A-Fa-f]{2}/.test(str);
@@ -194,7 +181,7 @@ async function downloadFromGCS(gcsUrl, destinationPath) {
 
 export const getBlobClient = async (containerName = null) => {
   const connectionString = process.env.AZURE_STORAGE_CONNECTION_STRING;
-  const finalContainerName = containerName || DEFAULT_AZURE_STORAGE_CONTAINER_NAME;
+  const finalContainerName = containerName || getDefaultContainerName();
 
   // Validate container name is in whitelist
   if (!isValidContainerName(finalContainerName)) {
@@ -350,10 +337,12 @@ function uploadBlob(
             
             if (errorOccurred) return; // Check again after waiting
 
-            await processFile(fieldname, file, info);
+            // Capture containerName value to avoid closure issues
+            const capturedContainerName = containerName;
+            await processFile(fieldname, file, info, capturedContainerName);
           });
 
-          const processFile = async (fieldname, file, info) => {
+          const processFile = async (fieldname, file, info, capturedContainerName) => {
             if (errorOccurred) return;
 
             // Validate file
@@ -449,7 +438,7 @@ function uploadBlob(
                 context,
                 uploadName,
                 azureStream,
-                containerName,
+                capturedContainerName,
               ).catch(async (err) => {
                 cloudUploadError = err;
                 // Fallback: try from disk if available
@@ -459,7 +448,7 @@ function uploadBlob(
                     highWaterMark: 1024 * 1024,
                     autoClose: true,
                   });
-                  return saveToAzureStorage(context, uploadName, diskStream, containerName);
+                  return saveToAzureStorage(context, uploadName, diskStream, capturedContainerName);
                 }
                 throw err;
               });
@@ -511,6 +500,7 @@ function uploadBlob(
                 }, {}),
               };
               if (hash) result.hash = hash;
+              if (capturedContainerName) result.container = capturedContainerName;
 
               // If saving locally, wait for disk write to finish and then move to public folder
               if (saveToLocal) {
@@ -582,7 +572,7 @@ function uploadBlob(
                         conversion.convertedPath,
                         requestId,
                         null,
-                        containerName,
+                        capturedContainerName,
                       );
 
                     // Optionally save to GCS
@@ -827,6 +817,10 @@ async function uploadFile(
     if (hash) {
       result.hash = hash;
     }
+    
+    if (containerName) {
+      result.container = containerName;
+    }
 
     // Initialize conversion service
     const conversionService = new FileConversionService(context, !saveToLocal);
@@ -1156,4 +1150,10 @@ export {
   gcs,
   uploadChunkToGCS,
   downloadFromGCS,
+  // Re-export container constants for backward compatibility
+  getCurrentContainerNames,
+  AZURE_STORAGE_CONTAINER_NAMES,
+  getDefaultContainerName,
+  GCS_BUCKETNAME,
+  isValidContainerName,
 };

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

@@ -132,3 +132,33 @@ export const CONVERTED_EXTENSIONS = [
 
 // Azure Storage constants
 export const AZURITE_ACCOUNT_NAME = "devstoreaccount1";
+
+// Parse comma-separated container names from environment variable
+export const parseContainerNames = () => {
+  const containerStr = process.env.AZURE_STORAGE_CONTAINER_NAME || "whispertempfiles";
+  return containerStr.split(',').map(name => name.trim());
+};
+
+// Helper function to get current container names at runtime
+// Useful for runtime validation when env vars might change (e.g., in tests)
+export const getCurrentContainerNames = () => {
+  return parseContainerNames();
+};
+
+export const AZURE_STORAGE_CONTAINER_NAMES = parseContainerNames();
+
+// Helper function to get the default container name at runtime
+// This allows tests to change the environment variable and have the correct default
+export const getDefaultContainerName = () => {
+  return process.env.DEFAULT_AZURE_STORAGE_CONTAINER_NAME || getCurrentContainerNames()[0];
+};
+
+export const DEFAULT_AZURE_STORAGE_CONTAINER_NAME = process.env.DEFAULT_AZURE_STORAGE_CONTAINER_NAME || AZURE_STORAGE_CONTAINER_NAMES[0];
+export const GCS_BUCKETNAME = process.env.GCS_BUCKETNAME || "cortextempfiles";
+
+// Validate if a container name is allowed
+export const isValidContainerName = (containerName) => {
+  // Read from environment at runtime to support dynamically changing env in tests
+  const currentContainerNames = getCurrentContainerNames();
+  return currentContainerNames.includes(containerName);
+};

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

@@ -14,6 +14,7 @@ import {
   removeFromFileStoreMap,
   setFileStoreMap,
   cleanupRedisFileStoreMapAge,
+  getScopedHashKey,
 } from "./redis.js";
 import { FileConversionService } from "./services/FileConversionService.js";
 import { StorageService } from "./services/storage/StorageService.js";
@@ -141,7 +142,7 @@ async function CortexFileHandler(context, req) {
     // If only hash is provided, delete single file by hash
     if (deleteHash && !deleteRequestId) {
       try {
-        const deleted = await storageService.deleteFileByHash(deleteHash);
+        const deleted = await storageService.deleteFileByHash(deleteHash, container);
         context.res = {
           status: 200,
           body: { 
@@ -170,10 +171,11 @@ async function CortexFileHandler(context, req) {
 
     // First, get the hash from the map if it exists
     if (deleteHash) {
-      const hashResult = await getFileStoreMap(deleteHash);
+      const scopedHash = getScopedHashKey(deleteHash, container);
+      const hashResult = await getFileStoreMap(scopedHash);
       if (hashResult) {
-        context.log(`Found hash in map for deletion: ${deleteHash}`);
-        await removeFromFileStoreMap(deleteHash);
+        context.log(`Found hash in map for deletion: ${deleteHash} (scoped key: ${scopedHash})`);
+        await removeFromFileStoreMap(scopedHash);
       }
     }
 
@@ -201,7 +203,8 @@ async function CortexFileHandler(context, req) {
       }
 
       // Check if file already exists (using hash or URL as the key)
-      const cacheKey = hash || remoteUrl;
+      // If hash is provided, scope it by container; otherwise use URL as-is
+      const cacheKey = hash ? getScopedHashKey(hash, container) : remoteUrl;
       const exists = await getFileStoreMap(cacheKey);
       if (exists) {
         context.res = {
@@ -255,9 +258,10 @@ async function CortexFileHandler(context, req) {
 
   if (hash && clearHash) {
     try {
-      const hashValue = await getFileStoreMap(hash);
+      const scopedHash = getScopedHashKey(hash, container);
+      const hashValue = await getFileStoreMap(scopedHash);
       if (hashValue) {
-        await removeFromFileStoreMap(hash);
+        await removeFromFileStoreMap(scopedHash);
         context.res = {
           status: 200,
           body: `Hash ${hash} removed`,
@@ -279,10 +283,11 @@ async function CortexFileHandler(context, req) {
   }
 
   if (hash && checkHash) {
-    let hashResult = await getFileStoreMap(hash, true); // Skip lazy cleanup to handle it ourselves
+    const scopedHash = getScopedHashKey(hash, container);
+    let hashResult = await getFileStoreMap(scopedHash, true); // Skip lazy cleanup to handle it ourselves
 
     if (hashResult) {
-      context.log(`File exists in map: ${hash}`);
+      context.log(`File exists in map: ${hash} (scoped key: ${scopedHash})`);
 
       // Log the URL retrieved from Redis before checking existence
       context.log(`Checking existence of URL from Redis: ${hashResult?.url}`);
@@ -301,7 +306,7 @@ async function CortexFileHandler(context, req) {
           context.log(
             `File not found in any storage. Removing from map: ${hash}`,
           );
-          await removeFromFileStoreMap(hash);
+          await removeFromFileStoreMap(scopedHash);
           context.res = {
             status: 404,
             body: `Hash ${hash} not found in storage`,
@@ -320,7 +325,7 @@ async function CortexFileHandler(context, req) {
           } catch (error) {
             context.log(`Error restoring to GCS: ${error}`);
             // If restoration fails, remove the hash from the map
-            await removeFromFileStoreMap(hash);
+            await removeFromFileStoreMap(scopedHash);
             context.res = {
               status: 404,
               body: `Hash ${hash} not found`,
@@ -378,7 +383,7 @@ async function CortexFileHandler(context, req) {
           } catch (error) {
             console.error("Error restoring from GCS:", error);
             // If restoration fails, remove the hash from the map
-            await removeFromFileStoreMap(hash);
+            await removeFromFileStoreMap(scopedHash);
             context.res = {
               status: 404,
               body: `Hash ${hash} not found`,
@@ -396,7 +401,7 @@ async function CortexFileHandler(context, req) {
           : false;
         if (!finalPrimaryCheck && !finalGCSCheck) {
           context.log(`Failed to restore file. Removing from map: ${hash}`);
-          await removeFromFileStoreMap(hash);
+          await removeFromFileStoreMap(scopedHash);
           context.res = {
             status: 404,
             body: `Hash ${hash} not found`,
@@ -498,7 +503,7 @@ async function CortexFileHandler(context, req) {
         }
 
         //update redis timestamp with current time
-        await setFileStoreMap(hash, hashResult);
+        await setFileStoreMap(scopedHash, hashResult);
 
         context.res = {
           status: 200,
@@ -508,7 +513,7 @@ async function CortexFileHandler(context, req) {
       } catch (error) {
         context.log(`Error checking file existence: ${error}`);
         // If there's an error checking file existence, remove the hash from the map
-        await removeFromFileStoreMap(hash);
+        await removeFromFileStoreMap(scopedHash);
         context.res = {
           status: 404,
           body: `Hash ${hash} not found`,
@@ -532,7 +537,8 @@ async function CortexFileHandler(context, req) {
     // Use uploadBlob to handle multipart/form-data
     const result = await uploadBlob(context, req, saveToLocal, null, hash, container);
     if (result?.hash && context?.res?.body) {
-      await setFileStoreMap(result.hash, context.res.body);
+      const scopedHash = getScopedHashKey(result.hash, result.container || container);
+      await setFileStoreMap(scopedHash, context.res.body);
     }
     return;
   }

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

@@ -1,7 +1,28 @@
 import redis from "ioredis";
+import { getDefaultContainerName } from "./constants.js";
 
 const connectionString = process.env["REDIS_CONNECTION_STRING"];
 
+/**
+ * Generate a scoped hash key for Redis storage
+ * Always includes the container name in the format hash:container
+ * @param {string} hash - The file hash
+ * @param {string} containerName - The container name (optional, defaults to default container)
+ * @returns {string} The scoped hash key
+ */
+export const getScopedHashKey = (hash, containerName = null) => {
+  if (!hash) return hash;
+  
+  // Get the default container name at runtime to support dynamic env changes in tests
+  const defaultContainerName = getDefaultContainerName();
+  
+  // Use default container if not provided
+  const container = containerName || defaultContainerName;
+  
+  // Always scope by container
+  return `${hash}:${container}`;
+};
+
 // Create a mock client for test environment when Redis is not configured
 const createMockClient = () => {
   const store = new Map();
@@ -123,7 +144,28 @@ const setFileStoreMap = async (key, value) => {
 
 const getFileStoreMap = async (key, skipLazyCleanup = false) => {
   try {
-    const value = await client.hget("FileStoreMap", key);
+    let value = await client.hget("FileStoreMap", key);
+    
+    // Backwards compatibility: if not found and key is for default container, try legacy key
+    if (!value && key && key.includes(':')) {
+      const [hash, containerName] = key.split(':', 2);
+      const defaultContainerName = getDefaultContainerName();
+      
+      // If this is the default container, try the legacy key (hash without container)
+      if (containerName === defaultContainerName) {
+        console.log(`Key ${key} not found, trying legacy key ${hash} for backwards compatibility`);
+        value = await client.hget("FileStoreMap", hash);
+        
+        // If found with legacy key, migrate it to the new scoped key
+        if (value) {
+          console.log(`Found value with legacy key ${hash}, migrating to new key ${key}`);
+          await client.hset("FileStoreMap", key, value);
+          // Optionally remove the old key after migration
+          // await client.hdel("FileStoreMap", hash);
+        }
+      }
+    }
+    
     if (value) {
       try {
         // parse the value back to an object before returning

package/helper-apps/cortex-file-handler/src/services/storage/StorageFactory.js

@@ -1,18 +1,10 @@
 import { AzureStorageProvider } from "./AzureStorageProvider.js";
 import { GCSStorageProvider } from "./GCSStorageProvider.js";
 import { LocalStorageProvider } from "./LocalStorageProvider.js";
+import { getCurrentContainerNames, GCS_BUCKETNAME } from "../../constants.js";
 import path from "path";
 import { fileURLToPath } from "url";
 
-// Lazy-load blob handler constants to avoid blocking module import
-let blobHandlerConstants = null;
-async function getBlobHandlerConstants() {
-  if (!blobHandlerConstants) {
-    blobHandlerConstants = await import("../../blobHandler.js");
-  }
-  return blobHandlerConstants;
-}
-
 // Singleton instance for provider caching across the application
 let storageFactoryInstance = null;
 
@@ -49,7 +41,6 @@ export class StorageFactory {
 
   async getAzureProvider(containerName = null) {
     // Read container names from environment directly to get current values
-    const { getCurrentContainerNames } = await getBlobHandlerConstants();
     const azureStorageContainerNames = getCurrentContainerNames();
     const defaultAzureStorageContainerName = azureStorageContainerNames[0];
     
@@ -82,7 +73,7 @@ export class StorageFactory {
       }
       const provider = new GCSStorageProvider(
         credentials,
-        process.env.GCS_BUCKETNAME || "cortextempfiles",
+        GCS_BUCKETNAME,
       );
       this.providers.set(key, provider);
     }

package/helper-apps/cortex-file-handler/src/services/storage/StorageService.js

@@ -163,9 +163,10 @@ export class StorageService {
   /**
    * Delete a single file by its hash from both primary and backup storage
    * @param {string} hash - The hash of the file to delete
+   * @param {string} containerName - Optional container name for scoping the hash
    * @returns {Promise<Object>} Object containing deletion results and file info
    */
-  async deleteFileByHash(hash) {
+  async deleteFileByHash(hash, containerName = null) {
     await this._initialize();
     
     if (!hash) {
@@ -175,11 +176,24 @@ export class StorageService {
     const results = [];
 
     // Get and remove file information from Redis map (non-atomic operations)
-    const { getFileStoreMap, removeFromFileStoreMap } = await import("../../redis.js");
-    const hashResult = await getFileStoreMap(hash);
+    const { getFileStoreMap, removeFromFileStoreMap, getScopedHashKey, getDefaultContainerName } = await import("../../redis.js");
+    const { getDefaultContainerName: getDefaultContainerNameFromConstants } = await import("../../constants.js");
+    const scopedHash = getScopedHashKey(hash, containerName);
+    const hashResult = await getFileStoreMap(scopedHash);
     
     if (hashResult) {
-      await removeFromFileStoreMap(hash);
+      // Remove from scoped key
+      await removeFromFileStoreMap(scopedHash);
+      
+      // Also check and remove legacy key (unscoped) if this is the default container
+      // This handles backwards compatibility with old entries stored without container scoping
+      const defaultContainerName = getDefaultContainerNameFromConstants();
+      const effectiveContainer = containerName || defaultContainerName;
+      if (effectiveContainer === defaultContainerName && scopedHash.includes(':')) {
+        const [legacyHash] = scopedHash.split(':', 2);
+        // Try to remove legacy key - it's okay if it doesn't exist
+        await removeFromFileStoreMap(legacyHash);
+      }
     }
     
     if (!hashResult) {

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

@@ -6,6 +6,7 @@ import cors from "cors";
 import { readFileSync } from "fs";
 
 import { publicIpv4 } from "public-ip";
+import { AZURE_STORAGE_CONTAINER_NAMES, getDefaultContainerName } from "./blobHandler.js";
 
 // When running under tests we want all generated URLs to resolve to the
 // locally-running server, otherwise checks like HEAD requests inside the
@@ -93,6 +94,10 @@ if (import.meta.url === `file://${process.argv[1]}`) {
       console.log(
         `Cortex File Handler v${version} running on port ${port} (includes legacy MediaFileChunker endpoint)`,
       );
+      
+      // Debug: Show configured container names
+      console.log(`Configured container names: ${AZURE_STORAGE_CONTAINER_NAMES.join(', ')}`);
+      console.log(`Default container name: ${getDefaultContainerName()}`);
     });
   });
 }

package/helper-apps/cortex-file-handler/tests/blobHandler.test.js

@@ -12,7 +12,7 @@ import {
   deleteGCS,
   getBlobClient,
   AZURE_STORAGE_CONTAINER_NAMES,
-  DEFAULT_AZURE_STORAGE_CONTAINER_NAME,
+  getDefaultContainerName,
   isValidContainerName,
 } from "../src/blobHandler.js";
 import { urlExists } from "../src/helper.js";
@@ -330,10 +330,11 @@ test("AZURE_STORAGE_CONTAINER_NAMES should be an array with at least one contain
   });
 });
 
-test("DEFAULT_AZURE_STORAGE_CONTAINER_NAME should be the first container", (t) => {
-  t.is(DEFAULT_AZURE_STORAGE_CONTAINER_NAME, AZURE_STORAGE_CONTAINER_NAMES[0]);
-  t.truthy(DEFAULT_AZURE_STORAGE_CONTAINER_NAME);
-  t.is(typeof DEFAULT_AZURE_STORAGE_CONTAINER_NAME, 'string');
+test("getDefaultContainerName should return the first container", (t) => {
+  const defaultContainer = getDefaultContainerName();
+  t.is(defaultContainer, AZURE_STORAGE_CONTAINER_NAMES[0]);
+  t.truthy(defaultContainer);
+  t.is(typeof defaultContainer, 'string');
 });
 
 test("isValidContainerName should validate container names correctly", (t) => {

package/helper-apps/cortex-file-handler/tests/containerNameParsing.test.js

@@ -1,7 +1,7 @@
 import test from "ava";
 import { 
   AZURE_STORAGE_CONTAINER_NAMES, 
-  DEFAULT_AZURE_STORAGE_CONTAINER_NAME,
+  getDefaultContainerName,
   isValidContainerName,
   getCurrentContainerNames
 } from "../src/blobHandler.js";
@@ -119,15 +119,16 @@ test("parseContainerNames should handle only commas", (t) => {
   t.is(result[3], "");
 });
 
-test("DEFAULT_AZURE_STORAGE_CONTAINER_NAME should be the first container in the list", (t) => {
+test("getDefaultContainerName should return the first container in the list", (t) => {
   // Test with current module exports (these are loaded at import time)
   // The default should be the first item in the array
-  t.is(DEFAULT_AZURE_STORAGE_CONTAINER_NAME, AZURE_STORAGE_CONTAINER_NAMES[0]);
+  const defaultContainer = getDefaultContainerName();
+  t.is(defaultContainer, getCurrentContainerNames()[0]);
   
   // Additional validation that it's a non-empty string
-  t.truthy(DEFAULT_AZURE_STORAGE_CONTAINER_NAME);
-  t.is(typeof DEFAULT_AZURE_STORAGE_CONTAINER_NAME, 'string');
-  t.true(DEFAULT_AZURE_STORAGE_CONTAINER_NAME.length > 0);
+  t.truthy(defaultContainer);
+  t.is(typeof defaultContainer, 'string');
+  t.true(defaultContainer.length > 0);
 });
 
 test("isValidContainerName should return true for valid container names", (t) => {

package/helper-apps/cortex-file-handler/tests/containerParameterFlow.test.js

@@ -11,7 +11,7 @@ import {
   uploadBlob,
   isValidContainerName,
   AZURE_STORAGE_CONTAINER_NAMES,
-  DEFAULT_AZURE_STORAGE_CONTAINER_NAME,
+  getDefaultContainerName,
 } from "../src/blobHandler.js";
 import CortexFileHandler from "../src/index.js";
 import {
@@ -315,8 +315,9 @@ test("should use default container when no container specified", async (t) => {
   }
 
   // Test that default container is first in the list
-  t.is(DEFAULT_AZURE_STORAGE_CONTAINER_NAME, AZURE_STORAGE_CONTAINER_NAMES[0]);
-  t.true(isValidContainerName(DEFAULT_AZURE_STORAGE_CONTAINER_NAME));
+  const defaultContainer = getDefaultContainerName();
+  t.is(defaultContainer, AZURE_STORAGE_CONTAINER_NAMES[0]);
+  t.true(isValidContainerName(defaultContainer));
 
   // Create a test file
   const testContent = "test content for default container";

package/helper-apps/cortex-file-handler/tests/hashContainerScoping.test.js

@@ -0,0 +1,415 @@
+import test from "ava";
+import axios from "axios";
+import FormData from "form-data";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { v4 as uuidv4 } from "uuid";
+import { port } from "../src/start.js";
+import { startTestServer } from "./testUtils.helper.js";
+
+// Test server setup
+let baseUrl;
+let server;
+
+// Start test server before running tests
+test.before(async (t) => {
+  baseUrl = `http://localhost:${port}/api/CortexFileHandler`;
+
+  // Start the test server
+  server = await startTestServer();
+});
+
+// Clean up server after tests
+test.after.always(async (t) => {
+  if (server) {
+    await new Promise((resolve, reject) => {
+      server.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+});
+
+// Helper to create a test file
+async function createTestFile(content, extension = "txt", filename = null) {
+  const tempDir = os.tmpdir();
+  const actualFilename = filename || `test-${uuidv4()}.${extension}`;
+  const filePath = path.join(tempDir, actualFilename);
+  
+  if (extension === "txt") {
+    fs.writeFileSync(filePath, content);
+  } else {
+    throw new Error(`Unsupported file extension: ${extension}`);
+  }
+  
+  return filePath;
+}
+
+// Helper to upload a file with hash and container
+async function uploadFileWithHashAndContainer(filePath, hash, containerName) {
+  const form = new FormData();
+  // Append hash and container BEFORE file so they're processed first
+  form.append("hash", hash);
+  if (containerName) {
+    form.append("container", containerName);
+  }
+  form.append("file", fs.createReadStream(filePath));
+
+  const response = await axios.post(baseUrl, form, {
+    headers: {
+      ...form.getHeaders(),
+      "Content-Type": "multipart/form-data",
+    },
+    validateStatus: (status) => true,
+    timeout: 10000,
+  });
+
+  return response;
+}
+
+// Helper to check if hash exists with optional container
+async function checkHashExists(hash, containerName = null) {
+  const params = {
+    hash,
+    checkHash: true,
+  };
+  
+  if (containerName) {
+    params.container = containerName;
+  }
+
+  const response = await axios.get(baseUrl, {
+    params,
+    validateStatus: (status) => true,
+    timeout: 10000,
+  });
+
+  return response;
+}
+
+// Helper to cleanup hash
+async function cleanupHash(hash, containerName = null) {
+  const params = {
+    hash,
+    clearHash: true,
+  };
+  
+  if (containerName) {
+    params.container = containerName;
+  }
+
+  try {
+    await axios.get(baseUrl, {
+      params,
+      validateStatus: (status) => true,
+      timeout: 5000,
+    });
+  } catch (error) {
+    // Ignore cleanup errors
+  }
+}
+
+// Main test: Hash scoping across containers
+test.serial("should scope hash by container - same hash different containers should be independent", async (t) => {
+  if (!process.env.AZURE_STORAGE_CONNECTION_STRING) {
+    t.pass("Skipping test - Azure not configured");
+    return;
+  }
+
+  const originalEnv = process.env.AZURE_STORAGE_CONTAINER_NAME;
+  process.env.AZURE_STORAGE_CONTAINER_NAME = "test1,test2,test3";
+
+  try {
+    const testHash = `hash-scope-test-${uuidv4()}`;
+    const contentA = "Content for container A";
+    const contentB = "Content for container B";
+    const fileA = await createTestFile(contentA, "txt", "fileA.txt");
+    const fileB = await createTestFile(contentB, "txt", "fileB.txt");
+
+    // Upload file to container test1 with hash
+    const uploadA = await uploadFileWithHashAndContainer(fileA, testHash, "test1");
+    t.is(uploadA.status, 200, "Upload to test1 should succeed");
+    t.truthy(uploadA.data.url, "Upload A should have URL");
+
+    // Wait for Redis to update
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    // Upload file to container test2 with SAME hash
+    const uploadB = await uploadFileWithHashAndContainer(fileB, testHash, "test2");
+    t.is(uploadB.status, 200, "Upload to test2 should succeed");
+    t.truthy(uploadB.data.url, "Upload B should have URL");
+
+    // Wait for Redis to update
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    // Check hash in container test1 - should return file A
+    const checkA = await checkHashExists(testHash, "test1");
+    t.is(checkA.status, 200, "Hash should exist in test1");
+    t.is(checkA.data.url, uploadA.data.url, "Should return URL from container test1");
+
+    // Check hash in container test2 - should return file B
+    const checkB = await checkHashExists(testHash, "test2");
+    t.is(checkB.status, 200, "Hash should exist in test2");
+    t.is(checkB.data.url, uploadB.data.url, "Should return URL from container test2");
+
+    // Verify the URLs are different
+    t.not(checkA.data.url, checkB.data.url, "URLs should be different for same hash in different containers");
+
+    // Verify the file contents are different
+    const fileResponseA = await axios.get(uploadA.data.url, {
+      validateStatus: (status) => true,
+      timeout: 5000,
+    });
+    const fileResponseB = await axios.get(uploadB.data.url, {
+      validateStatus: (status) => true,
+      timeout: 5000,
+    });
+    
+    t.is(fileResponseA.data, contentA, "File A should have correct content");
+    t.is(fileResponseB.data, contentB, "File B should have correct content");
+
+    // Cleanup
+    fs.unlinkSync(fileA);
+    fs.unlinkSync(fileB);
+    await cleanupHash(testHash, "test1");
+    await cleanupHash(testHash, "test2");
+
+    // Delete the actual files
+    await axios.delete(baseUrl, {
+      params: {
+        hash: testHash,
+        container: "test1",
+      },
+      validateStatus: (status) => true,
+    });
+    await axios.delete(baseUrl, {
+      params: {
+        hash: testHash,
+        container: "test2",
+      },
+      validateStatus: (status) => true,
+    });
+  } finally {
+    // Restore environment
+    if (originalEnv) {
+      process.env.AZURE_STORAGE_CONTAINER_NAME = originalEnv;
+    } else {
+      delete process.env.AZURE_STORAGE_CONTAINER_NAME;
+    }
+  }
+});
+
+// Test: Hash in default container should be scoped with container name
+test.serial("should scope hash for default container with container name", async (t) => {
+  if (!process.env.AZURE_STORAGE_CONNECTION_STRING) {
+    t.pass("Skipping test - Azure not configured");
+    return;
+  }
+
+  const originalEnv = process.env.AZURE_STORAGE_CONTAINER_NAME;
+  const originalDefaultEnv = process.env.DEFAULT_AZURE_STORAGE_CONTAINER_NAME;
+  process.env.AZURE_STORAGE_CONTAINER_NAME = "test1,test2,test3";
+  // Ensure test1 is the default container
+  delete process.env.DEFAULT_AZURE_STORAGE_CONTAINER_NAME;
+
+  try {
+    const testHash = `hash-default-test-${uuidv4()}`;
+    const content = "Content for default container";
+    const file = await createTestFile(content, "txt", "fileDefault.txt");
+
+    // Upload file to default container (test1) with hash
+    // We upload WITHOUT specifying container, so it should use default
+    // Now it will be stored as hash:test1 (always scoped)
+    const uploadDefault = await uploadFileWithHashAndContainer(file, testHash, null);
+    t.is(uploadDefault.status, 200, "Upload to default should succeed");
+    t.truthy(uploadDefault.data.url, "Upload should have URL");
+
+    // Wait for Redis to update
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    // Check hash without container parameter - should work for default container
+    const checkWithoutContainer = await checkHashExists(testHash, null);
+    t.is(checkWithoutContainer.status, 200, "Hash should exist without container param");
+    t.is(checkWithoutContainer.data.url, uploadDefault.data.url, "Should return URL from default container");
+
+    // Check hash with explicit default container parameter - should also work
+    const checkWithDefaultContainer = await checkHashExists(testHash, "test1");
+    t.is(checkWithDefaultContainer.status, 200, "Hash should exist with default container param");
+    t.is(checkWithDefaultContainer.data.url, uploadDefault.data.url, "Should return same URL with default container param");
+
+    // Cleanup
+    fs.unlinkSync(file);
+    await cleanupHash(testHash, null);
+
+    // Delete the actual file
+    await axios.delete(baseUrl, {
+      params: {
+        hash: testHash,
+      },
+      validateStatus: (status) => true,
+    });
+  } finally {
+    // Restore environment
+    if (originalEnv) {
+      process.env.AZURE_STORAGE_CONTAINER_NAME = originalEnv;
+    } else {
+      delete process.env.AZURE_STORAGE_CONTAINER_NAME;
+    }
+    if (originalDefaultEnv) {
+      process.env.DEFAULT_AZURE_STORAGE_CONTAINER_NAME = originalDefaultEnv;
+    } else {
+      delete process.env.DEFAULT_AZURE_STORAGE_CONTAINER_NAME;
+    }
+  }
+});
+
+// Test: Backwards compatibility - legacy hash without container should be found for default container
+test.serial("should support backwards compatibility for legacy hashes in default container", async (t) => {
+  if (!process.env.AZURE_STORAGE_CONNECTION_STRING) {
+    t.pass("Skipping test - Azure not configured");
+    return;
+  }
+
+  const originalEnv = process.env.AZURE_STORAGE_CONTAINER_NAME;
+  const originalDefaultEnv = process.env.DEFAULT_AZURE_STORAGE_CONTAINER_NAME;
+  process.env.AZURE_STORAGE_CONTAINER_NAME = "test1,test2,test3";
+  // Ensure test1 is the default container for backwards compatibility logic
+  delete process.env.DEFAULT_AZURE_STORAGE_CONTAINER_NAME;
+
+  try {
+    const testHash = `hash-legacy-test-${uuidv4()}`;
+    const content = "Content for legacy test";
+    const file = await createTestFile(content, "txt", "fileLegacy.txt");
+
+    // Upload file to default container (test1) with hash - this creates the scoped entry
+    const upload = await uploadFileWithHashAndContainer(file, testHash, "test1");
+    t.is(upload.status, 200, "Upload to test1 should succeed");
+    t.truthy(upload.data.url, "Upload should have URL");
+
+    // Wait for Redis to update
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    // Now simulate a legacy entry by also storing the hash WITHOUT container scope
+    // This mimics the old behavior before container scoping was added
+    const { client } = await import("../src/redis.js");
+    const legacyData = {
+      url: upload.data.url, // Use the real uploaded URL
+      blobName: upload.data.blobName || upload.data.filename, // Include blobName for proper restoration
+      filename: upload.data.filename,
+      timestamp: new Date().toISOString(),
+    };
+    await client.hset("FileStoreMap", testHash, JSON.stringify(legacyData));
+
+    // Wait for Redis to update
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // Delete the scoped key to simulate only having the legacy entry
+    const { getScopedHashKey } = await import("../src/redis.js");
+    const scopedKey = getScopedHashKey(testHash, "test1");
+    await client.hdel("FileStoreMap", scopedKey);
+
+    // Wait a bit for Redis
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // Check hash with default container parameter - should find the legacy entry
+    const checkWithDefaultContainer = await checkHashExists(testHash, "test1");
+    t.is(checkWithDefaultContainer.status, 200, "Legacy hash should be found with default container param");
+    t.is(checkWithDefaultContainer.data.url, legacyData.url, "Should return URL from legacy entry");
+
+    // Check hash without container parameter - should also find the legacy entry
+    const checkWithoutContainer = await checkHashExists(testHash, null);
+    t.is(checkWithoutContainer.status, 200, "Legacy hash should be found without container param");
+    t.is(checkWithoutContainer.data.url, legacyData.url, "Should return URL from legacy entry");
+
+    // After migration, the new scoped key should exist
+    const { getFileStoreMap } = await import("../src/redis.js");
+    const migratedValue = await getFileStoreMap(scopedKey, true); // Skip lazy cleanup
+    t.truthy(migratedValue, "Migrated value should exist with new scoped key");
+    t.is(migratedValue.url, legacyData.url, "Migrated value should have same URL");
+
+    // Cleanup
+    fs.unlinkSync(file);
+    await cleanupHash(testHash, "test1");
+    await cleanupHash(testHash, null);
+
+    // Delete the actual file
+    await axios.delete(baseUrl, {
+      params: {
+        hash: testHash,
+        container: "test1",
+      },
+      validateStatus: (status) => true,
+    });
+  } finally {
+    // Restore environment
+    if (originalEnv) {
+      process.env.AZURE_STORAGE_CONTAINER_NAME = originalEnv;
+    } else {
+      delete process.env.AZURE_STORAGE_CONTAINER_NAME;
+    }
+    if (originalDefaultEnv) {
+      process.env.DEFAULT_AZURE_STORAGE_CONTAINER_NAME = originalDefaultEnv;
+    } else {
+      delete process.env.DEFAULT_AZURE_STORAGE_CONTAINER_NAME;
+    }
+  }
+});
+
+// Test: Hash check with wrong container should return 404
+test.serial("should return 404 when checking hash with wrong container", async (t) => {
+  if (!process.env.AZURE_STORAGE_CONNECTION_STRING) {
+    t.pass("Skipping test - Azure not configured");
+    return;
+  }
+
+  const originalEnv = process.env.AZURE_STORAGE_CONTAINER_NAME;
+  process.env.AZURE_STORAGE_CONTAINER_NAME = "test1,test2,test3";
+
+  try {
+    const testHash = `hash-wrong-container-test-${uuidv4()}`;
+    const content = "Content for specific container";
+    const file = await createTestFile(content, "txt", "fileWrong.txt");
+
+    // Upload file to container test1 with hash
+    const upload = await uploadFileWithHashAndContainer(file, testHash, "test1");
+    t.is(upload.status, 200, "Upload to test1 should succeed");
+
+    // Wait for Redis to update
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    // Check hash in container test2 (wrong container) - should return 404
+    const checkWrong = await checkHashExists(testHash, "test2");
+    t.is(checkWrong.status, 404, "Hash should not exist in test2");
+
+    // Check hash in container test3 (also wrong) - should return 404
+    const checkWrong2 = await checkHashExists(testHash, "test3");
+    t.is(checkWrong2.status, 404, "Hash should not exist in test3");
+
+    // Check hash in container test1 (correct container) - should return 200
+    const checkCorrect = await checkHashExists(testHash, "test1");
+    t.is(checkCorrect.status, 200, "Hash should exist in test1");
+
+    // Cleanup
+    fs.unlinkSync(file);
+    await cleanupHash(testHash, "test1");
+
+    // Delete the actual file
+    await axios.delete(baseUrl, {
+      params: {
+        hash: testHash,
+        container: "test1",
+      },
+      validateStatus: (status) => true,
+    });
+  } finally {
+    // Restore environment
+    if (originalEnv) {
+      process.env.AZURE_STORAGE_CONTAINER_NAME = originalEnv;
+    } else {
+      delete process.env.AZURE_STORAGE_CONTAINER_NAME;
+    }
+  }
+});
+

package/lib/crypto.js

@@ -2,6 +2,18 @@
 import logger from './logger.js';
 import crypto from 'crypto';
 
+// Helper function to generate a preview of a message for logging
+function getMessagePreview(message, maxLength = 50) {
+    if (typeof message === 'string') {
+        return message.substring(0, maxLength);
+    }
+    try {
+        return JSON.stringify(message).substring(0, maxLength);
+    } catch (e) {
+        return String(message).substring(0, maxLength);
+    }
+}
+
 // Encryption function
 function encrypt(text, key) {
     if (!key) { return text; }
@@ -22,6 +34,20 @@ function encrypt(text, key) {
 function decrypt(message, key) {
     if (!key) { return message; }
     try {
+        // Quick type check - if not string, convert or skip
+        if (typeof message !== 'string') {
+            if (Buffer.isBuffer(message)) {
+                message = message.toString('utf8');
+            } else if (message === null || message === undefined) {
+                logger.warn(`Decryption skipped: message is ${message === null ? 'null' : 'undefined'}`);
+                return null;
+            } else {
+                const preview = getMessagePreview(message);
+                logger.warn(`Decryption skipped: message is not a string (type: ${typeof message}, preview: ${preview})`);
+                return null;
+            }
+        }
+        
         key = tryBufferKey(key);
         let parts = message.split(':');
         let iv = Buffer.from(parts.shift(), 'hex');
@@ -31,7 +57,8 @@ function decrypt(message, key) {
         decrypted += decipher.final('utf8');
         return decrypted;
     } catch (error) {
-        logger.error(`Decryption failed: ${error.message}`);
+        const preview = getMessagePreview(message);
+        logger.error(`Decryption failed: ${error.message} (preview: ${preview})`);
         return null;
     }
 }

package/lib/util.js

@@ -475,8 +475,12 @@ const uploadImageToCloud = async (base64Data, mimeType, pathwayResolver = null)
             contentType: mimeType
         });
         
+        // Append requestId parameter (preserving existing query parameters like subscription-key)
+        const separator = fileHandlerUrl.includes('?') ? '&' : '?';
+        const uploadUrl = `${fileHandlerUrl}${separator}requestId=${requestId}`;
+        
         // Upload file
-        const uploadResponse = await axios.post(`${fileHandlerUrl}?requestId=${requestId}`, formData, {
+        const uploadResponse = await axios.post(uploadUrl, formData, {
             headers: {
                 ...formData.getHeaders()
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "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/system/entity/sys_entity_agent.js

@@ -10,6 +10,30 @@ import { Prompt } from '../../../server/prompt.js';
 import { getToolsForEntity, loadEntityConfig } from './tools/shared/sys_entity_tools.js';
 import CortexResponse from '../../../lib/cortexResponse.js';
 
+// Helper function to generate a smart error response using the agent
+async function generateErrorResponse(error, args, pathwayResolver) {
+    const errorMessage = error?.message || error?.toString() || String(error);
+    
+    // Clear any accumulated errors since we're handling them intelligently
+    pathwayResolver.errors = [];
+    
+    // Use sys_generator_error to create a smart response
+    try {
+        const errorResponse = await callPathway('sys_generator_error', {
+            ...args,
+            text: errorMessage,
+            chatHistory: args.chatHistory || [],
+            stream: false
+        }, pathwayResolver);
+        
+        return errorResponse;
+    } catch (errorResponseError) {
+        // Fallback if sys_generator_error itself fails
+        logger.error(`Error generating error response: ${errorResponseError.message}`);
+        return `I apologize, but I encountered an error while processing your request: ${errorMessage}. Please try again or contact support if the issue persists.`;
+    }
+}
+
 export default {
     emulateOpenAIChatModel: 'cortex-agent',
     useInputChunking: false,
@@ -234,11 +258,20 @@ export default {
             // Add a line break to avoid running output together
             await say(pathwayResolver.rootRequestId || pathwayResolver.requestId, `\n`, 1000, false, false);
 
-            return await pathwayResolver.promptAndParse({
-                ...args,
-                tools: entityToolsOpenAiFormat,
-                tool_choice: "auto",
-            });
+            try {
+                return await pathwayResolver.promptAndParse({
+                    ...args,
+                    tools: entityToolsOpenAiFormat,
+                    tool_choice: "auto",
+                });
+            } catch (parseError) {
+                // If promptAndParse fails, generate error response instead of re-throwing
+                logger.error(`Error in promptAndParse during tool callback: ${parseError.message}`);
+                const errorResponse = await generateErrorResponse(parseError, args, pathwayResolver);
+                // Ensure errors are cleared before returning
+                pathwayResolver.errors = [];
+                return errorResponse;
+            }
         }
     },
   
@@ -396,6 +429,11 @@ export default {
                 tool_choice: memoryLookupRequired ? "required" : "auto"
             });
 
+            // Handle null response (can happen when ModelExecutor catches an error)
+            if (!response) {
+                throw new Error('Model execution returned null - the model request likely failed');
+            }
+
             let toolCallback = pathwayResolver.pathway.toolCallback;
 
             // Handle both CortexResponse objects and plain responses
@@ -403,15 +441,38 @@ export default {
                 (response instanceof CortexResponse && response.hasToolCalls()) ||
                 (typeof response === 'object' && response.tool_calls)
             )) {
-                response = await toolCallback(args, response, pathwayResolver);
+                try {
+                    response = await toolCallback(args, response, pathwayResolver);
+                    
+                    // Handle null response from tool callback
+                    if (!response) {
+                        throw new Error('Tool callback returned null - a model request likely failed');
+                    }
+                } catch (toolError) {
+                    // Handle errors in tool callback
+                    logger.error(`Error in tool callback: ${toolError.message}`);
+                    // Generate error response for tool callback errors
+                    const errorResponse = await generateErrorResponse(toolError, args, pathwayResolver);
+                    // Ensure errors are cleared before returning
+                    pathwayResolver.errors = [];
+                    return errorResponse;
+                }
             }
 
             return response;
 
         } catch (e) {
-            pathwayResolver.logError(e);
-            const chatResponse = await callPathway('sys_generator_quick', {...args, model: styleModel, stream: false}, pathwayResolver);
-            return chatResponse;
+            logger.error(`Error in sys_entity_agent: ${e.message}`);
+            
+            // Generate a smart error response instead of throwing
+            // Note: We don't call logError here because generateErrorResponse will clear errors
+            // and we want to handle the error gracefully rather than tracking it
+            const errorResponse = await generateErrorResponse(e, args, pathwayResolver);
+            
+            // Ensure errors are cleared before returning (in case any were added during error response generation)
+            pathwayResolver.errors = [];
+            
+            return errorResponse;
         }
     }
 }; 

package/pathways/system/entity/sys_generator_error.js

@@ -7,7 +7,7 @@ export default {
                 {"role": "system", "content": `{{renderTemplate AI_MEMORY}}\n\n{{renderTemplate AI_DIRECTIVES}}\n\n{{renderTemplate AI_COMMON_INSTRUCTIONS}}\n\n{{renderTemplate AI_EXPERTISE}}\n\n{{renderTemplate AI_CONVERSATION_HISTORY}}\n\nYou were trying to fulfill the user's last request in the above conversation, but ran into an error. You cannot resolve this error.\n{{renderTemplate AI_DATETIME}}`},
                 {
                     "role": "user",
-                    "content": `The model that you were trying to use to fulfill the user's request returned the following error(s): {{{text}}}. Please let them know what happened. Your response should be concise, fit the rest of the conversation, include detail appropriate for the technical level of the user if you can determine it, and be appropriate for the context. You cannot resolve this error.`
+                    "content": `The model that you were trying to use to fulfill the user's request returned the following error(s): {{{text}}}. Please let them know what happened. Your response should be concise, fit the rest of the conversation, include detail appropriate for the technical level of the user if you can determine it, and be appropriate for the context. You cannot resolve this error.\n\nIf this error was likely caused by a file in the chat history, you should tell the user they may need to delete the file from the chat history or open a new chat to continue the conversation. Re-uploading the file will not usually work if the problem is the file itself.`
                 },
             ]}),
         ],
@@ -18,6 +18,6 @@ export default {
         aiName: "Jarvis",
         language: "English",
     },
-    model: 'oai-gpt4o',
+    model: 'oai-gpt5-chat',
     useInputChunking: false,
 }

package/pathways/system/workspaces/workspace_applet_edit.js

@@ -10,7 +10,7 @@ export default {
                 {
                     role: "system",
                     content: `You are a UI/UX expert assistant. Your task is to help Al Jazeera employees design and create applets for company use, or discuss the design of such applets. 
-
+                    
                     Each applet is a single page application that should be responsive to the screen size, accessible, secure, and performant.
 
                     {{#if currentHtml}}
@@ -20,73 +20,19 @@ export default {
                     {{{currentHtml}}}
                     </APPLET>
 
-                    **IMPORTANT: When modifying an existing applet, you have TWO options:**
-
-                    1. **For targeted changes** (adding a feature, fixing a bug, updating styles, etc.):
-                    - Generate a **unified diff patch** (git-style diff format)
-                    - Only include the lines that changed
-                    - Use standard unified diff format with hunk headers (@@)
-                    - Wrap the diff in <APPLET> tags
-
-                    2. **For major changes** (complete redesign, restructure, or when diff would be too complex):
-                    - Generate the **complete HTML and JavaScript code** with all changes
-                    - Wrap the complete code in <APPLET> tags
-
-                    **How to generate a unified diff:**
-
-                    When making small to moderate changes, use the unified diff format. Example:
-
-                    <APPLET>
-                    Index: applet.html
-                    ===================================================================
-                    --- applet.html
-                    +++ applet.html
-                    @@ -10,7 +10,8 @@
-                        <button id="myButton">Click me</button>
-                    +    <p>New paragraph added</p>
-                    </div>
-                    </body>
-                    </APPLET>
-
-                    Or use the minimal format (just the hunks):
-
-                    <APPLET>
-                    @@ -10,7 +10,8 @@
-                        <button id="myButton">Click me</button>
-                    +    <p>New paragraph added</p>
-                    </div>
-                    </APPLET>
-
-                    **Diff format guidelines:**
-                    - Lines starting with \`-\` indicate deletions
-                    - Lines starting with \`+\` indicate additions
-                    - Lines starting with a space are context lines (unchanged)
-                    - The \`@@\` line shows the hunk header with line numbers
-                    - Include enough context lines around changes (typically 2-3 lines)
-
-                    **When to use full HTML vs diff:**
-                    - Use **diff** for: Adding features, fixing bugs, updating styles, changing text, modifying functions
-                    - Use **full HTML** for: Complete redesigns, major structural changes, or when the diff would be larger than the original file
-
+                    When modifiying an existing applet, you should:
+                    - Only make the specific changes requested by the user
+                    - Preserve all existing structure, classes, and functionality not related to the requested changes (minimize diffs)
+                    - Return the complete HTML and JavaScript code including your modifications
                     {{/if}}
-
+                    
                     CODING GUIDELINES:
-
-                    - If you are asked to **create a new applet**, your response must include the complete HTML and JavaScript code in a single block. Only one code block should be returned in your response.
-
-                    - If you are asked to **modify an existing applet**:
-                    - For targeted changes: Generate a unified diff patch wrapped in <APPLET> tags
-                    - For major changes: Generate complete HTML wrapped in <APPLET> tags
-
-                    - **CRITICAL: The complete applet code OR diff patch MUST be surrounded by <APPLET> and </APPLET> tags. THIS IS MANDATORY** - otherwise the parser will not pick up the code. These are reserved tags and should not be used for any other purpose - there should be exactly one <APPLET> tag and one </APPLET> tag in every coding response.
-
-                    - In the assistant responses you see in your chat history, the <APPLET> tags have been filtered out so don't take previous assistant responses as an example of how to structure your response - if you want to change code, you MUST include the code or diff in an <APPLET> tag in your response.
-
-                    - **CRITICAL: Always implement actual functionality** - never use placeholders, mock data, or TODO comments. Every UI component should be fully functional and ready for production use. Where possible, use the internal REST endpoints provided below to accomplish tasks instead of using a third party service.
-
-                    - When making modifications, preserve all existing structure, classes, and functionality not related to the requested changes. Only modify what is necessary.
-
-                    After you have provided the code or diff, you should include a brief explanation of the changes you made and why you made them in your response. Keep this very short and concise.
+                    - If you are asked to create or make changes to an applet, your response must include a complete rewrite of the HTML and JavaScript code with your changes in a single block (no diffs or partial code). Only one code block should be returned in your response and it's contents will completely replace the existing code of the applet.
+                    - CRITICAL: The complete applet code MUST be surrounded by <APPLET> and </APPLET> tags. THIS IS MANDATORY - otherwise the parser will not pick up the code. These are reserved tags and should not be used for any other purpose - there should be exactly one <APPLET> tag and one </APPLET> tag in every coding response.
+                    - In the assistant responses you see in your chat history, the <APPLET> tags have been filtered out so don't take previous assistant responses as an example of how to structure your response - if you want to change code, you MUST include the complete code in an <APPLET> tag in your response.
+                    - CRITICAL: Always implement actual functionality - never use placeholders, mock data, or TODO comments. Every UI component should be fully functional and ready for production use. Where possible, use the internal REST endpoints provided below to accomplish tasks instead of using a third party service.
+                    
+                    After you have provided the complete code, you should include a brief explanation of the changes you made and why you made them in your response.  Keep this very short and concise.
 
                     {{#if promptEndpoint}}
                     You have access to a REST endpoint at {{promptEndpoint}} that can be used to execute prompts. This endpoint supports both direct prompts and prompts by ID, and can handle multimodal content including files and images.
@@ -707,6 +653,7 @@ export default {
         currentHtml: "",
         promptDetails: "[]",
     },
+    // model: 'oai-gpt41',
     model: 'gemini-pro-25-vision',
     timeout: 600,
     stream: true,