const { fetchOpenRouterModels } = require("../AiProviders/openRouter");
const {
  fetchOpenRouterEmbeddingModels,
} = require("../EmbeddingEngines/openRouter");
const { fetchApiPieModels } = require("../AiProviders/apipie");
const { perplexityModels } = require("../AiProviders/perplexity");
const { fireworksAiModels } = require("../AiProviders/fireworksAi");
const { ElevenLabsTTS } = require("../TextToSpeech/elevenLabs");
const { fetchNovitaModels } = require("../AiProviders/novita");
const { parseLMStudioBasePath } = require("../AiProviders/lmStudio");
const { parseNvidiaNimBasePath } = require("../AiProviders/nvidiaNim");
const { fetchPPIOModels } = require("../AiProviders/ppio");
const { GeminiLLM } = require("../AiProviders/gemini");
const { fetchCometApiModels } = require("../AiProviders/cometapi");
const { parseFoundryBasePath } = require("../AiProviders/foundry");
const { getDockerModels } = require("../AiProviders/dockerModelRunner");
const { getAllLemonadeModels } = require("../AiProviders/lemonade");

const SUPPORT_CUSTOM_MODELS = [
  "openai",
  "anthropic",
  "localai",
  "ollama",
  "togetherai",
  "fireworksai",
  "nvidia-nim",
  "mistral",
  "perplexity",
  "openrouter",
  "lmstudio",
  "koboldcpp",
  "litellm",
  "elevenlabs-tts",
  "groq",
  "deepseek",
  "apipie",
  "novita",
  "cometapi",
  "xai",
  "gemini",
  "ppio",
  "moonshotai",
  "foundry",
  "cohere",
  "zai",
  "giteeai",
  "docker-model-runner",
  "privatemode",
  "sambanova",
  "lemonade",
  "minimax",
  "cerebras",
  "bedrock",
  "generic-openai",
  // Embedding Engines
  "native-embedder",
  "cohere-embedder",
  "openrouter-embedder",
  "lemonade-embedder",
  // STT Engines
  "openai-stt",
  "deepgram-stt",
  "lemonade-stt",
  "groq-stt",
  // TTS Engines
  "kokoro-tts",
];

async function getCustomModels(
  provider = "",
  apiKey = null,
  basePath = null,
  options = {}
) {
  if (!SUPPORT_CUSTOM_MODELS.includes(provider))
    return { models: [], error: "Invalid provider for custom models" };

  switch (provider) {
    case "openai":
      return await openAiModels(apiKey);
    case "openai-stt":
      return await openAiSttModels(apiKey);
    case "anthropic":
      return await anthropicModels(apiKey);
    case "localai":
      return await localAIModels(basePath, apiKey);
    case "ollama":
      return await ollamaAIModels(basePath, apiKey);
    case "togetherai":
      return await getTogetherAiModels(apiKey);
    case "fireworksai":
      return await getFireworksAiModels(apiKey);
    case "mistral":
      return await getMistralModels(apiKey);
    case "perplexity":
      return await getPerplexityModels();
    case "openrouter":
      return await getOpenRouterModels();
    case "lmstudio":
      return await getLMStudioModels(basePath, apiKey);
    case "koboldcpp":
      return await getKoboldCPPModels(basePath);
    case "litellm":
      return await liteLLMModels(basePath, apiKey);
    case "elevenlabs-tts":
      return await getElevenLabsModels(apiKey);
    case "groq":
      return await getGroqAiModels(apiKey);
    case "deepseek":
      return await getDeepSeekModels(apiKey);
    case "apipie":
      return await getAPIPieModels(apiKey);
    case "novita":
      return await getNovitaModels();
    case "cometapi":
      return await getCometApiModels();
    case "xai":
      return await getXAIModels(apiKey);
    case "nvidia-nim":
      return await getNvidiaNimModels(basePath);
    case "gemini":
      return await getGeminiModels(apiKey);
    case "ppio":
      return await getPPIOModels(apiKey);
    case "moonshotai":
      return await getMoonshotAiModels(apiKey);
    case "foundry":
      return await getFoundryModels(basePath);
    case "cohere":
      return await getCohereModels(apiKey, "chat");
    case "zai":
      return await getZAiModels(apiKey);
    case "native-embedder":
      return await getNativeEmbedderModels();
    case "cohere-embedder":
      return await getCohereModels(apiKey, "embed");
    case "openrouter-embedder":
      return await getOpenRouterEmbeddingModels();
    case "giteeai":
      return await getGiteeAIModels(apiKey);
    case "docker-model-runner":
      return await getDockerModelRunnerModels(basePath);
    case "privatemode":
      return await getPrivatemodeModels(basePath, "generate");
    case "sambanova":
      return await getSambaNovaModels(apiKey);
    case "lemonade":
      return await getLemonadeModels(basePath);
    case "lemonade-stt":
      return await getLemonadeSTTModels(basePath);
    case "lemonade-embedder":
      return await getLemonadeModels(basePath, "embedding");
    case "minimax":
      return await getMinimaxModels(apiKey);
    case "cerebras":
      return await getCerebrasModels();
    case "bedrock":
      return await getBedrockModels(apiKey, options);
    case "generic-openai":
      return await getGenericOpenAiModels(basePath, apiKey);
    case "deepgram-stt":
      return await getDeepgramSTTModels(apiKey);
    case "groq-stt":
      return await getGroqSTTModels(apiKey);
    case "kokoro-tts":
      return await kokoroTtsVoices(basePath, apiKey);
    default:
      return { models: [], error: "Invalid provider for custom models" };
  }
}

async function openAiModels(apiKey = null) {
  const { OpenAI: OpenAIApi } = require("openai");
  const openai = new OpenAIApi({
    apiKey: apiKey || process.env.OPEN_AI_KEY,
  });
  const allModels = await openai.models
    .list()
    .then((results) => results.data)
    .catch((e) => {
      console.error(`OpenAI:listModels`, e.message);
      return [
        {
          name: "gpt-3.5-turbo",
          id: "gpt-3.5-turbo",
          object: "model",
          created: 1677610602,
          owned_by: "openai",
          organization: "OpenAi",
        },
        {
          name: "gpt-4o",
          id: "gpt-4o",
          object: "model",
          created: 1677610602,
          owned_by: "openai",
          organization: "OpenAi",
        },
        {
          name: "gpt-4",
          id: "gpt-4",
          object: "model",
          created: 1687882411,
          owned_by: "openai",
          organization: "OpenAi",
        },
        {
          name: "gpt-4-turbo",
          id: "gpt-4-turbo",
          object: "model",
          created: 1712361441,
          owned_by: "system",
          organization: "OpenAi",
        },
        {
          name: "gpt-4-32k",
          id: "gpt-4-32k",
          object: "model",
          created: 1687979321,
          owned_by: "openai",
          organization: "OpenAi",
        },
        {
          name: "gpt-3.5-turbo-16k",
          id: "gpt-3.5-turbo-16k",
          object: "model",
          created: 1683758102,
          owned_by: "openai-internal",
          organization: "OpenAi",
        },
      ];
    });

  const gpts = allModels
    .filter(
      (model) =>
        (model.id.includes("gpt") && !model.id.startsWith("ft:")) ||
        model.id.startsWith("o") // o1, o1-mini, o3, etc
    )
    .filter(
      (model) =>
        !model.id.includes("vision") &&
        !model.id.includes("instruct") &&
        !model.id.includes("audio") &&
        !model.id.includes("realtime") &&
        !model.id.includes("image") &&
        !model.id.includes("moderation") &&
        !model.id.includes("transcribe")
    )
    .map((model) => {
      return {
        ...model,
        name: model.id,
        organization: "OpenAi",
      };
    });

  const customModels = allModels
    .filter(
      (model) =>
        !model.owned_by.includes("openai") && model.owned_by !== "system"
    )
    .map((model) => {
      return {
        ...model,
        name: model.id,
        organization: "Your Fine-Tunes",
      };
    });

  // Api Key was successful so lets save it for future uses
  if ((gpts.length > 0 || customModels.length > 0) && !!apiKey)
    process.env.OPEN_AI_KEY = apiKey;
  return { models: [...gpts, ...customModels], error: null };
}

async function openAiSttModels(apiKey = null) {
  const fallback = [
    { id: "whisper-1", name: "whisper-1", organization: "OpenAi" },
    {
      id: "gpt-4o-transcribe",
      name: "gpt-4o-transcribe",
      organization: "OpenAi",
    },
    {
      id: "gpt-4o-mini-transcribe",
      name: "gpt-4o-mini-transcribe",
      organization: "OpenAi",
    },
  ];

  const { OpenAI: OpenAIApi } = require("openai");
  const openai = new OpenAIApi({
    apiKey: apiKey || process.env.OPEN_AI_KEY,
  });

  const allModels = await openai.models
    .list()
    .then((results) => results.data)
    .catch((e) => {
      console.error(`OpenAI:listModels (stt)`, e.message);
      return null;
    });

  if (!allModels) return { models: fallback, error: null };

  // The /v1/models response has no category/type field, so we filter by id.
  // Realtime variants use a separate WebSocket API and are not compatible
  // with the audio.transcriptions.create endpoint we use server-side.
  const models = allModels
    .filter(
      (m) =>
        (m.id.includes("whisper") || m.id.includes("transcribe")) &&
        !m.id.includes("realtime")
    )
    .map((m) => ({ ...m, name: m.id, organization: "OpenAi" }));

  return { models: models.length ? models : fallback, error: null };
}

async function anthropicModels(_apiKey = null) {
  const apiKey =
    _apiKey === true
      ? process.env.ANTHROPIC_API_KEY
      : _apiKey || process.env.ANTHROPIC_API_KEY || null;
  const AnthropicAI = require("@anthropic-ai/sdk");
  const anthropic = new AnthropicAI({ apiKey });
  const models = await anthropic.models
    .list()
    .then((results) => results.data)
    .then((models) => {
      return models
        .filter((model) => model.type === "model")
        .map((model) => {
          return {
            id: model.id,
            name: model.display_name,
          };
        });
    })
    .catch((e) => {
      console.error(`Anthropic:listModels`, e.message);
      return [];
    });

  // Api Key was successful so lets save it for future uses
  if (models.length > 0 && !!apiKey) process.env.ANTHROPIC_API_KEY = apiKey;
  return { models, error: null };
}

async function localAIModels(basePath = null, apiKey = null) {
  const { OpenAI: OpenAIApi } = require("openai");
  const openai = new OpenAIApi({
    baseURL: basePath || process.env.LOCAL_AI_BASE_PATH,
    apiKey: apiKey || process.env.LOCAL_AI_API_KEY || null,
  });
  const models = await openai.models
    .list()
    .then((results) => results.data)
    .catch((e) => {
      console.error(`LocalAI:listModels`, e.message);
      return [];
    });

  // Api Key was successful so lets save it for future uses
  if (models.length > 0 && !!apiKey) process.env.LOCAL_AI_API_KEY = apiKey;
  return { models, error: null };
}

async function getGroqAiModels(_apiKey = null) {
  const { OpenAI: OpenAIApi } = require("openai");
  const apiKey =
    _apiKey === true
      ? process.env.GROQ_API_KEY
      : _apiKey || process.env.GROQ_API_KEY || null;
  const openai = new OpenAIApi({
    baseURL: "https://api.groq.com/openai/v1",
    apiKey,
  });
  const models = (
    await openai.models
      .list()
      .then((results) => results.data)
      .catch((e) => {
        console.error(`GroqAi:listModels`, e.message);
        return [];
      })
  ).filter(
    (model) => !model.id.includes("whisper") && !model.id.includes("tool-use")
  );

  // Api Key was successful so lets save it for future uses
  if (models.length > 0 && !!apiKey) process.env.GROQ_API_KEY = apiKey;
  return { models, error: null };
}

async function getGroqSTTModels(_apiKey = null) {
  const { OpenAI: OpenAIApi } = require("openai");
  const apiKey =
    _apiKey === true
      ? process.env.STT_GROQ_API_KEY
      : _apiKey || process.env.STT_GROQ_API_KEY || null;

  const openai = new OpenAIApi({
    baseURL: "https://api.groq.com/openai/v1",
    apiKey,
  });
  const models = (
    await openai.models
      .list()
      .then((results) => results.data)
      .catch((e) => {
        console.error(`GroqSTT:listModels`, e.message);
        return [];
      })
  ).filter((model) => model.id.includes("whisper"));

  // Api Key was successful so lets save it for future uses
  if (models.length > 0 && !!apiKey) process.env.GROQ_STT_API_KEY = apiKey;
  return { models, error: null };
}

async function liteLLMModels(basePath = null, apiKey = null) {
  const { OpenAI: OpenAIApi } = require("openai");
  const openai = new OpenAIApi({
    baseURL: basePath || process.env.LITE_LLM_BASE_PATH,
    apiKey: apiKey || process.env.LITE_LLM_API_KEY || null,
  });
  const models = await openai.models
    .list()
    .then((results) => results.data)
    .catch((e) => {
      console.error(`LiteLLM:listModels`, e.message);
      return [];
    });

  // Api Key was successful so lets save it for future uses
  if (models.length > 0 && !!apiKey) process.env.LITE_LLM_API_KEY = apiKey;
  return { models, error: null };
}

async function getLMStudioModels(basePath = null, _apiKey = null) {
  try {
    const apiKey =
      _apiKey === true
        ? process.env.LMSTUDIO_AUTH_TOKEN
        : _apiKey || process.env.LMSTUDIO_AUTH_TOKEN || null;

    const { OpenAI: OpenAIApi } = require("openai");
    const openai = new OpenAIApi({
      baseURL: parseLMStudioBasePath(
        basePath || process.env.LMSTUDIO_BASE_PATH
      ),
      apiKey: apiKey || null,
    });
    const models = await openai.models
      .list()
      .then((results) => results.data)
      .catch((e) => {
        console.error(`LMStudio:listModels`, e.message);
        return [];
      });

    return { models, error: null };
  } catch (e) {
    console.error(`LMStudio:getLMStudioModels`, e.message);
    return { models: [], error: "Could not fetch LMStudio Models" };
  }
}

async function getKoboldCPPModels(basePath = null) {
  try {
    const { OpenAI: OpenAIApi } = require("openai");
    const openai = new OpenAIApi({
      baseURL: basePath || process.env.KOBOLD_CPP_BASE_PATH,
      apiKey: null,
    });
    const models = await openai.models
      .list()
      .then((results) => results.data)
      .catch((e) => {
        console.error(`KoboldCPP:listModels`, e.message);
        return [];
      });

    return { models, error: null };
  } catch (e) {
    console.error(`KoboldCPP:getKoboldCPPModels`, e.message);
    return { models: [], error: "Could not fetch KoboldCPP Models" };
  }
}

async function ollamaAIModels(basePath = null, _authToken = null) {
  let url;
  try {
    let urlPath = basePath ?? process.env.OLLAMA_BASE_PATH;
    new URL(urlPath);
    if (urlPath.split("").slice(-1)?.[0] === "/")
      throw new Error("BasePath Cannot end in /!");
    url = urlPath;
  } catch {
    return { models: [], error: "Not a valid URL." };
  }

  const authToken = _authToken || process.env.OLLAMA_AUTH_TOKEN || null;
  const headers = authToken ? { Authorization: `Bearer ${authToken}` } : {};
  const models = await fetch(`${url}/api/tags`, { headers: headers })
    .then((res) => {
      if (!res.ok)
        throw new Error(`Could not reach Ollama server! ${res.status}`);
      return res.json();
    })
    .then((data) => data?.models || [])
    .then((models) =>
      models.map((model) => {
        return { id: model.name };
      })
    )
    .catch((e) => {
      console.error(e);
      return [];
    });

  // Api Key was successful so lets save it for future uses
  if (models.length > 0 && !!authToken)
    process.env.OLLAMA_AUTH_TOKEN = authToken;
  return { models, error: null };
}

async function getTogetherAiModels(apiKey = null) {
  const _apiKey =
    apiKey === true
      ? process.env.TOGETHER_AI_API_KEY
      : apiKey || process.env.TOGETHER_AI_API_KEY || null;
  try {
    const { togetherAiModels } = require("../AiProviders/togetherAi");
    const models = await togetherAiModels(_apiKey);
    if (models.length > 0 && !!_apiKey)
      process.env.TOGETHER_AI_API_KEY = _apiKey;
    return { models, error: null };
  } catch (error) {
    console.error("Error in getTogetherAiModels:", error);
    return { models: [], error: "Failed to fetch Together AI models" };
  }
}

async function getFireworksAiModels(apiKey = null) {
  const knownModels = await fireworksAiModels(apiKey);
  if (!Object.keys(knownModels).length === 0)
    return { models: [], error: null };

  const models = Object.values(knownModels).map((model) => {
    return {
      id: model.id,
      organization: model.organization,
      name: model.name,
    };
  });
  return { models, error: null };
}

async function getPerplexityModels() {
  const knownModels = perplexityModels();
  if (!Object.keys(knownModels).length === 0)
    return { models: [], error: null };

  const models = Object.values(knownModels).map((model) => {
    return {
      id: model.id,
      name: model.name,
    };
  });
  return { models, error: null };
}

async function getOpenRouterModels() {
  const knownModels = await fetchOpenRouterModels();
  if (!Object.keys(knownModels).length === 0)
    return { models: [], error: null };

  const models = Object.values(knownModels).map((model) => {
    return {
      id: model.id,
      organization: model.organization,
      name: model.name,
    };
  });
  return { models, error: null };
}

async function getNovitaModels() {
  const knownModels = await fetchNovitaModels();
  if (!Object.keys(knownModels).length === 0)
    return { models: [], error: null };
  const models = Object.values(knownModels).map((model) => {
    return {
      id: model.id,
      organization: model.organization,
      name: model.name,
    };
  });
  return { models, error: null };
}

async function getCometApiModels() {
  const knownModels = await fetchCometApiModels();
  if (!Object.keys(knownModels).length === 0)
    return { models: [], error: null };
  const models = Object.values(knownModels).map((model) => {
    return {
      id: model.id,
      organization: model.organization,
      name: model.name,
    };
  });
  return { models, error: null };
}

async function getAPIPieModels(apiKey = null) {
  const knownModels = await fetchApiPieModels(apiKey);
  if (!Object.keys(knownModels).length === 0)
    return { models: [], error: null };

  const models = Object.values(knownModels)
    .filter((model) => {
      // Filter for chat models
      return (
        model.subtype &&
        (model.subtype.includes("chat") || model.subtype.includes("chatx"))
      );
    })
    .map((model) => {
      return {
        id: model.id,
        organization: model.organization,
        name: model.name,
      };
    });
  return { models, error: null };
}

async function getMistralModels(apiKey = null) {
  const { OpenAI: OpenAIApi } = require("openai");
  const openai = new OpenAIApi({
    apiKey: apiKey || process.env.MISTRAL_API_KEY || null,
    baseURL: "https://api.mistral.ai/v1",
  });
  const models = await openai.models
    .list()
    .then((results) =>
      results.data.filter((model) => !model.id.includes("embed"))
    )
    .catch((e) => {
      console.error(`Mistral:listModels`, e.message);
      return [];
    });

  // Api Key was successful so lets save it for future uses
  if (models.length > 0 && !!apiKey) process.env.MISTRAL_API_KEY = apiKey;
  return { models, error: null };
}

async function getElevenLabsModels(apiKey = null) {
  const models = (await ElevenLabsTTS.voices(apiKey)).map((model) => {
    return {
      id: model.voice_id,
      organization: model.category,
      name: model.name,
    };
  });

  if (models.length === 0) {
    return {
      models: [
        {
          id: "21m00Tcm4TlvDq8ikWAM",
          organization: "premade",
          name: "Rachel (default)",
        },
      ],
      error: null,
    };
  }

  if (models.length > 0 && !!apiKey) process.env.TTS_ELEVEN_LABS_KEY = apiKey;
  return { models, error: null };
}

async function getMinimaxModels(_apiKey = null) {
  const { OpenAI: OpenAIApi } = require("openai");
  const apiKey =
    _apiKey === true
      ? process.env.MINIMAX_API_KEY
      : _apiKey || process.env.MINIMAX_API_KEY || null;
  const openai = new OpenAIApi({
    baseURL: "https://api.minimax.io/v1",
    apiKey,
  });
  const models = await openai.models
    .list()
    .then((results) => results.data)
    .then((models) =>
      models.map((model) => ({
        id: model.id,
        name: model.id,
        organization: model.owned_by || "minimax",
      }))
    )
    .catch((e) => {
      console.error(`Minimax:listModels`, e.message);
      return [
        {
          id: "MiniMax-M2.7",
          name: "MiniMax-M2.7",
          organization: "minimax",
        },
        {
          id: "MiniMax-M2.7-highspeed",
          name: "MiniMax-M2.7-highspeed",
          organization: "minimax",
        },
        {
          id: "MiniMax-M2.5",
          name: "MiniMax-M2.5",
          organization: "minimax",
        },
        {
          id: "MiniMax-M2.5-highspeed",
          name: "MiniMax-M2.5-highspeed",
          organization: "minimax",
        },
        {
          id: "MiniMax-M2.1",
          name: "MiniMax-M2.1",
          organization: "minimax",
        },
        {
          id: "MiniMax-M2.1-highspeed",
          name: "MiniMax-M2.1-highspeed",
          organization: "minimax",
        },
        {
          id: "MiniMax-M2",
          name: "MiniMax-M2",
          organization: "minimax",
        },
      ];
    });

  // Api Key was successful so lets save it for future uses
  if (models.length > 0 && !!apiKey) process.env.MINIMAX_API_KEY = apiKey;
  return { models, error: null };
}

async function getDeepSeekModels(apiKey = null) {
  const { OpenAI: OpenAIApi } = require("openai");
  const openai = new OpenAIApi({
    apiKey: apiKey || process.env.DEEPSEEK_API_KEY,
    baseURL: "https://api.deepseek.com/v1",
  });
  const models = await openai.models
    .list()
    .then((results) => results.data)
    .then((models) =>
      models.map((model) => ({
        id: model.id,
        name: model.id,
        organization: model.owned_by,
      }))
    )
    .catch((e) => {
      console.error(`DeepSeek:listModels`, e.message);
      return [
        {
          id: "deepseek-chat",
          name: "deepseek-chat",
          organization: "deepseek",
        },
        {
          id: "deepseek-reasoner",
          name: "deepseek-reasoner",
          organization: "deepseek",
        },
      ];
    });

  if (models.length > 0 && !!apiKey) process.env.DEEPSEEK_API_KEY = apiKey;
  return { models, error: null };
}

async function getGiteeAIModels() {
  const { giteeAiModels } = require("../AiProviders/giteeai");
  const modelMap = await giteeAiModels();
  if (!Object.keys(modelMap).length === 0) return { models: [], error: null };
  const models = Object.values(modelMap).map((model) => {
    return {
      id: model.id,
      organization: model.organization ?? "GiteeAI",
      name: model.id,
    };
  });
  return { models, error: null };
}

async function getXAIModels(_apiKey = null) {
  const { OpenAI: OpenAIApi } = require("openai");
  const apiKey =
    _apiKey === true
      ? process.env.XAI_LLM_API_KEY
      : _apiKey || process.env.XAI_LLM_API_KEY || null;
  const openai = new OpenAIApi({
    baseURL: "https://api.x.ai/v1",
    apiKey,
  });
  const models = await openai.models
    .list()
    .then((results) => results.data)
    .catch((e) => {
      console.error(`XAI:listModels`, e.message);
      return [
        {
          created: 1725148800,
          id: "grok-beta",
          object: "model",
          owned_by: "xai",
        },
      ];
    });

  // Api Key was successful so lets save it for future uses
  if (models.length > 0 && !!apiKey) process.env.XAI_LLM_API_KEY = apiKey;
  return { models, error: null };
}

async function getNvidiaNimModels(basePath = null) {
  try {
    const { OpenAI: OpenAIApi } = require("openai");
    const openai = new OpenAIApi({
      baseURL: parseNvidiaNimBasePath(
        basePath ?? process.env.NVIDIA_NIM_LLM_BASE_PATH
      ),
      apiKey: null,
    });
    const modelResponse = await openai.models
      .list()
      .then((results) => results.data)
      .catch((e) => {
        throw new Error(e.message);
      });

    const models = modelResponse.map((model) => {
      return {
        id: model.id,
        name: model.id,
        organization: model.owned_by,
      };
    });

    return { models, error: null };
  } catch (e) {
    console.error(`NVIDIA NIM:getNvidiaNimModels`, e.message);
    return { models: [], error: "Could not fetch NVIDIA NIM Models" };
  }
}

async function getGeminiModels(_apiKey = null) {
  const apiKey =
    _apiKey === true
      ? process.env.GEMINI_API_KEY
      : _apiKey || process.env.GEMINI_API_KEY || null;
  const models = await GeminiLLM.fetchModels(apiKey);
  // Api Key was successful so lets save it for future uses
  if (models.length > 0 && !!apiKey) process.env.GEMINI_API_KEY = apiKey;
  return { models, error: null };
}

async function getPPIOModels() {
  const ppioModels = await fetchPPIOModels();
  if (!Object.keys(ppioModels).length === 0) return { models: [], error: null };
  const models = Object.values(ppioModels).map((model) => {
    return {
      id: model.id,
      organization: model.organization,
      name: model.name,
    };
  });
  return { models, error: null };
}

function getNativeEmbedderModels() {
  const { NativeEmbedder } = require("../EmbeddingEngines/native");
  return { models: NativeEmbedder.availableModels(), error: null };
}

async function getMoonshotAiModels(_apiKey = null) {
  const apiKey =
    _apiKey === true
      ? process.env.MOONSHOT_AI_API_KEY
      : _apiKey || process.env.MOONSHOT_AI_API_KEY || null;

  const { OpenAI: OpenAIApi } = require("openai");
  const openai = new OpenAIApi({
    baseURL: "https://api.moonshot.ai/v1",
    apiKey,
  });
  const models = await openai.models
    .list()
    .then((results) => results.data)
    .catch((e) => {
      console.error(`MoonshotAi:listModels`, e.message);
      return [];
    });

  // Api Key was successful so lets save it for future uses
  if (models.length > 0) process.env.MOONSHOT_AI_API_KEY = apiKey;
  return { models, error: null };
}

async function getFoundryModels(basePath = null) {
  try {
    const { OpenAI: OpenAIApi } = require("openai");
    const openai = new OpenAIApi({
      baseURL: parseFoundryBasePath(basePath || process.env.FOUNDRY_BASE_PATH),
      apiKey: null,
    });
    const models = await openai.models
      .list()
      .then((results) =>
        results.data.map((model) => ({
          ...model,
          name: model.id,
        }))
      )
      .catch((e) => {
        console.error(`Foundry:listModels`, e.message);
        return [];
      });

    return { models, error: null };
  } catch (e) {
    console.error(`Foundry:getFoundryModels`, e.message);
    return { models: [], error: "Could not fetch Foundry Models" };
  }
}

/**
 * Get Cohere models
 * @param {string} _apiKey - The API key to use
 * @param {'chat' | 'embed'} type - The type of model to get
 * @returns {Promise<{models: Array<{id: string, organization: string, name: string}>, error: string | null}>}
 */
async function getCohereModels(_apiKey = null, type = "chat") {
  const apiKey =
    _apiKey === true
      ? process.env.COHERE_API_KEY
      : _apiKey || process.env.COHERE_API_KEY || null;

  // Cohere's models endpoint is queried directly so we can keep filtering by
  // endpoint (chat/embed) which the OpenAI-compatible /models route does not support.
  const models = await fetch(
    `https://api.cohere.com/v1/models?page_size=1000&endpoint=${type}`,
    {
      method: "GET",
      headers: { Authorization: `Bearer ${apiKey}` },
    }
  )
    .then((res) => res.json())
    .then((data) => data?.models || [])
    .then((models) =>
      models.map((model) => ({
        id: model.name,
        name: model.name,
      }))
    )
    .catch((e) => {
      console.error(`Cohere:listModels`, e.message);
      return [];
    });

  return { models, error: null };
}

async function getZAiModels(_apiKey = null) {
  const { OpenAI: OpenAIApi } = require("openai");
  const apiKey =
    _apiKey === true
      ? process.env.ZAI_API_KEY
      : _apiKey || process.env.ZAI_API_KEY || null;
  const openai = new OpenAIApi({
    baseURL: "https://api.z.ai/api/paas/v4",
    apiKey,
  });
  const models = await openai.models
    .list()
    .then((results) => results.data)
    .catch((e) => {
      console.error(`Z.AI:listModels`, e.message);
      return [];
    });

  // Api Key was successful so lets save it for future uses
  if (models.length > 0 && !!apiKey) process.env.ZAI_API_KEY = apiKey;
  return { models, error: null };
}

async function getOpenRouterEmbeddingModels() {
  const knownModels = await fetchOpenRouterEmbeddingModels();
  if (!Object.keys(knownModels).length === 0)
    return { models: [], error: null };

  const models = Object.values(knownModels).map((model) => {
    return {
      id: model.id,
      organization: model.organization,
      name: model.name,
    };
  });
  return { models, error: null };
}

async function getDockerModelRunnerModels(basePath = null) {
  try {
    const models = await getDockerModels(basePath);
    return { models, error: null };
  } catch (e) {
    console.error(`DockerModelRunner:getDockerModelRunnerModels`, e.message);
    return {
      models: [],
      error: "Could not fetch Docker Model Runner Models",
    };
  }
}

async function getLemonadeModels(basePath = null, task = "chat") {
  try {
    const models = await getAllLemonadeModels(basePath, task);
    return { models, error: null };
  } catch (e) {
    console.error(`Lemonade:getLemonadeModels`, e.message);
    return { models: [], error: "Could not fetch Lemonade Models" };
  }
}

async function getLemonadeSTTModels(basePath = null) {
  try {
    const models = await getAllLemonadeModels(basePath, "transcription");
    return { models, error: null };
  } catch (e) {
    console.error(`Lemonade:getLemonadeSTTModels`, e.message);
    return { models: [], error: "Could not fetch Lemonade STT Models" };
  }
}

/**
 * Get Deepgram STT models from the Management API.
 * https://api.deepgram.com/v1/models returns { stt: [...], tts: [...] }.
 * @param {string} _apiKey - Deepgram API key. Falls back to STT_DEEPGRAM_API_KEY.
 * @returns {Promise<{models: Array<{id: string, name: string, organization: string}>, error: string | null}>}
 */
async function getDeepgramSTTModels(_apiKey = null) {
  const apiKey =
    _apiKey === true
      ? process.env.STT_DEEPGRAM_API_KEY
      : _apiKey || process.env.STT_DEEPGRAM_API_KEY || null;
  if (!apiKey)
    return { models: [], error: "No Deepgram API key was provided." };

  try {
    const response = await fetch("https://api.deepgram.com/v1/models", {
      method: "GET",
      headers: { Authorization: `Token ${apiKey}` },
    });
    if (!response.ok) throw new Error(`Deepgram returned ${response.status}`);

    let models = new Map();
    const data = await response.json();
    (data?.stt ?? [])
      .filter((m) => m.batch !== false)
      .forEach((m) => {
        if (models.has(m.canonical_name)) return;
        models.set(m.canonical_name, {
          id: m.canonical_name,
          name: m.canonical_name,
          organization: "Deepgram",
        });
      });

    models = Array.from(models.values());
    // Api Key was successful so lets save it for future uses
    if (models.length > 0 && _apiKey) process.env.STT_DEEPGRAM_API_KEY = apiKey;
    return { models, error: null };
  } catch (e) {
    console.error(`Deepgram:getDeepgramSTTModels`, e.message);
    return { models: [], error: "Could not fetch Deepgram STT models" };
  }
}

/**
 * Get Privatemode models
 * @param {string} basePath - The base path of the Privatemode endpoint.
 * @param {'any' | 'generate' | 'embed' | 'transcribe'} task - The task to fetch the models for.
 * @returns {Promise<{models: Array<{id: string, organization: string, name: string}>, error: string | null}>}
 */
async function getPrivatemodeModels(basePath = null, task = "any") {
  try {
    const { PrivatemodeLLM } = require("../AiProviders/privatemode");
    const { OpenAI: OpenAIApi } = require("openai");
    const openai = new OpenAIApi({
      baseURL: PrivatemodeLLM.parseBasePath(
        basePath || process.env.PRIVATEMODE_LLM_BASE_PATH
      ),
      apiKey: null,
    });
    const models = await openai.models
      .list()
      .then((results) => results.data)
      .then(
        (models) =>
          models
            .filter((model) => !model.id.includes("/")) // remove legacy prefixed models
            .filter((model) =>
              task === "any" ? true : model.tasks.includes(task)
            ) // filter by task or show all if task is any
      )
      .then((models) =>
        models.map((model) => ({
          id: model.id,
          organization: "Privatemode",
          name: model.id
            .split("-")
            .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
            .join(" "),
        }))
      )
      .catch((e) => {
        console.error(`Privatemode:listModels`, e.message);
        return [];
      });
    return { models, error: null };
  } catch (e) {
    console.error(`Privatemode:getPrivatemodeModels`, e.message);
    return { models: [], error: "Could not fetch Privatemode Models" };
  }
}

/**
 * Get SambaNova models
 * @param {string} _apiKey - The API key to use
 * @returns {Promise<{models: Array<{id: string, organization: string, name: string}>, error: string | null}>}
 */
async function getSambaNovaModels(_apiKey = null) {
  try {
    const apiKey =
      _apiKey === true
        ? process.env.SAMBANOVA_LLM_API_KEY
        : _apiKey || process.env.SAMBANOVA_LLM_API_KEY || null;
    const { OpenAI: OpenAIApi } = require("openai");
    const openai = new OpenAIApi({
      baseURL: "https://api.sambanova.ai/v1",
      apiKey,
    });
    const models = await openai.models
      .list()
      .then((results) => results.data)
      .then((models) =>
        models.filter((model) => !model.id.toLowerCase().startsWith("whisper"))
      )
      .then((models) =>
        models.map((model) => {
          const organization =
            model.hasOwnProperty("owned_by") &&
            model.owned_by !== "no-reply@sambanova.ai"
              ? model.owned_by
              : "SambaNova";
          return {
            id: model.id,
            organization,
            name: model.id,
          };
        })
      )
      .catch((e) => {
        console.error(`SambaNova:listModels`, e.message);
        return [];
      });
    return { models, error: null };
  } catch (e) {
    console.error(`SambaNova:getSambaNovaModels`, e.message);
    return { models: [], error: "Could not fetch SambaNova Models" };
  }
}

/**
 * Use the Cerebras PUBLIC API to fetch the public models
 * @returns {Promise<{models: Array<{id: string, organization: string, name: string}>, error: string | null}>}
 */
async function getCerebrasModels() {
  try {
    const models = await fetch("https://api.cerebras.ai/public/v1/models")
      .then((response) => response.json())
      .then(({ data = [] }) => {
        return data.map((model) => ({
          id: model.id,
          name: model.name,
          organization: model.owned_by ?? "Cerebras",
        }));
      })
      .catch((error) => {
        console.error(`Cerebras:listModels`, error.message);
        return [];
      });
    return { models, error: null };
  } catch (e) {
    console.error(`Cerebras:getCerebrasModels`, e.message);
    return { models: [], error: "Could not fetch Cerebras Models" };
  }
}

async function getGenericOpenAiModels(basePath = null, apiKey = null) {
  try {
    const { OpenAI: OpenAIApi } = require("openai");
    const openai = new OpenAIApi({
      baseURL: basePath || process.env.GENERIC_OPEN_AI_BASE_PATH,
      apiKey: apiKey || process.env.GENERIC_OPEN_AI_API_KEY || null,
    });
    const models = await openai.models
      .list()
      .then((results) => results.data)
      .then((models) =>
        models.map((model) => ({
          id: model.id,
          name: model.id,
          organization: model.owned_by ?? "generic-openai",
        }))
      )
      .catch((e) => {
        console.error(`GenericOpenAI:listModels`, e.message);
        return [];
      });

    if (models.length > 0 && !!apiKey)
      process.env.GENERIC_OPEN_AI_API_KEY = apiKey;
    return { models, error: null };
  } catch (e) {
    console.error(`GenericOpenAI:getGenericOpenAiModels`, e.message);
    return { models: [], error: "Could not fetch Generic OpenAI Models" };
  }
}

/**
 * Pulls the live voice list from a self-hosted kokoro-fastapi server's
 * /audio/voices endpoint. basePath is the OpenAI-compatible base URL the
 * user pointed at their kokoro instance (e.g. http://localhost:8880/v1).
 * @param {string} basePath - The base path to the Kokoro instance.
 * @param {string} apiKey - The API key to use.
 * @returns {Promise<{models: Array<{id: string, organization: string, name: string}>, error: string | null}>}
 */
async function kokoroTtsVoices(basePath = null, apiKey = null) {
  let endpoint = basePath || process.env.TTS_KOKORO_ENDPOINT;
  if (!endpoint)
    return { models: [], error: "No Kokoro endpoint was provided." };

  endpoint = new URL(endpoint);
  endpoint.pathname = "/v1/audio/voices";
  const headers = { "Content-Type": "application/json" };
  const key = typeof apiKey === "boolean" ? null : apiKey;
  if (key) headers.Authorization = `Bearer ${key}`;

  const voices = await fetch(endpoint.toString(), { method: "GET", headers })
    .then((res) => {
      if (!res.ok) throw new Error(res.statusText || "Failed to load voices");
      return res.json();
    })
    .then((data) => (Array.isArray(data?.voices) ? data.voices : []))
    .catch((e) => {
      console.error(`Kokoro:listVoices`, e.message);
      return null;
    });

  if (!voices || !Array.isArray(voices))
    return { models: [], error: "Could not fetch Kokoro voices." };

  // kokoro-fastapi < 0.3.x returns voices as plain id strings while >= 0.3.x
  // returns { id, name } objects. Normalize both shapes to { id, name } so the
  // voice list renders regardless of the kokoro-fastapi version being used.
  const models = voices
    .map((voice) => {
      if (typeof voice === "string")
        return { id: voice, name: voice, organization: "Kokoro" };
      if (voice && typeof voice === "object" && voice.id)
        return {
          id: voice.id,
          name: voice.name || voice.id,
          organization: "Kokoro",
        };
      return null;
    })
    .filter(Boolean);
  return { models, error: null };
}

/**
 * Get AWS Bedrock models
 * @param {string} _apiKey - The API key to use
 * @param {Object} options - The options to use
 * @param {string} [options.region] - The region to use
 * @returns {Promise<{models: Array<{id: string, organization: string, name: string}>, error: string | null}>}
 */
async function getBedrockModels(_apiKey = null, options = {}) {
  try {
    const apiKey =
      _apiKey === true
        ? process.env.AWS_BEDROCK_LLM_API_KEY
        : _apiKey || process.env.AWS_BEDROCK_LLM_API_KEY || null;
    const region =
      options?.region || process.env.AWS_BEDROCK_LLM_REGION || "us-west-2";

    const { OpenAI: OpenAIApi } = require("openai");
    const openai = new OpenAIApi({
      apiKey,
      baseURL: `https://bedrock-mantle.${region}.api.aws/v1`,
    });
    const models = await openai.models
      .list()
      .then((results) => results.data)
      .then((models) =>
        models.map((model) => ({
          id: model.id,
          name: model.id,
          organization: model.owned_by ?? "AWS Bedrock",
        }))
      )
      .catch((e) => {
        console.error(`AWSBedrock:listModels`, e.message);
        return [];
      });

    if (models.length > 0 && !!apiKey)
      process.env.AWS_BEDROCK_LLM_API_KEY = apiKey;
    return { models, error: null };
  } catch (e) {
    console.error(`AWSBedrock:getBedrockModels`, e.message);
    return { models: [], error: "Could not fetch AWS Bedrock Models" };
  }
}

module.exports = {
  getCustomModels,
  SUPPORT_CUSTOM_MODELS,
};