Merge branch 'main' into main

Author: indranil786

package-lock.json

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

package.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/manifest.json

@@ -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/modelRules.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';
@@ -69,6 +70,7 @@ export const plugins = {
     alllowercase: defaultalllowercase,
     endsWith: defaultendsWith,
     modelWhitelist: defaultmodelWhitelist,
+    modelRules: defaultmodelRules,
     jwt: defaultjwt,
     requiredMetadataKeys: defaultrequiredMetadataKeys,
     regexReplace: defaultregexReplace,

plugins/index.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 = {

src/globals.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/handlerUtils.ts

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

src/handlers/streamHandler.ts

@@ -169,6 +169,7 @@ export const GoogleApiConfig: ProviderAPIConfig = {
         return googleUrlMap.get(mappedFn) || `${projectRoute}`;
       }
 
+      case 'mistralai':
       case 'anthropic': {
         if (mappedFn === 'chatComplete' || mappedFn === 'messages') {
           return `${projectRoute}/publishers/${provider}/models/${model}:rawPredict`;

src/providers/google-vertex-ai/api.ts

@@ -51,6 +51,11 @@ import {
   VertexAnthropicMessagesConfig,
   VertexAnthropicMessagesResponseTransform,
 } from './messages';
+import {
+  GetMistralAIChatCompleteResponseTransform,
+  GetMistralAIChatCompleteStreamChunkTransform,
+  MistralAIChatCompleteConfig,
+} from '../mistral-ai/chatComplete';
 
 const VertexConfig: ProviderConfigs = {
   api: VertexApiConfig,
@@ -162,6 +167,17 @@ const VertexConfig: ProviderConfigs = {
             ...responseTransforms,
           },
         };
+      case 'mistralai':
+        return {
+          chatComplete: MistralAIChatCompleteConfig,
+          api: GoogleApiConfig,
+          responseTransforms: {
+            chatComplete:
+              GetMistralAIChatCompleteResponseTransform(GOOGLE_VERTEX_AI),
+            'stream-chatComplete':
+              GetMistralAIChatCompleteStreamChunkTransform(GOOGLE_VERTEX_AI),
+          },
+        };
       default:
         return baseConfig;
     }