Merge branch 'main' into feature/add-qualifire-integration

Author: drorIvry

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@portkey-ai/gateway",
-  "version": "1.12.3",
+  "version": "1.13.0",
   "description": "A fast AI gateway by Portkey",
   "repository": {
     "type": "git",

package.json

@@ -0,0 +1,247 @@
+import {
+  HookEventType,
+  PluginContext,
+  PluginHandler,
+  PluginParameters,
+} from '../types';
+import { getCurrentContentPart, setCurrentContentPart } from '../utils';
+
+const addPrefixToCompletion = (
+  context: PluginContext,
+  prefix: string,
+  eventType: HookEventType
+): Record<string, any> => {
+  const transformedData: Record<string, any> = {
+    request: { json: null },
+    response: { json: null },
+  };
+
+  const { content, textArray } = getCurrentContentPart(context, eventType);
+  if (!content) {
+    return transformedData;
+  }
+
+  const updatedTexts = (
+    Array.isArray(textArray) ? textArray : [String(textArray)]
+  ).map((text, index) => (index === 0 ? `${prefix}${text ?? ''}` : text));
+
+  setCurrentContentPart(context, eventType, transformedData, updatedTexts);
+  return transformedData;
+};
+
+const addPrefixToChatCompletion = (
+  context: PluginContext,
+  prefix: string,
+  applyToRole: string = 'user',
+  addToExisting: boolean = true,
+  onlyIfEmpty: boolean = false,
+  eventType: HookEventType
+): Record<string, any> => {
+  const json = context.request.json;
+  const updatedJson = { ...json };
+  const messages = Array.isArray(json.messages) ? [...json.messages] : [];
+
+  // Find the target role message
+  const targetIndex = messages.findIndex((msg) => msg.role === applyToRole);
+
+  // Helper to build a message content with the prefix in both chatComplete and messages formats
+  const buildPrefixedContent = (existing: any): any => {
+    if (existing == null || typeof existing === 'string') {
+      return `${prefix}${existing ?? ''}`;
+    }
+    if (Array.isArray(existing)) {
+      if (existing.length > 0 && existing[0]?.type === 'text') {
+        const cloned = existing.map((item) => ({ ...item }));
+        cloned[0].text = `${prefix}${cloned[0]?.text ?? ''}`;
+        return cloned;
+      }
+      return [{ type: 'text', text: prefix }, ...existing];
+    }
+    return `${prefix}${String(existing)}`;
+  };
+
+  // If the target role exists
+  if (targetIndex !== -1) {
+    const targetMsg = messages[targetIndex];
+    const content = targetMsg?.content;
+
+    const isEmptyContent =
+      (typeof content === 'string' && content.trim().length === 0) ||
+      (Array.isArray(content) && content.length === 0);
+
+    if (onlyIfEmpty && !isEmptyContent) {
+      // Respect onlyIfEmpty by skipping modification when non-empty
+      return {
+        request: { json: updatedJson },
+        response: { json: null },
+      };
+    }
+
+    if (addToExisting) {
+      // If this is the last message, leverage utils to ensure messages route compatibility
+      if (targetIndex === messages.length - 1) {
+        const transformedData: Record<string, any> = {
+          request: { json: null },
+          response: { json: null },
+        };
+        const { content: currentContent, textArray } = getCurrentContentPart(
+          context,
+          eventType
+        );
+        if (currentContent !== null) {
+          const updatedTexts = (
+            Array.isArray(textArray) ? textArray : [String(textArray)]
+          ).map((text, idx) => (idx === 0 ? `${prefix}${text ?? ''}` : text));
+          setCurrentContentPart(
+            context,
+            eventType,
+            transformedData,
+            updatedTexts
+          );
+        }
+        return transformedData;
+      }
+
+      // Otherwise, modify the specific message inline
+      messages[targetIndex] = {
+        ...targetMsg,
+        content: buildPrefixedContent(targetMsg.content),
+      };
+    } else {
+      // Create new message with prefix before the existing one
+      const newMessage = {
+        role: applyToRole,
+        content:
+          context.requestType === 'messages'
+            ? [{ type: 'text', text: prefix }]
+            : prefix,
+      };
+      messages.splice(targetIndex, 0, newMessage);
+    }
+  } else {
+    // No message with target role exists, create one
+    const newMessage = {
+      role: applyToRole,
+      content:
+        context.requestType === 'messages'
+          ? [{ type: 'text', text: prefix }]
+          : prefix,
+    };
+
+    if (applyToRole === 'system') {
+      messages.unshift(newMessage);
+    } else {
+      messages.push(newMessage);
+    }
+  }
+
+  updatedJson.messages = messages;
+
+  return {
+    request: {
+      json: updatedJson,
+    },
+    response: {
+      json: null,
+    },
+  };
+};
+
+export const handler: PluginHandler = async (
+  context: PluginContext,
+  parameters: PluginParameters,
+  eventType: HookEventType
+) => {
+  let error = null;
+  let verdict = true; // Always allow the request to continue
+  let data = null;
+  const transformedData: Record<string, any> = {
+    request: {
+      json: null,
+    },
+    response: {
+      json: null,
+    },
+  };
+  let transformed = false;
+
+  try {
+    // Only process before request and only for completion/chat completion/messages
+    if (
+      eventType !== 'beforeRequestHook' ||
+      !['complete', 'chatComplete', 'messages'].includes(
+        context.requestType || ''
+      )
+    ) {
+      return {
+        error: null,
+        verdict: true,
+        data: null,
+        transformedData,
+        transformed,
+      };
+    }
+
+    // Get prefix from parameters
+    const prefix = parameters.prefix;
+    if (!prefix || typeof prefix !== 'string') {
+      return {
+        error: { message: 'Prefix parameter is required and must be a string' },
+        verdict: true,
+        data: null,
+        transformedData,
+        transformed,
+      };
+    }
+
+    // Check if request JSON exists
+    if (!context.request?.json) {
+      return {
+        error: { message: 'Request JSON is empty or missing' },
+        verdict: true,
+        data: null,
+        transformedData,
+        transformed,
+      };
+    }
+
+    let newTransformedData;
+
+    if (
+      context.requestType &&
+      ['chatComplete', 'messages'].includes(context.requestType)
+    ) {
+      // Handle chat completion
+      newTransformedData = addPrefixToChatCompletion(
+        context,
+        prefix,
+        parameters.applyToRole || 'user',
+        parameters.addToExisting !== false, // default to true
+        parameters.onlyIfEmpty === true, // default to false
+        eventType
+      );
+    } else {
+      // Handle regular completion
+      newTransformedData = addPrefixToCompletion(context, prefix, eventType);
+    }
+
+    Object.assign(transformedData, newTransformedData);
+    transformed = true;
+
+    data = {
+      prefix: prefix,
+      requestType: context.requestType,
+      applyToRole: parameters.applyToRole || 'user',
+      addToExisting: parameters.addToExisting !== false,
+      onlyIfEmpty: parameters.onlyIfEmpty === true,
+    };
+  } catch (e: any) {
+    delete e.stack;
+    error = {
+      message: `Error in addPrefix plugin: ${e.message || 'Unknown error'}`,
+      originalError: e,
+    };
+  }
+
+  return { error, verdict, data, transformedData, transformed };
+};