lmkm

Model.json

@@ -0,0 +1,50 @@
+[
+    {
+        "text": "Next.js and Supabase Starter Kit\n\nNext steps\n\n 1. Create Supabase project\n    \n    Head over to database.new and create a new Supabase project.\n\n 2. Declare environment variables\n    \n    Rename the .env.example file in your Next.js app to .env.local and populate with values from your Supabase project's API Settings.\n\n 3. Restart your Next.js development server\n    \n    You may need to quit your Next.js development server and run npm run dev again to load the new environment variables.\n\n 4. Refresh the page\n    \n    You may need to refresh the page for Next.js to load the new environment variables.",
+        "metadata": {
+            "title": "Next.js and Supabase Starter Kit",
+            "description": "The fastest way to build apps with Next.js and Supabase",
+            "og:title": "Next.js and Supabase Starter Kit",
+            "og:description": "The fastest way to build apps with Next.js and Supabase",
+            "og:image:type": "image/png",
+            "og:image:width": "1200",
+            "og:image:height": "600",
+            "og:image": "https://web4app-4qbc-jmjfa06vw-web4s-projects-1b8287a0.vercel.app/opengraph-image.png?2e0bc232e210f89d",
+            "twitter:title": "Next.js and Supabase Starter Kit",
+            "twitter:description": "The fastest way to build apps with Next.js and Supabase"
+        },
+        "credits": 2
+    },
+    {
+        "text": "Next.js and Supabase Starter Kit\n\nNext steps\n\n 1. Create Supabase project\n    \n    Head over to database.new and create a new Supabase project.\n\n 2. Declare environment variables\n    \n    Rename the .env.example file in your Next.js app to .env.local and populate with values from your Supabase project's API Settings.\n\n 3. Restart your Next.js development server\n    \n    You may need to quit your Next.js development server and run npm run dev again to load the new environment variables.\n\n 4. Refresh the page\n    \n    You may need to refresh the page for Next.js to load the new environment variables.",
+        "metadata": {
+            "title": "Next.js and Supabase Starter Kit",
+            "description": "The fastest way to build apps with Next.js and Supabase",
+            "og:title": "Next.js and Supabase Starter Kit",
+            "og:description": "The fastest way to build apps with Next.js and Supabase",
+            "og:image:type": "image/png",
+            "og:image:width": "1200",
+            "og:image:height": "600",
+            "og:image": "https://web4app-4qbc-jmjfa06vw-web4s-projects-1b8287a0.vercel.app/opengraph-image.png?2e0bc232e210f89d",
+            "twitter:title": "Next.js and Supabase Starter Kit",
+            "twitter:description": "The fastest way to build apps with Next.js and Supabase"
+        },
+        "credits": 2
+    },
+    {
+        "text": "Next.js and Supabase Starter Kit\n\nNext steps\n\n 1. Create Supabase project\n    \n    Head over to database.new and create a new Supabase project.\n\n 2. Declare environment variables\n    \n    Rename the .env.example file in your Next.js app to .env.local and populate with values from your Supabase project's API Settings.\n\n 3. Restart your Next.js development server\n    \n    You may need to quit your Next.js development server and run npm run dev again to load the new environment variables.\n\n 4. Refresh the page\n    \n    You may need to refresh the page for Next.js to load the new environment variables.",
+        "metadata": {
+            "title": "Next.js and Supabase Starter Kit",
+            "description": "The fastest way to build apps with Next.js and Supabase",
+            "og:title": "Next.js and Supabase Starter Kit",
+            "og:description": "The fastest way to build apps with Next.js and Supabase",
+            "og:image:type": "image/png",
+            "og:image:width": "1200",
+            "og:image:height": "600",
+            "og:image": "https://web4app-4qbc-jmjfa06vw-web4s-projects-1b8287a0.vercel.app/opengraph-image.png?2e0bc232e210f89d",
+            "twitter:title": "Next.js and Supabase Starter Kit",
+            "twitter:description": "The fastest way to build apps with Next.js and Supabase"
+        },
+        "credits": 2
+    }
+]

Model.jsonl

@@ -0,0 +1,172 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "$id": "https://github.com/unicode-org/message-format-wg/blob/main/spec/data-model/message.json",
+
+  "oneOf": [{ "$ref": "#/$defs/message" }, { "$ref": "#/$defs/select" }],
+
+  "$defs": {
+    "literal": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "literal" },
+        "value": { "type": "string" }
+      },
+      "required": ["type", "value"]
+    },
+    "variable": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "variable" },
+        "name": { "type": "string" }
+      },
+      "required": ["type", "name"]
+    },
+    "literal-or-variable": {
+      "oneOf": [{ "$ref": "#/$defs/literal" }, { "$ref": "#/$defs/variable" }]
+    },
+
+    "options": {
+      "type": "object",
+      "additionalProperties": { "$ref": "#/$defs/literal-or-variable" }
+    },
+    "attributes": {
+      "type": "object",
+      "additionalProperties": {
+        "oneOf": [{ "$ref": "#/$defs/literal" }, { "const": true }]
+      }
+    },
+
+    "function": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "function" },
+        "name": { "type": "string" },
+        "options": { "$ref": "#/$defs/options" }
+      },
+      "required": ["type", "name"]
+    },
+    "expression": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "expression" },
+        "arg": { "$ref": "#/$defs/literal-or-variable" },
+        "function": { "$ref": "#/$defs/function" },
+        "attributes": { "$ref": "#/$defs/attributes" }
+      },
+      "anyOf": [
+        { "required": ["type", "arg"] },
+        { "required": ["type", "function"] }
+      ]
+    },
+
+    "markup": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "markup" },
+        "kind": { "enum": ["open", "standalone", "close"] },
+        "name": { "type": "string" },
+        "options": { "$ref": "#/$defs/options" },
+        "attributes": { "$ref": "#/$defs/attributes" }
+      },
+      "required": ["type", "kind", "name"]
+    },
+
+    "pattern": {
+      "type": "array",
+      "items": {
+        "oneOf": [
+          { "type": "string" },
+          { "$ref": "#/$defs/expression" },
+          { "$ref": "#/$defs/markup" }
+        ]
+      }
+    },
+
+    "input-declaration": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "input" },
+        "name": { "type": "string" },
+        "value": {
+          "allOf": [
+            { "$ref": "#/$defs/expression" },
+            {
+              "properties": {
+                "arg": { "$ref": "#/$defs/variable" }
+              },
+              "required": ["arg"]
+            }
+          ]
+        }
+      },
+      "required": ["type", "name", "value"]
+    },
+    "local-declaration": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "local" },
+        "name": { "type": "string" },
+        "value": { "$ref": "#/$defs/expression" }
+      },
+      "required": ["type", "name", "value"]
+    },
+    "declarations": {
+      "type": "array",
+      "items": {
+        "oneOf": [
+          { "$ref": "#/$defs/input-declaration" },
+          { "$ref": "#/$defs/local-declaration" }
+        ]
+      }
+    },
+
+    "variant-key": {
+      "oneOf": [
+        { "$ref": "#/$defs/literal" },
+        {
+          "type": "object",
+          "properties": {
+            "type": { "const": "*" },
+            "value": { "type": "string" }
+          },
+          "required": ["type"]
+        }
+      ]
+    },
+    "message": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "message" },
+        "declarations": { "$ref": "#/$defs/declarations" },
+        "pattern": { "$ref": "#/$defs/pattern" }
+      },
+      "required": ["type", "declarations", "pattern"]
+    },
+    "select": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "select" },
+        "declarations": { "$ref": "#/$defs/declarations" },
+        "selectors": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/variable" }
+        },
+        "variants": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "keys": {
+                "type": "array",
+                "items": { "$ref": "#/$defs/variant-key" }
+              },
+              "value": { "$ref": "#/$defs/pattern" }
+            },
+            "required": ["keys", "value"]
+          }
+        }
+      },
+      "required": ["type", "declarations", "selectors", "variants"]
+    }
+  }
+}

Usr.tsx

@@ -0,0 +1,13 @@
+import { PaletteColors } from '@blockchain-com/constellation'
+import styled from 'styled-components'
+
+export const CloseIconContainer = styled.div`
+  display: flex;
+  align-items: center;
+  cursor: pointer;
+  justify-content: center;
+  width: 32px;
+  height: 32px;
+  border-radius: 50%;
+  background: ${PaletteColors['grey-000']};
+`

model.ts

@@ -0,0 +1,258 @@
+import { DEFAULT_MODELS, ServiceProvider } from "../constant";
+import { LLMModel } from "../client/api";
+
+const CustomSeq = {
+  val: -1000, //To ensure the custom model located at front, start from -1000, refer to constant.ts
+  cache: new Map<string, number>(),
+  next: (id: string) => {
+    if (CustomSeq.cache.has(id)) {
+      return CustomSeq.cache.get(id) as number;
+    } else {
+      let seq = CustomSeq.val++;
+      CustomSeq.cache.set(id, seq);
+      return seq;
+    }
+  },
+};
+
+const customProvider = (providerName: string) => ({
+  id: providerName.toLowerCase(),
+  providerName: providerName,
+  providerType: "custom",
+  sorted: CustomSeq.next(providerName),
+});
+
+/**
+ * Sorts an array of models based on specified rules.
+ *
+ * First, sorted by provider; if the same, sorted by model
+ */
+const sortModelTable = (models: ReturnType<typeof collectModels>) =>
+  models.sort((a, b) => {
+    if (a.provider && b.provider) {
+      let cmp = a.provider.sorted - b.provider.sorted;
+      return cmp === 0 ? a.sorted - b.sorted : cmp;
+    } else {
+      return a.sorted - b.sorted;
+    }
+  });
+
+/**
+ * get model name and provider from a formatted string,
+ * e.g. `gpt-4@OpenAi` or `claude-3-5-sonnet@20240620@Google`
+ * @param modelWithProvider model name with provider separated by last `@` char,
+ * @returns [model, provider] tuple, if no `@` char found, provider is undefined
+ */
+export function getModelProvider(modelWithProvider: string): [string, string?] {
+  const [model, provider] = modelWithProvider.split(/@(?!.*@)/);
+  return [model, provider];
+}
+
+export function collectModelTable(
+  models: readonly LLMModel[],
+  customModels: string,
+) {
+  const modelTable: Record<
+    string,
+    {
+      available: boolean;
+      name: string;
+      displayName: string;
+      sorted: number;
+      provider?: LLMModel["provider"]; // Marked as optional
+      isDefault?: boolean;
+    }
+  > = {};
+
+  // default models
+  models.forEach((m) => {
+    // using <modelName>@<providerId> as fullName
+    modelTable[`${m.name}@${m?.provider?.id}`] = {
+      ...m,
+      displayName: m.name, // 'provider' is copied over if it exists
+    };
+  });
+
+  // server custom models
+  customModels
+    .split(",")
+    .filter((v) => !!v && v.length > 0)
+    .forEach((m) => {
+      const available = !m.startsWith("-");
+      const nameConfig =
+        m.startsWith("+") || m.startsWith("-") ? m.slice(1) : m;
+      let [name, displayName] = nameConfig.split("=");
+
+      // enable or disable all models
+      if (name === "all") {
+        Object.values(modelTable).forEach(
+          (model) => (model.available = available),
+        );
+      } else {
+        // 1. find model by name, and set available value
+        const [customModelName, customProviderName] = getModelProvider(name);
+        let count = 0;
+        for (const fullName in modelTable) {
+          const [modelName, providerName] = getModelProvider(fullName);
+          if (
+            customModelName == modelName &&
+            (customProviderName === undefined ||
+              customProviderName === providerName)
+          ) {
+            count += 1;
+            modelTable[fullName]["available"] = available;
+            // swap name and displayName for bytedance
+            if (providerName === "bytedance") {
+              [name, displayName] = [displayName, modelName];
+              modelTable[fullName]["name"] = name;
+            }
+            if (displayName) {
+              modelTable[fullName]["displayName"] = displayName;
+            }
+          }
+        }
+        // 2. if model not exists, create new model with available value
+        if (count === 0) {
+          let [customModelName, customProviderName] = getModelProvider(name);
+          const provider = customProvider(
+            customProviderName || customModelName,
+          );
+          // swap name and displayName for bytedance
+          if (displayName && provider.providerName == "ByteDance") {
+            [customModelName, displayName] = [displayName, customModelName];
+          }
+          modelTable[`${customModelName}@${provider?.id}`] = {
+            name: customModelName,
+            displayName: displayName || customModelName,
+            available,
+            provider, // Use optional chaining
+            sorted: CustomSeq.next(`${customModelName}@${provider?.id}`),
+          };
+        }
+      }
+    });
+
+  return modelTable;
+}
+
+export function collectModelTableWithDefaultModel(
+  models: readonly LLMModel[],
+  customModels: string,
+  defaultModel: string,
+) {
+  let modelTable = collectModelTable(models, customModels);
+  if (defaultModel && defaultModel !== "") {
+    if (defaultModel.includes("@")) {
+      if (defaultModel in modelTable) {
+        modelTable[defaultModel].isDefault = true;
+      }
+    } else {
+      for (const key of Object.keys(modelTable)) {
+        if (
+          modelTable[key].available &&
+          getModelProvider(key)[0] == defaultModel
+        ) {
+          modelTable[key].isDefault = true;
+          break;
+        }
+      }
+    }
+  }
+  return modelTable;
+}
+
+/**
+ * Generate full model table.
+ */
+export function collectModels(
+  models: readonly LLMModel[],
+  customModels: string,
+) {
+  const modelTable = collectModelTable(models, customModels);
+  let allModels = Object.values(modelTable);
+
+  allModels = sortModelTable(allModels);
+
+  return allModels;
+}
+
+export function collectModelsWithDefaultModel(
+  models: readonly LLMModel[],
+  customModels: string,
+  defaultModel: string,
+) {
+  const modelTable = collectModelTableWithDefaultModel(
+    models,
+    customModels,
+    defaultModel,
+  );
+  let allModels = Object.values(modelTable);
+
+  allModels = sortModelTable(allModels);
+
+  return allModels;
+}
+
+export function isModelAvailableInServer(
+  customModels: string,
+  modelName: string,
+  providerName: string,
+) {
+  const fullName = `${modelName}@${providerName}`;
+  const modelTable = collectModelTable(DEFAULT_MODELS, customModels);
+  return modelTable[fullName]?.available === false;
+}
+
+/**
+ * Check if the model name is a GPT-4 related model
+ *
+ * @param modelName The name of the model to check
+ * @returns True if the model is a GPT-4 related model (excluding gpt-4o-mini)
+ */
+export function isGPT4Model(modelName: string): boolean {
+  return (
+    (modelName.startsWith("gpt-4") ||
+      modelName.startsWith("chatgpt-4o") ||
+      modelName.startsWith("o1")) &&
+    !modelName.startsWith("gpt-4o-mini")
+  );
+}
+
+/**
+ * Checks if a model is not available on any of the specified providers in the server.
+ *
+ * @param {string} customModels - A string of custom models, comma-separated.
+ * @param {string} modelName - The name of the model to check.
+ * @param {string|string[]} providerNames - A string or array of provider names to check against.
+ *
+ * @returns {boolean} True if the model is not available on any of the specified providers, false otherwise.
+ */
+export function isModelNotavailableInServer(
+  customModels: string,
+  modelName: string,
+  providerNames: string | string[],
+): boolean {
+  // Check DISABLE_GPT4 environment variable
+  if (
+    process.env.DISABLE_GPT4 === "1" &&
+    isGPT4Model(modelName.toLowerCase())
+  ) {
+    return true;
+  }
+
+  const modelTable = collectModelTable(DEFAULT_MODELS, customModels);
+
+  const providerNamesArray = Array.isArray(providerNames)
+    ? providerNames
+    : [providerNames];
+  for (const providerName of providerNamesArray) {
+    // if model provider is bytedance, use model config name to check if not avaliable
+    if (providerName === ServiceProvider.ByteDance) {
+      return !Object.values(modelTable).filter((v) => v.name === modelName)?.[0]
+        ?.available;
+    }
+    const fullName = `${modelName}@${providerName.toLowerCase()}`;
+    if (modelTable?.[fullName]?.available === true) return false;
+  }
+  return true;
+}

models.json

@@ -0,0 +1,212 @@
+{
+  "models": [
+    {
+      "id": "gpt-4.1",
+      "name": "GPT-4.1",
+      "provider": "OpenAI",
+      "providerId": "openai",
+      "enabled": true,
+      "toolCallType": "native"
+    },
+    {
+      "id": "gpt-4.1-mini",
+      "name": "GPT-4.1 mini",
+      "provider": "OpenAI",
+      "providerId": "openai",
+      "enabled": true,
+      "toolCallType": "native"
+    },
+    {
+      "id": "gpt-4.1-nano",
+      "name": "GPT-4.1 nano",
+      "provider": "OpenAI",
+      "providerId": "openai",
+      "enabled": true,
+      "toolCallType": "native"
+    },
+    {
+      "id": "o3-mini",
+      "name": "o3 mini",
+      "provider": "OpenAI",
+      "providerId": "openai",
+      "enabled": true,
+      "toolCallType": "native"
+    },
+    {
+      "id": "gpt-4o",
+      "name": "GPT-4o",
+      "provider": "OpenAI",
+      "providerId": "openai",
+      "enabled": true,
+      "toolCallType": "native"
+    },
+    {
+      "id": "gpt-4o-mini",
+      "name": "GPT-4o mini",
+      "provider": "OpenAI",
+      "providerId": "openai",
+      "enabled": true,
+      "toolCallType": "native"
+    },
+    {
+      "id": "claude-3-7-sonnet-20250219",
+      "name": "Claude 3.7 Sonnet",
+      "provider": "Anthropic",
+      "providerId": "anthropic",
+      "enabled": true,
+      "toolCallType": "native"
+    },
+    {
+      "id": "claude-3-5-sonnet-latest",
+      "name": "Claude 3.5 Sonnet",
+      "provider": "Anthropic",
+      "providerId": "anthropic",
+      "enabled": true,
+      "toolCallType": "native"
+    },
+    {
+      "id": "claude-3-5-haiku-20241022",
+      "name": "Claude 3.5 Haiku",
+      "provider": "Anthropic",
+      "providerId": "anthropic",
+      "enabled": true,
+      "toolCallType": "native"
+    },
+    {
+      "id": "<AZURE_DEPLOYMENT_NAME>",
+      "name": "<AZURE_DEPLOYMENT_NAME>",
+      "provider": "Azure",
+      "providerId": "azure",
+      "enabled": true,
+      "toolCallType": "native"
+    },
+    {
+      "id": "gemini-2.0-flash",
+      "name": "Gemini 2.0 Flash",
+      "provider": "Google Generative AI",
+      "providerId": "google",
+      "enabled": true,
+      "toolCallType": "manual"
+    },
+    {
+      "id": "gemini-2.0-flash-thinking-exp-01-21",
+      "name": "Gemini 2.0 Flash Thinking (Exp)",
+      "provider": "Google Generative AI",
+      "providerId": "google",
+      "enabled": true,
+      "toolCallType": "manual",
+      "toolCallModel": "gemini-2.0-flash"
+    },
+    {
+      "id": "gemini-2.5-pro-exp-03-25",
+      "name": "Gemini 2.5 Pro (Exp)",
+      "provider": "Google Generative AI",
+      "providerId": "google",
+      "enabled": true,
+      "toolCallType": "manual",
+      "toolCallModel": "gemini-2.0-flash"
+    },
+    {
+      "id": "accounts/fireworks/models/deepseek-r1",
+      "name": "DeepSeek R1",
+      "provider": "Fireworks",
+      "providerId": "fireworks",
+      "enabled": true,
+      "toolCallType": "manual",
+      "toolCallModel": "accounts/fireworks/models/llama-v3p1-8b-instruct"
+    },
+    {
+      "id": "accounts/fireworks/models/llama4-maverick-instruct-basic",
+      "name": "Llama 4 Maverick",
+      "provider": "Fireworks",
+      "providerId": "fireworks",
+      "enabled": true,
+      "toolCallType": "manual",
+      "toolCallModel": "accounts/fireworks/models/llama-v3p1-8b-instruct"
+    },
+    {
+      "id": "deepseek-reasoner",
+      "name": "DeepSeek R1",
+      "provider": "DeepSeek",
+      "providerId": "deepseek",
+      "enabled": true,
+      "toolCallType": "manual",
+      "toolCallModel": "deepseek-chat"
+    },
+    {
+      "id": "deepseek-chat",
+      "name": "DeepSeek V3",
+      "provider": "DeepSeek",
+      "providerId": "deepseek",
+      "enabled": true,
+      "toolCallType": "manual"
+    },
+    {
+      "id": "deepseek-r1-distill-llama-70b",
+      "name": "DeepSeek R1 Distill Llama 70B",
+      "provider": "Groq",
+      "providerId": "groq",
+      "enabled": true,
+      "toolCallType": "manual",
+      "toolCallModel": "llama-3.1-8b-instant"
+    },
+    {
+      "id": "meta-llama/llama-4-maverick-17b-128e-instruct",
+      "name": "Llama 4 Maverick 17B",
+      "provider": "Groq",
+      "providerId": "groq",
+      "enabled": true,
+      "toolCallType": "native"
+    },
+    {
+      "id": "deepseek-r1",
+      "name": "DeepSeek R1",
+      "provider": "Ollama",
+      "providerId": "ollama",
+      "enabled": true,
+      "toolCallType": "manual",
+      "toolCallModel": "phi4"
+    },
+    {
+      "id": "<OLLAMA_MODEL_ID>",
+      "name": "<OLLAMA_MODEL_NAME>",
+      "provider": "Ollama",
+      "providerId": "ollama",
+      "enabled": true,
+      "toolCallType": "manual",
+      "toolCallModel": "<OLLAMA_MODEL_ID>"
+    },
+    {
+      "id": "grok-2-1212",
+      "name": "Grok 2",
+      "provider": "xAI",
+      "providerId": "xai",
+      "enabled": true,
+      "toolCallType": "native"
+    },
+    {
+      "id": "grok-2-vision-1212",
+      "name": "Grok 2 Vision",
+      "provider": "xAI",
+      "providerId": "xai",
+      "enabled": true,
+      "toolCallType": "native"
+    },
+    {
+      "id": "grok-3-beta",
+      "name": "Grok 3 Beta",
+      "provider": "xAI",
+      "providerId": "xai",
+      "enabled": true,
+      "toolCallType": "native"
+    },
+    {
+      "id": "<OPENAI_COMPATIBLE_MODEL>",
+      "name": "<OPENAI_COMPATIBLE_MODEL>",
+      "provider": "OpenAI Compatible",
+      "providerId": "openai-compatible",
+      "enabled": true,
+      "toolCallType": "native"
+    }
+  ]
+}

models.service.ts

@@ -0,0 +1,195 @@
+import { ServerModelStatus } from '$lib/enums';
+import { apiFetch, apiPost } from '$lib/utils';
+import type { ParsedModelId } from '$lib/types/models';
+import {
+	MODEL_FORMAT_SEGMENT_RE,
+	MODEL_PARAMS_RE,
+	MODEL_ACTIVATED_PARAMS_RE,
+	MODEL_ID_NOT_FOUND,
+	MODEL_ID_ORG_SEPARATOR,
+	MODEL_ID_SEGMENT_SEPARATOR,
+	MODEL_ID_QUANTIZATION_SEPARATOR,
+	API_MODELS
+} from '$lib/constants';
+
+export class ModelsService {
+	/**
+	 *
+	 *
+	 * Listing
+	 *
+	 *
+	 */
+
+	/**
+	 * Fetch list of models from OpenAI-compatible endpoint.
+	 * Works in both MODEL and ROUTER modes.
+	 *
+	 * @returns List of available models with basic metadata
+	 */
+	static async list(): Promise<ApiModelListResponse> {
+		return apiFetch<ApiModelListResponse>(API_MODELS.LIST);
+	}
+
+	/**
+	 * Fetch list of all models with detailed metadata (ROUTER mode).
+	 * Returns models with load status, paths, and other metadata
+	 * beyond what the OpenAI-compatible endpoint provides.
+	 *
+	 * @returns List of models with detailed status and configuration info
+	 */
+	static async listRouter(): Promise<ApiRouterModelsListResponse> {
+		return apiFetch<ApiRouterModelsListResponse>(API_MODELS.LIST);
+	}
+
+	/**
+	 *
+	 *
+	 * Load/Unload
+	 *
+	 *
+	 */
+
+	/**
+	 * Load a model (ROUTER mode only).
+	 * Sends POST request to `/models/load`. Note: the endpoint returns success
+	 * before loading completes — use polling to await actual load status.
+	 *
+	 * @param modelId - Model identifier to load
+	 * @param extraArgs - Optional additional arguments to pass to the model instance
+	 * @returns Load response from the server
+	 */
+	static async load(modelId: string, extraArgs?: string[]): Promise<ApiRouterModelsLoadResponse> {
+		const payload: { model: string; extra_args?: string[] } = { model: modelId };
+		if (extraArgs && extraArgs.length > 0) {
+			payload.extra_args = extraArgs;
+		}
+
+		return apiPost<ApiRouterModelsLoadResponse>(API_MODELS.LOAD, payload);
+	}
+
+	/**
+	 * Unload a model (ROUTER mode only).
+	 * Sends POST request to `/models/unload`. Note: the endpoint returns success
+	 * before unloading completes — use polling to await actual unload status.
+	 *
+	 * @param modelId - Model identifier to unload
+	 * @returns Unload response from the server
+	 */
+	static async unload(modelId: string): Promise<ApiRouterModelsUnloadResponse> {
+		return apiPost<ApiRouterModelsUnloadResponse>(API_MODELS.UNLOAD, { model: modelId });
+	}
+
+	/**
+	 *
+	 *
+	 * Status
+	 *
+	 *
+	 */
+
+	/**
+	 * Check if a model is loaded based on its metadata.
+	 *
+	 * @param model - Model data entry from the API response
+	 * @returns True if the model status is LOADED
+	 */
+	static isModelLoaded(model: ApiModelDataEntry): boolean {
+		return model.status.value === ServerModelStatus.LOADED;
+	}
+
+	/**
+	 * Check if a model is currently loading.
+	 *
+	 * @param model - Model data entry from the API response
+	 * @returns True if the model status is LOADING
+	 */
+	static isModelLoading(model: ApiModelDataEntry): boolean {
+		return model.status.value === ServerModelStatus.LOADING;
+	}
+
+	/**
+	 *
+	 *
+	 * Parsing
+	 *
+	 *
+	 */
+
+	/**
+	 * Parse a model ID string into its structured components.
+	 *
+	 * Handles the convention:
+	 *   `<org>/<ModelName>-<Parameters>(-<ActivatedParameters>)-<Format>:<QuantizationType>`
+	 *
+	 * @param modelId - Raw model identifier string
+	 * @returns Structured {@link ParsedModelId} with all detected fields
+	 */
+	static parseModelId(modelId: string): ParsedModelId {
+		const result: ParsedModelId = {
+			raw: modelId,
+			orgName: null,
+			modelName: null,
+			params: null,
+			activatedParams: null,
+			format: null,
+			quantization: null,
+			tags: []
+		};
+
+		const colonIdx = modelId.indexOf(MODEL_ID_QUANTIZATION_SEPARATOR);
+		let modelPath: string;
+
+		if (colonIdx !== MODEL_ID_NOT_FOUND) {
+			result.quantization = modelId.slice(colonIdx + 1) || null;
+			modelPath = modelId.slice(0, colonIdx);
+		} else {
+			modelPath = modelId;
+		}
+
+		const slashIdx = modelPath.indexOf(MODEL_ID_ORG_SEPARATOR);
+		let modelStr: string;
+
+		if (slashIdx !== MODEL_ID_NOT_FOUND) {
+			result.orgName = modelPath.slice(0, slashIdx);
+			modelStr = modelPath.slice(slashIdx + 1);
+		} else {
+			modelStr = modelPath;
+		}
+
+		const segments = modelStr.split(MODEL_ID_SEGMENT_SEPARATOR);
+
+		if (segments.length > 0 && MODEL_FORMAT_SEGMENT_RE.test(segments[segments.length - 1])) {
+			result.format = segments.pop()!;
+		}
+
+		const paramsRe = MODEL_PARAMS_RE;
+		const activatedParamsRe = MODEL_ACTIVATED_PARAMS_RE;
+
+		let paramsIdx = MODEL_ID_NOT_FOUND;
+		let activatedParamsIdx = MODEL_ID_NOT_FOUND;
+
+		for (let i = 0; i < segments.length; i++) {
+			const seg = segments[i];
+			if (paramsIdx === -1 && paramsRe.test(seg)) {
+				paramsIdx = i;
+				result.params = seg.toUpperCase();
+			} else if (activatedParamsRe.test(seg)) {
+				activatedParamsIdx = i;
+				result.activatedParams = seg.toUpperCase();
+			}
+		}
+
+		const pivotIdx = paramsIdx !== MODEL_ID_NOT_FOUND ? paramsIdx : segments.length;
+
+		result.modelName = segments.slice(0, pivotIdx).join(MODEL_ID_SEGMENT_SEPARATOR) || null;
+
+		if (paramsIdx !== MODEL_ID_NOT_FOUND) {
+			result.tags = segments
+				.slice(paramsIdx + 1)
+				.filter((_, relIdx) => paramsIdx + 1 + relIdx !== activatedParamsIdx);
+		}
+
+		return result;
+	}
+}

models.ts

@@ -0,0 +1,243 @@
+/*
+ * The version of the OpenAPI document: v68
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit this class manually.
+ */
+
+
+export * from './address';
+export * from './amount';
+export * from './bankAccount';
+export * from './card';
+export * from './fraudCheckResult';
+export * from './fraudCheckResultWrapper';
+export * from './fraudResult';
+export * from './fundSource';
+export * from './modifyRequest';
+export * from './modifyResponse';
+export * from './name';
+export * from './payoutRequest';
+export * from './payoutResponse';
+export * from './recurring';
+export * from './responseAdditionalData3DSecure';
+export * from './responseAdditionalDataBillingAddress';
+export * from './responseAdditionalDataCard';
+export * from './responseAdditionalDataCommon';
+export * from './responseAdditionalDataDomesticError';
+export * from './responseAdditionalDataInstallments';
+export * from './responseAdditionalDataNetworkTokens';
+export * from './responseAdditionalDataOpi';
+export * from './responseAdditionalDataSepa';
+export * from './serviceError';
+export * from './storeDetailAndSubmitRequest';
+export * from './storeDetailAndSubmitResponse';
+export * from './storeDetailRequest';
+export * from './storeDetailResponse';
+export * from './submitRequest';
+export * from './submitResponse';
+
+
+import { Address } from './address';
+import { Amount } from './amount';
+import { BankAccount } from './bankAccount';
+import { Card } from './card';
+import { FraudCheckResult } from './fraudCheckResult';
+import { FraudCheckResultWrapper } from './fraudCheckResultWrapper';
+import { FraudResult } from './fraudResult';
+import { FundSource } from './fundSource';
+import { ModifyRequest } from './modifyRequest';
+import { ModifyResponse } from './modifyResponse';
+import { Name } from './name';
+import { PayoutRequest } from './payoutRequest';
+import { PayoutResponse } from './payoutResponse';
+import { Recurring } from './recurring';
+import { ResponseAdditionalData3DSecure } from './responseAdditionalData3DSecure';
+import { ResponseAdditionalDataBillingAddress } from './responseAdditionalDataBillingAddress';
+import { ResponseAdditionalDataCard } from './responseAdditionalDataCard';
+import { ResponseAdditionalDataCommon } from './responseAdditionalDataCommon';
+import { ResponseAdditionalDataDomesticError } from './responseAdditionalDataDomesticError';
+import { ResponseAdditionalDataInstallments } from './responseAdditionalDataInstallments';
+import { ResponseAdditionalDataNetworkTokens } from './responseAdditionalDataNetworkTokens';
+import { ResponseAdditionalDataOpi } from './responseAdditionalDataOpi';
+import { ResponseAdditionalDataSepa } from './responseAdditionalDataSepa';
+import { ServiceError } from './serviceError';
+import { StoreDetailAndSubmitRequest } from './storeDetailAndSubmitRequest';
+import { StoreDetailAndSubmitResponse } from './storeDetailAndSubmitResponse';
+import { StoreDetailRequest } from './storeDetailRequest';
+import { StoreDetailResponse } from './storeDetailResponse';
+import { SubmitRequest } from './submitRequest';
+import { SubmitResponse } from './submitResponse';
+
+/* tslint:disable:no-unused-variable */
+let primitives = [
+                    "string",
+                    "boolean",
+                    "double",
+                    "integer",
+                    "long",
+                    "float",
+                    "number",
+                    "any"
+                 ];
+
+let enumsMap: {[index: string]: any} = {
+        "PayoutRequest.ShopperInteractionEnum": PayoutRequest.ShopperInteractionEnum,
+        "PayoutResponse.ResultCodeEnum": PayoutResponse.ResultCodeEnum,
+        "Recurring.ContractEnum": Recurring.ContractEnum,
+        "Recurring.TokenServiceEnum": Recurring.TokenServiceEnum,
+        "ResponseAdditionalDataCommon.FraudResultTypeEnum": ResponseAdditionalDataCommon.FraudResultTypeEnum,
+        "ResponseAdditionalDataCommon.RecurringProcessingModelEnum": ResponseAdditionalDataCommon.RecurringProcessingModelEnum,
+        "StoreDetailAndSubmitRequest.EntityTypeEnum": StoreDetailAndSubmitRequest.EntityTypeEnum,
+        "StoreDetailRequest.EntityTypeEnum": StoreDetailRequest.EntityTypeEnum,
+        "SubmitRequest.EntityTypeEnum": SubmitRequest.EntityTypeEnum,
+}
+
+let typeMap: {[index: string]: any} = {
+    "Address": Address,
+    "Amount": Amount,
+    "BankAccount": BankAccount,
+    "Card": Card,
+    "FraudCheckResult": FraudCheckResult,
+    "FraudCheckResultWrapper": FraudCheckResultWrapper,
+    "FraudResult": FraudResult,
+    "FundSource": FundSource,
+    "ModifyRequest": ModifyRequest,
+    "ModifyResponse": ModifyResponse,
+    "Name": Name,
+    "PayoutRequest": PayoutRequest,
+    "PayoutResponse": PayoutResponse,
+    "Recurring": Recurring,
+    "ResponseAdditionalData3DSecure": ResponseAdditionalData3DSecure,
+    "ResponseAdditionalDataBillingAddress": ResponseAdditionalDataBillingAddress,
+    "ResponseAdditionalDataCard": ResponseAdditionalDataCard,
+    "ResponseAdditionalDataCommon": ResponseAdditionalDataCommon,
+    "ResponseAdditionalDataDomesticError": ResponseAdditionalDataDomesticError,
+    "ResponseAdditionalDataInstallments": ResponseAdditionalDataInstallments,
+    "ResponseAdditionalDataNetworkTokens": ResponseAdditionalDataNetworkTokens,
+    "ResponseAdditionalDataOpi": ResponseAdditionalDataOpi,
+    "ResponseAdditionalDataSepa": ResponseAdditionalDataSepa,
+    "ServiceError": ServiceError,
+    "StoreDetailAndSubmitRequest": StoreDetailAndSubmitRequest,
+    "StoreDetailAndSubmitResponse": StoreDetailAndSubmitResponse,
+    "StoreDetailRequest": StoreDetailRequest,
+    "StoreDetailResponse": StoreDetailResponse,
+    "SubmitRequest": SubmitRequest,
+    "SubmitResponse": SubmitResponse,
+}
+
+export class ObjectSerializer {
+    public static findCorrectType(data: any, expectedType: string) {
+        if (data == undefined) {
+            return expectedType;
+        } else if (primitives.indexOf(expectedType.toLowerCase()) !== -1) {
+            return expectedType;
+        } else if (expectedType === "Date") {
+            return expectedType;
+        } else {
+            if (enumsMap[expectedType]) {
+                return expectedType;
+            }
+
+            if (!typeMap[expectedType]) {
+                return expectedType; // w/e we don't know the type
+            }
+
+            // Check the discriminator
+            let discriminatorProperty = typeMap[expectedType].discriminator;
+            if (discriminatorProperty == null) {
+                return expectedType; // the type does not have a discriminator. use it.
+            } else {
+                if (data[discriminatorProperty]) {
+                    var discriminatorType = data[discriminatorProperty];
+                    if(typeMap[discriminatorType]){
+                        return discriminatorType; // use the type given in the discriminator
+                    } else {
+                        return expectedType; // discriminator did not map to a type
+                    }
+                } else {
+                    return expectedType; // discriminator was not present (or an empty string)
+                }
+            }
+        }
+    }
+
+    public static serialize(data: any, type: string) {
+        if (data == undefined) {
+            return data;
+        } else if (primitives.indexOf(type.toLowerCase()) !== -1) {
+            return data;
+        } else if (type.lastIndexOf("Array<", 0) === 0) { // string.startsWith pre es6
+            let subType: string = type.replace("Array<", ""); // Array<Type> => Type>
+            subType = subType.substring(0, subType.length - 1); // Type> => Type
+            let transformedData: any[] = [];
+            for (let index = 0; index < data.length; index++) {
+                let datum = data[index];
+                transformedData.push(ObjectSerializer.serialize(datum, subType));
+            }
+            return transformedData;
+        } else if (type === "Date") {
+            return data.toISOString();
+        } else if (type === "SaleToAcquirerData") {
+            const dataString = JSON.stringify(data);
+            return Buffer.from(dataString).toString("base64");
+        } else {
+            if (enumsMap[type]) {
+                return data;
+            }
+            if (!typeMap[type]) { // in case we dont know the type
+                return data;
+            }
+
+            // Get the actual type of this object
+            type = this.findCorrectType(data, type);
+
+            // get the map for the correct type.
+            let attributeTypes = typeMap[type].getAttributeTypeMap();
+            let instance: {[index: string]: any} = {};
+            for (let index = 0; index < attributeTypes.length; index++) {
+                let attributeType = attributeTypes[index];
+                instance[attributeType.baseName] = ObjectSerializer.serialize(data[attributeType.name], attributeType.type);
+            }
+            return instance;
+        }
+    }
+
+    public static deserialize(data: any, type: string) {
+        // polymorphism may change the actual type.
+        type = ObjectSerializer.findCorrectType(data, type);
+        if (data == undefined) {
+            return data;
+        } else if (primitives.indexOf(type.toLowerCase()) !== -1) {
+            return data;
+        } else if (type.lastIndexOf("Array<", 0) === 0) { // string.startsWith pre es6
+            let subType: string = type.replace("Array<", ""); // Array<Type> => Type>
+            subType = subType.substring(0, subType.length - 1); // Type> => Type
+            let transformedData: any[] = [];
+            for (let index = 0; index < data.length; index++) {
+                let datum = data[index];
+                transformedData.push(ObjectSerializer.deserialize(datum, subType));
+            }
+            return transformedData;
+        } else if (type === "Date") {
+            return new Date(data);
+        } else {
+            if (enumsMap[type]) {// is Enum
+                return data;
+            }
+
+            if (!typeMap[type]) { // dont know the type
+                return data;
+            }
+            let instance = new typeMap[type]();
+            let attributeTypes = typeMap[type].getAttributeTypeMap();
+            for (let index = 0; index < attributeTypes.length; index++) {
+                let attributeType = attributeTypes[index];
+                instance[attributeType.name] = ObjectSerializer.deserialize(data[attributeType.baseName], attributeType.type);
+            }
+            return instance;
+        }
+    }
+}