Merge branch 'main' into feat/mistral-on-vertex

Author: VisargD

plugins/default/manifest.json

@@ -636,6 +636,45 @@
         "required": ["models"]
       }
     },
+    {
+      "name": "Model Rules",
+      "id": "modelRules",
+      "type": "guardrail",
+      "supportedHooks": ["beforeRequestHook"],
+      "description": [
+        {
+          "type": "subHeading",
+          "text": "Allow requests based on metadata-driven rules mapping to allowed models."
+        }
+      ],
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "rules": {
+            "type": "object",
+            "label": "Rules object: {\"defaults\": [\"model\"], \"metadata\": {\"key\": {\"value\": [\"models\"]}}}",
+            "description": [
+              {
+                "type": "text",
+                "text": "Overrides model list using metadata-based routing."
+              }
+            ]
+          },
+          "not": {
+            "type": "boolean",
+            "label": "Invert Model Check",
+            "description": [
+              {
+                "type": "text",
+                "text": "When on, any model resolved by rules is blocked instead of allowed."
+              }
+            ],
+            "default": false
+          }
+        },
+        "required": ["rules"]
+      }
+    },
     {
       "name": "JWT",
       "id": "jwt",

plugins/default/modelRules.ts

@@ -0,0 +1,118 @@
+import type {
+  HookEventType,
+  PluginContext,
+  PluginHandler,
+  PluginParameters,
+} from '../types';
+
+interface RulesData {
+  explanation: string;
+}
+
+export const handler: PluginHandler = async (
+  context: PluginContext,
+  parameters: PluginParameters,
+  eventType: HookEventType
+) => {
+  let error = null;
+  let verdict = false;
+  let data: RulesData | null = null;
+
+  try {
+    const rulesConfig = parameters.rules as Record<string, unknown> | undefined;
+    const not = parameters.not || false;
+    const requestModel = context.request?.json.model as string | undefined;
+    const requestMetadata: Record<string, unknown> = context?.metadata || {};
+
+    if (!requestModel) {
+      throw new Error('Missing model in request');
+    }
+
+    if (!rulesConfig || typeof rulesConfig !== 'object') {
+      throw new Error('Missing rules configuration');
+    }
+
+    type RulesShape = {
+      defaults?: unknown;
+      metadata?: unknown;
+    };
+    const cfg = rulesConfig as RulesShape;
+
+    const defaultsArray = Array.isArray(cfg.defaults)
+      ? (cfg.defaults as unknown[])
+      : [];
+    const defaults = defaultsArray.map((m) => String(m));
+
+    const metadata =
+      cfg.metadata && typeof cfg.metadata === 'object'
+        ? (cfg.metadata as Record<string, Record<string, unknown>>)
+        : {};
+
+    const matched = new Set<string>();
+    const matchedRules: string[] = [];
+
+    for (const [key, mapping] of Object.entries(metadata)) {
+      const reqVal = requestMetadata[key];
+      if (reqVal === undefined || reqVal === null) continue;
+
+      const reqVals = Array.isArray(reqVal)
+        ? reqVal.map((v) => String(v))
+        : [String(reqVal)];
+
+      for (const val of reqVals) {
+        const modelsUnknown = (mapping as Record<string, unknown>)[val];
+        if (Array.isArray(modelsUnknown)) {
+          const models = (modelsUnknown as unknown[]).filter(
+            (m) => typeof m === 'string'
+          ) as string[];
+          matchedRules.push(`${key}:${val}`);
+          for (const m of models) {
+            if (m && typeof m === 'string') {
+              matched.add(String(m));
+            }
+          }
+        }
+      }
+    }
+
+    let allowedSet = Array.from(matched);
+    let usingDefaults = false;
+    if (allowedSet.length === 0) {
+      allowedSet = defaults;
+      usingDefaults = true;
+    }
+
+    if (!Array.isArray(allowedSet) || allowedSet.length === 0) {
+      throw new Error('No allowed models resolved from rules');
+    }
+
+    const inList = allowedSet.includes(requestModel);
+    verdict = not ? !inList : inList;
+
+    let explanation = '';
+    if (verdict) {
+      explanation = not
+        ? `Model "${requestModel}" is not permitted by rules (blocked list).`
+        : `Model "${requestModel}" is allowed by rules.`;
+      if (matchedRules.length) {
+        explanation += ` (matched rules: ${matchedRules.join(', ')})`;
+      } else if (usingDefaults) {
+        explanation += ' (using default models)';
+      }
+    } else {
+      explanation = not
+        ? `Model "${requestModel}" is permitted by rules (in blocked list).`
+        : `Model "${requestModel}" is not allowed by rules.`;
+    }
+
+    data = { explanation };
+  } catch (e) {
+    const err = e as Error;
+    error = err;
+    data = {
+      explanation: `An error occurred while checking model rules: ${err.message}`,
+    };
+  }
+
+  return { error, verdict, data };
+};

plugins/default/regexReplace.ts

@@ -0,0 +1,92 @@
+import {
+  HookEventType,
+  PluginContext,
+  PluginHandler,
+  PluginParameters,
+} from '../types';
+import { getCurrentContentPart, setCurrentContentPart } from '../utils';
+
+export const handler: PluginHandler = async (
+  context: PluginContext,
+  parameters: PluginParameters,
+  eventType: HookEventType
+) => {
+  let error = null;
+  let verdict = true;
+  let data: any = null;
+  const transformedData: Record<string, any> = {
+    request: {
+      json: null,
+    },
+    response: {
+      json: null,
+    },
+  };
+  let transformed = false;
+
+  try {
+    const regexPattern = parameters.rule;
+    const redactText = parameters.redactText || '[REDACTED]';
+    const failOnDetection = parameters.failOnDetection || false;
+
+    const { content, textArray } = getCurrentContentPart(context, eventType);
+
+    if (!regexPattern) {
+      throw new Error('Missing regex pattern');
+    }
+    if (!content) {
+      throw new Error('Missing text to match');
+    }
+
+    const regex = new RegExp(regexPattern, 'g');
+
+    // Process all text items in the array
+    let hasMatches = false;
+    const mappedTextArray: Array<string | null> = [];
+    textArray.forEach((text) => {
+      if (!text) {
+        mappedTextArray.push(null);
+        return;
+      }
+
+      // Reset regex for each text when using global flag
+      regex.lastIndex = 0;
+
+      const matches = text.match(regex);
+      if (matches && matches.length > 0) {
+        hasMatches = true;
+      }
+      const replacedText = text.replace(regex, redactText);
+      mappedTextArray.push(replacedText);
+    });
+
+    // Handle transformation
+    if (hasMatches) {
+      setCurrentContentPart(
+        context,
+        eventType,
+        transformedData,
+        mappedTextArray
+      );
+      transformed = true;
+    }
+    if (failOnDetection && hasMatches) {
+      verdict = false;
+    }
+    data = {
+      regexPattern,
+      verdict,
+      explanation: transformed
+        ? `Pattern '${regexPattern}' matched and was replaced with '${redactText}'`
+        : `The regex pattern '${regexPattern}' did not match any text.`,
+    };
+  } catch (e: any) {
+    error = e;
+    data = {
+      explanation: `An error occurred while processing the regex: ${e.message}`,
+      regexPattern: parameters.rule,
+    };
+  }
+
+  return { error, verdict, data, transformedData, transformed };
+};

plugins/index.ts

@@ -13,6 +13,7 @@ import { handler as defaultalluppercase } from './default/alluppercase';
 import { handler as defaultalllowercase } from './default/alllowercase';
 import { handler as defaultendsWith } from './default/endsWith';
 import { handler as defaultmodelWhitelist } from './default/modelWhitelist';
+import { handler as defaultmodelRules } from './default/modelRules';
 import { handler as portkeymoderateContent } from './portkey/moderateContent';
 import { handler as portkeylanguage } from './portkey/language';
 import { handler as portkeypii } from './portkey/pii';
@@ -50,6 +51,7 @@ import { handler as panwPrismaAirsintercept } from './panw-prisma-airs/intercept
 import { handler as defaultjwt } from './default/jwt';
 import { handler as defaultrequiredMetadataKeys } from './default/requiredMetadataKeys';
 import { handler as walledaiguardrails } from './walledai/guardrails';
+import { handler as defaultregexReplace } from './default/regexReplace';
 
 export const plugins = {
   default: {
@@ -68,8 +70,10 @@ export const plugins = {
     alllowercase: defaultalllowercase,
     endsWith: defaultendsWith,
     modelWhitelist: defaultmodelWhitelist,
+    modelRules: defaultmodelRules,
     jwt: defaultjwt,
     requiredMetadataKeys: defaultrequiredMetadataKeys,
+    regexReplace: defaultregexReplace,
   },
   portkey: {
     moderateContent: portkeymoderateContent,

src/globals.ts

@@ -102,6 +102,8 @@ export const FEATHERLESS_AI: string = 'featherless-ai';
 export const KRUTRIM: string = 'krutrim';
 export const QDRANT: string = 'qdrant';
 export const THREE_ZERO_TWO_AI: string = '302ai';
+export const MESHY: string = 'meshy';
+export const TRIPO3D: string = 'tripo3d';
 
 export const VALID_PROVIDERS = [
   ANTHROPIC,
@@ -167,6 +169,8 @@ export const VALID_PROVIDERS = [
   KRUTRIM,
   QDRANT,
   THREE_ZERO_TWO_AI,
+  MESHY,
+  TRIPO3D,
 ];
 
 export const CONTENT_TYPES = {
@@ -215,6 +219,8 @@ export const fileExtensionMimeTypeMap = {
   mpegps: 'video/mpegps',
   flv: 'video/flv',
   webm: 'video/webm',
+  mkv: 'video/mkv',
+  threegpp: 'video/three_gpp',
 };
 
 export const imagesMimeTypes = [
@@ -238,6 +244,19 @@ export const documentMimeTypes = [
   fileExtensionMimeTypeMap.txt,
 ];
 
+export const videoMimeTypes = [
+  fileExtensionMimeTypeMap.mkv,
+  fileExtensionMimeTypeMap.mov,
+  fileExtensionMimeTypeMap.mp4,
+  fileExtensionMimeTypeMap.webm,
+  fileExtensionMimeTypeMap.flv,
+  fileExtensionMimeTypeMap.mpeg,
+  fileExtensionMimeTypeMap.mpg,
+  fileExtensionMimeTypeMap.wmv,
+  fileExtensionMimeTypeMap.threegpp,
+  fileExtensionMimeTypeMap.avi,
+];
+
 export enum BatchEndpoints {
   CHAT_COMPLETIONS = '/v1/chat/completions',
   COMPLETIONS = '/v1/completions',

src/handlers/handlerUtils.ts

@@ -734,6 +734,7 @@ export async function tryTargetsRecursively(
         conditionalRouter = new ConditionalRouter(currentTarget, {
           metadata,
           params,
+          url: { pathname: c.req.path },
         });
         finalTarget = conditionalRouter.resolveTarget();
       } catch (conditionalRouter: any) {

src/handlers/streamHandler.ts

@@ -321,9 +321,13 @@ export function handleStreamingMode(
           await writer.write(encoder.encode(chunk));
         }
       } catch (error) {
-        console.error(error);
+        console.error('Error during stream processing:', error);
       } finally {
-        writer.close();
+        try {
+          await writer.close();
+        } catch (closeError) {
+          console.error('Failed to close the writer:', closeError);
+        }
       }
     })();
   } else {
@@ -341,9 +345,13 @@ export function handleStreamingMode(
           await writer.write(encoder.encode(chunk));
         }
       } catch (error) {
-        console.error(error);
+        console.error('Error during stream processing:', error);
       } finally {
-        writer.close();
+        try {
+          await writer.close();
+        } catch (closeError) {
+          console.error('Failed to close the writer:', closeError);
+        }
       }
     })();
   }