@aj-archipelago/cortex 1.3.66 → 1.4.0

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,

package/server/typeDef.js

@@ -1,30 +1,113 @@
+// Check if a value is a JSON Schema object for parameter typing
+const isJsonSchemaObject = (value) => {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false;
+  // Basic JSON Schema indicators
+  return (
+    typeof value.type === 'string' ||
+    value.$ref !== undefined ||
+    value.oneOf !== undefined ||
+    value.anyOf !== undefined ||
+    value.allOf !== undefined ||
+    value.enum !== undefined ||
+    value.properties !== undefined ||
+    value.items !== undefined
+  );
+};
+
+// Extract the default value from a JSON Schema object or return the value as-is
+const extractValueFromTypeSpec = (value) => {
+  if (isJsonSchemaObject(value)) {
+    return value.hasOwnProperty('default') ? value.default : undefined;
+  }
+  return value;
+};
+
+// Process parameters to convert any type specification objects to their actual values
+const processPathwayParameters = (params) => {
+  if (!params || typeof params !== 'object') {
+    return params;
+  }
+  
+  const processed = {};
+  for (const [key, value] of Object.entries(params)) {
+    processed[key] = extractValueFromTypeSpec(value);
+  }
+  return processed;
+};
+
 const getGraphQlType = (value) => {
+  // The value might be an object with JSON Schema type specification
+  if (isJsonSchemaObject(value)) {
+    const schema = value;
+    // Map JSON Schema to GraphQL
+    if (schema.type === 'boolean') {
+      return { type: 'Boolean', defaultValue: schema.default === undefined ? undefined : schema.default };
+    }
+    if (schema.type === 'string') {
+      return { type: 'String', defaultValue: schema.default === undefined ? undefined : `"${schema.default}"` };
+    }
+    if (schema.type === 'integer') {
+      return { type: 'Int', defaultValue: schema.default };
+    }
+    if (schema.type === 'number') {
+      const def = schema.default;
+      return { type: 'Float', defaultValue: def };
+    }
+    if (schema.type === 'array') {
+      // Support arrays of primitive types; fall back to JSON string for complex types
+      const items = schema.items || {};
+      const def = schema.default;
+      const defaultArray = Array.isArray(def) ? JSON.stringify(def) : '[]';
+      if (items.type === 'string') {
+        return { type: '[String]', defaultValue: defaultArray };
+      }
+      if (items.type === 'integer') {
+        return { type: '[Int]', defaultValue: defaultArray };
+      }
+      if (items.type === 'number') {
+        return { type: '[Float]', defaultValue: defaultArray };
+      }
+      if (items.type === 'boolean') {
+        return { type: '[Boolean]', defaultValue: defaultArray };
+      }
+      // Unknown item type: pass as serialized JSON string argument
+      return { type: 'String', defaultValue: def === undefined ? '"[]"' : `"${JSON.stringify(def).replace(/"/g, '\\"')}"` };
+    }
+    if (schema.type === 'object' || schema.properties) {
+      // Until explicit input types are defined, accept as stringified JSON
+      const def = schema.default;
+      return { type: 'String', defaultValue: def === undefined ? '"{}"' : `"${JSON.stringify(def).replace(/"/g, '\\"')}"` };
+    }
+  }
+  
+  // Otherwise, autodetect the type
   switch (typeof value) {
     case 'boolean':
-      return {type: 'Boolean'};
+      return {type: 'Boolean', defaultValue: value};
     case 'string':
-      return {type: 'String'};
+      return {type: 'String', defaultValue: `"${value}"`};
     case 'number':
-      return {type: 'Int'};
+      // Check if it's an integer or float
+      return Number.isInteger(value) ? {type: 'Int', defaultValue: value} : {type: 'Float', defaultValue: value};
     case 'object':
       if (Array.isArray(value)) {
         if (value.length > 0 && typeof(value[0]) === 'string') {
-          return {type: '[String]'};
+          return {type: '[String]', defaultValue: JSON.stringify(value)};
         }
         else {
-          // New case for MultiMessage type
+          // Check if it's MultiMessage (content is array) or Message (content is string)
           if (Array.isArray(value[0]?.content)) {
-            return {type: '[MultiMessage]'};
+            return {type: '[MultiMessage]', defaultValue: `"${JSON.stringify(value).replace(/"/g, '\\"')}"`};
           }
           else {
-            return {type: '[Message]'};
+            return {type: '[Message]', defaultValue: `"${JSON.stringify(value).replace(/"/g, '\\"')}"`};
           }
         }
       } else {
-        return {type: `[${value.objName}]`};
+        return {type: `[${value.objName}]`, defaultValue: JSON.stringify(value)};
       }
     default:
-      return {type: 'String'};
+      return {type: 'String', defaultValue: `"${value}"`};
   }
 };
 
@@ -80,7 +163,7 @@ const getPathwayTypeDefAndExtendQuery = (pathway) => {
     };
   });
 
-  const gqlDefinition = `${type}\n\n${responseType}\n\nextend type Query {${name}(${paramsStr}): ${objName}}`;
+  const gqlDefinition = `${type}\n\n${responseType}\n\nextend type Query {${name}${paramsStr ? `(${paramsStr})` : ''}: ${objName}}`;
 
   return {
     gqlDefinition,
@@ -100,4 +183,7 @@ export {
   getMessageTypeDefs,
   getPathwayTypeDef,
   userPathwayInputParameters,
+  isJsonSchemaObject,
+  extractValueFromTypeSpec,
+  processPathwayParameters,
 };

package/tests/integration/apptekTranslatePlugin.integration.test.js

@@ -155,7 +155,7 @@ test.serial('AppTek Plugin: Force failure and test GPT-4 Omni fallback', async (
 });
 
 // Test AppTek failure with default fallback (translate_groq)
-test.skip('AppTek Plugin: Force failure and test default fallback', async (t) => {
+test('AppTek Plugin: Force failure and test default fallback', async (t) => {
     // Set a longer timeout for this test since Groq might be slower
     t.timeout(180000); // 3 minutes
     

package/tests/unit/core/parser.test.js

@@ -90,7 +90,6 @@ test('parseJson should attempt to repair invalid JSON', async t => {
     
     const result = await parser.parseJson(invalidJson);
     
-    console.log('parseJson result:', result);  // For debugging
     
     t.not(result, null);
     

package/tests/unit/core/pathwayManager.test.js

@@ -193,8 +193,7 @@ test('_createPromptObject handles empty system prompt', t => {
 
     t.true(result instanceof Prompt);
     t.is(result.name, 'test_prompt');
-    t.is(result.messages[0].content, '');
-    t.is(result.messages[1].content, '{{text}}\n\nTest prompt text');
+    t.is(result.messages[0].content, '{{text}}\n\nTest prompt text');
 });
 
 test('_createPromptObject handles null system prompt', t => {
@@ -206,8 +205,7 @@ test('_createPromptObject handles null system prompt', t => {
 
     t.true(result instanceof Prompt);
     t.is(result.name, 'test_prompt');
-    t.is(result.messages[0].content, '');
-    t.is(result.messages[1].content, '{{text}}\n\nTest prompt text');
+    t.is(result.messages[0].content, '{{text}}\n\nTest prompt text');
 });
 
 test('putPathway requires userId and secret', async t => {