chat-agent-toolkit 1.2.1

package/src/config/mcp-server-registry.ts

@@ -0,0 +1,24 @@
+import { configManager } from "./index";
+import type { ConfigModelProvider } from "./config-types";
+
+export const getConfiguredModelProviders = (): ConfigModelProvider[] => {
+  return configManager.getConfig("modelProviders", []);
+};
+
+export const getConfiguredModelProviderById = (
+  id: string,
+): ConfigModelProvider | undefined => {
+  return getConfiguredModelProviders().find((p) => p.id === id) ?? undefined;
+};
+
+export const getSearxngURL = () =>
+  configManager.getConfig("search.searxngURL", "");
+
+export const getTavilyApiKey = () =>
+  configManager.getConfig("search.tavilyApiKey", "");
+
+export const getSourceScrapeCount = (): number =>
+  parseInt(configManager.getConfig("search.sourceScrapeCount", "3"), 10) || 3;
+
+export const getSourceScrapeTimeout = (): number =>
+  parseInt(configManager.getConfig("search.sourceScrapeTimeout", "5"), 10) || 5;

package/src/config/model-registry.ts

@@ -0,0 +1,256 @@
+/**
+ * @fileoverview Registry for managing and loading Vercel AI SDK model providers.
+ *
+ * Exposes the full API expected by the app's API routes and chat handler:
+ * - `activeProviders` (sync getter) / `getActiveProviders()`
+ * - `isProviderEnvBased(providerId)`
+ * - `loadChatModel(providerId, modelKey)` — returns an AI SDK `LanguageModel`
+ * - provider/model CRUD passthroughs to {@link configManager}
+ */
+import configManager from "./config-manager";
+import { LANGUAGE_MODELS } from "./language-models-database";
+import { getModelProvidersUIConfigSection } from "./provider-ui-config";
+import type { ConfigModelProvider, Model } from "./config-types";
+
+// Maps a provider UI key to the matching `provider` name in the
+// LANGUAGE_MODELS database (e.g. the "gemini" UI key ↔ "Google" model list).
+const PROVIDER_KEY_TO_DB_NAME: Record<string, string> = {
+  openai: "openai",
+  anthropic: "anthropic",
+  gemini: "google",
+  groq: "groq",
+  deepseek: "deepseek",
+  nvidia: "nvidia",
+  openrouter: "openrouter",
+};
+
+/** Default chat models for a provider type from the LANGUAGE_MODELS database. */
+const getDefaultChatModels = (providerType: string): Model[] => {
+  const dbName = PROVIDER_KEY_TO_DB_NAME[providerType] ?? providerType;
+  const entry = LANGUAGE_MODELS.find(
+    (p) => p.provider.toLowerCase() === dbName.toLowerCase(),
+  );
+  if (!entry?.models) return [];
+  return entry.models.map((m: any) => ({ name: m.name, key: m.id }));
+};
+
+/** Merges default and user-added models, deduplicated by model key. */
+const mergeChatModels = (provider: ConfigModelProvider): Model[] => {
+  const merged = new Map<string, Model>();
+  for (const m of getDefaultChatModels(provider.type)) {
+    merged.set(m.key, m);
+  }
+  for (const m of provider.chatModels || []) {
+    merged.set(m.key, { key: m.key, name: m.name });
+  }
+  return [...merged.values()];
+};
+
+export default class ModelRegistry {
+  /**
+   * Currently configured providers (env-based + user-added).
+   * Sync getter used by the chat handler for logging and lookups.
+   */
+  get activeProviders(): ConfigModelProvider[] {
+    return configManager.getCurrentConfig().modelProviders;
+  }
+
+  /**
+   * Providers with their full chat model lists (defaults merged with
+   * user-added models), shaped for the settings/providers UI.
+   */
+  async getActiveProviders() {
+    return this.activeProviders.map((p) => ({
+      id: p.id,
+      name: p.name,
+      type: p.type,
+      chatModels: mergeChatModels(p),
+    }));
+  }
+
+  /**
+   * Finds a provider by id, falling back to free providers in order:
+   * OpenRouter (no daily limits, best for guests), Groq (fastest, daily limits),
+   * then NVIDIA, then the first configured provider.
+   * Client-side provider ids are config hashes that go stale whenever
+   * server env config changes, so a graceful fallback keeps existing
+   * chat sessions working after a redeploy.
+   */
+  private findProvider(providerId?: string): ConfigModelProvider | undefined {
+    const providers = this.activeProviders;
+    let provider = providers.find((p) => p.id === providerId);
+
+    if (!provider && providers.length > 0) {
+      // Prioritize OpenRouter (no daily limits) over Groq (has daily limits)
+      provider =
+        providers.find((p) => p.name.toLowerCase().includes("openrouter")) ??
+        providers.find((p) => p.name.toLowerCase().includes("groq")) ??
+        providers.find((p) => p.name.toLowerCase().includes("nvidia")) ??
+        providers[0];
+    }
+
+    return provider;
+  }
+
+  /** Whether the resolved provider was configured from environment variables. */
+  isProviderEnvBased(providerId?: string): boolean {
+    return this.findProvider(providerId)?.isEnvBased === true;
+  }
+
+  /**
+   * Instantiates a Vercel AI SDK language model for the given provider and
+   * model key. Falls back to the provider's first/default model when no key
+   * is given. Temperature is a per-call setting in the AI SDK, so callers
+   * pass it to generateText/streamText rather than the model instance.
+   */
+  async loadChatModel(providerId?: string, modelKey?: string): Promise<any> {
+    const provider = this.findProvider(providerId);
+
+    if (!provider) {
+      throw new Error(
+        "No model providers configured. Please add a provider in settings.",
+      );
+    }
+
+    const type = provider.type.toLowerCase();
+    const config = provider.config || {};
+    const apiKey = config.apiKey || "";
+    const availableModels = mergeChatModels(provider);
+    const modelName =
+      modelKey || availableModels[0]?.key || "";
+
+    console.log(
+      `[ModelRegistry] loadChatModel: providerId=${providerId} provider=${provider.name} type=${type} requestedModel=${modelKey ?? "(default)"} resolvedModel=${modelName}`,
+    );
+
+    if (!modelName) {
+      throw new Error(`No chat models available for provider "${provider.name}"`);
+    }
+
+    // Validate that the requested model exists in the provider's model list
+    if (modelKey && !availableModels.some((m) => m.key === modelKey)) {
+      console.warn(
+        `[ModelRegistry] Requested model "${modelKey}" not found in provider "${provider.name}". Available models: ${availableModels.map((m) => m.key).join(", ")}`,
+      );
+      throw new Error(
+        `Model "${modelKey}" is not available for provider "${provider.name}". Please select a different model in Settings.`,
+      );
+    }
+
+    // Validate API key is present
+    if (!apiKey) {
+      throw new Error(
+        `No API key configured for provider "${provider.name}". Please add your API key in Settings → Model Providers.`,
+      );
+    }
+
+    // OpenAI-compatible providers differ only by base URL.
+    const openAICompatibleBaseURLs: Record<string, string> = {
+      openai: "https://api.openai.com/v1",
+      togetherai: "https://api.together.xyz/v1",
+      perplexity: "https://api.perplexity.ai",
+      nvidia: "https://integrate.api.nvidia.com/v1",
+      openrouter: "https://openrouter.ai/api/v1",
+      deepseek: "https://api.deepseek.com",
+      xai: "https://api.x.ai/v1",
+    };
+
+    if (type in openAICompatibleBaseURLs) {
+      const { createOpenAI } = await import("@ai-sdk/openai");
+      return createOpenAI({
+        apiKey,
+        baseURL: config.baseURL || openAICompatibleBaseURLs[type],
+      }).chat(modelName);
+    }
+
+    switch (type) {
+      case "cloudflare": {
+        const { createOpenAI } = await import("@ai-sdk/openai");
+        const [cfApiToken, accountId] = apiKey.split(":");
+        return createOpenAI({
+          apiKey: cfApiToken,
+          baseURL: `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/v1`,
+        }).chat(modelName);
+      }
+      case "groq": {
+        const { createGroq } = await import("@ai-sdk/groq");
+        return createGroq({ apiKey })(modelName);
+      }
+      case "anthropic": {
+        const { createAnthropic } = await import("@ai-sdk/anthropic");
+        return createAnthropic({ apiKey })(modelName);
+      }
+      case "gemini":
+      case "google": {
+        const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+        return createGoogleGenerativeAI({ apiKey })(modelName);
+      }
+      default:
+        throw new Error(`Unsupported provider type: ${type}`);
+    }
+  }
+
+  /**
+   * Registers a new provider. Accepts both `(type, config)` — used by the
+   * providers API route — and `(type, name, config)`.
+   */
+  async addProvider(type: string, nameOrConfig: any, config?: Record<string, any>) {
+    let name: string;
+    let finalConfig: Record<string, any>;
+    if (typeof nameOrConfig === "object" && nameOrConfig !== null && !config) {
+      finalConfig = nameOrConfig;
+      const section = getModelProvidersUIConfigSection().find(
+        (s) => s.key === type,
+      );
+      name = section?.name || type.toUpperCase();
+    } else {
+      name = String(nameOrConfig);
+      finalConfig = config || {};
+    }
+
+    const newProvider = configManager.addModelProvider(type, name, finalConfig);
+    return {
+      ...newProvider,
+      chatModels: getDefaultChatModels(type),
+    };
+  }
+
+  async removeProvider(providerId: string) {
+    configManager.removeModelProvider(providerId);
+  }
+
+  /**
+   * Updates a provider's config. Accepts both `(id, config)` — used by the
+   * providers API route — and `(id, name, config)`.
+   */
+  async updateProvider(providerId: string, nameOrConfig: any, config?: Record<string, any>) {
+    let name: string;
+    let finalConfig: Record<string, any>;
+    if (typeof nameOrConfig === "object" && nameOrConfig !== null && !config) {
+      finalConfig = nameOrConfig;
+      const existing = this.activeProviders.find((p) => p.id === providerId);
+      name = existing?.name || providerId;
+    } else {
+      name = String(nameOrConfig);
+      finalConfig = config || {};
+    }
+
+    const updated = await configManager.updateModelProvider(
+      providerId,
+      name,
+      finalConfig,
+    );
+    return {
+      ...updated,
+      chatModels: mergeChatModels(updated),
+    };
+  }
+
+  async addProviderModel(providerId: string, type: "chat", model: any) {
+    return configManager.addProviderModel(providerId, type, model);
+  }
+
+  async removeProviderModel(providerId: string, type: "chat", modelKey: string) {
+    configManager.removeProviderModel(providerId, type, modelKey);
+  }
+}

package/src/config/model-tester.ts

@@ -0,0 +1,211 @@
+/**
+ * @fileoverview Model availability testing and validation
+ * Tests which models are actually working for a given provider
+ */
+
+import { generateText } from "ai";
+import { createLLMProvider } from "write-language/provider-factory";
+
+export interface ModelTestResult {
+  modelId: string;
+  modelName: string;
+  available: boolean;
+  error?: string;
+  latency?: number;
+  type?: string;
+}
+
+export interface ProviderTestResult {
+  provider: string;
+  totalModels: number;
+  availableModels: ModelTestResult[];
+  unavailableModels: ModelTestResult[];
+  testDuration: number;
+}
+
+/**
+ * Test a single model to see if it's working
+ */
+export async function testModel(
+  provider: string,
+  apiKey: string,
+  modelId: string,
+  modelName: string,
+  modelType: string = "text-generation",
+  timeout: number = 10000
+): Promise<ModelTestResult> {
+  const startTime = Date.now();
+
+  try {
+    // Only test text-generation models
+    if (modelType !== "text-generation") {
+      return {
+        modelId,
+        modelName,
+        available: false,
+        error: `Skipped: ${modelType} models not testable via text generation`,
+        type: modelType,
+      };
+    }
+
+    const model = createLLMProvider(
+      provider.toLowerCase(),
+      apiKey,
+      modelId,
+      0.1
+    );
+
+    if (!model) {
+      return {
+        modelId,
+        modelName,
+        available: false,
+        error: "Provider not supported",
+        type: modelType,
+      };
+    }
+
+    // Create a promise that will timeout
+    const timeoutPromise = new Promise((_, reject) =>
+      setTimeout(() => reject(new Error("Test timeout")), timeout)
+    );
+
+    // Test with a simple prompt
+    const testPromise = generateText({
+      model,
+      prompt: "Reply with just 'OK'",
+      maxTokens: 10,
+    });
+
+    const result = await Promise.race([testPromise, timeoutPromise]) as any;
+
+    const latency = Date.now() - startTime;
+
+    return {
+      modelId,
+      modelName,
+      available: true,
+      latency,
+      type: modelType,
+    };
+  } catch (error: any) {
+    return {
+      modelId,
+      modelName,
+      available: false,
+      error: error.message || String(error),
+      latency: Date.now() - startTime,
+      type: modelType,
+    };
+  }
+}
+
+/**
+ * Test all models for a provider
+ */
+export async function testProviderModels(
+  provider: string,
+  apiKey: string,
+  models: Array<{ id: string; name: string; type?: string; free?: boolean }>,
+  options: {
+    onlyFree?: boolean;
+    concurrency?: number;
+    timeout?: number;
+    onProgress?: (current: number, total: number, modelName: string) => void;
+  } = {}
+): Promise<ProviderTestResult> {
+  const {
+    onlyFree = false,
+    concurrency = 3,
+    timeout = 10000,
+    onProgress,
+  } = options;
+
+  const startTime = Date.now();
+
+  // Filter models
+  let modelsToTest = models;
+  if (onlyFree) {
+    modelsToTest = models.filter((m) => m.free !== false);
+  }
+
+  const results: ModelTestResult[] = [];
+  const queue = [...modelsToTest];
+  let completed = 0;
+
+  // Test models with concurrency control
+  const workers = Array(Math.min(concurrency, modelsToTest.length))
+    .fill(null)
+    .map(async () => {
+      while (queue.length > 0) {
+        const model = queue.shift();
+        if (!model) break;
+
+        const result = await testModel(
+          provider,
+          apiKey,
+          model.id,
+          model.name,
+          model.type || "text-generation",
+          timeout
+        );
+
+        results.push(result);
+        completed++;
+
+        if (onProgress) {
+          onProgress(completed, modelsToTest.length, model.name);
+        }
+      }
+    });
+
+  await Promise.all(workers);
+
+  const availableModels = results.filter((r) => r.available);
+  const unavailableModels = results.filter((r) => !r.available);
+
+  return {
+    provider,
+    totalModels: modelsToTest.length,
+    availableModels,
+    unavailableModels,
+    testDuration: Date.now() - startTime,
+  };
+}
+
+/**
+ * Get only free models from a model list
+ */
+export function getOnlyFreeModels<T extends { free?: boolean }>(
+  models: T[]
+): T[] {
+  return models.filter((m) => m.free === true);
+}
+
+/**
+ * Categorize models by type
+ */
+export function categorizeModelsByType<
+  T extends { type?: string; id: string; name: string }
+>(models: T[]): Record<string, T[]> {
+  const categories: Record<string, T[]> = {
+    "text-generation": [],
+    vision: [],
+    embedding: [],
+    reranker: [],
+    image: [],
+    video: [],
+    audio: [],
+    other: [],
+  };
+
+  for (const model of models) {
+    const type = model.type || "text-generation";
+    if (!categories[type]) {
+      categories[type] = [];
+    }
+    categories[type].push(model);
+  }
+
+  return categories;
+}

package/src/config/model-utils.ts

@@ -0,0 +1,193 @@
+/**
+ * Utility functions for working with AI models
+ */
+
+/**
+ * List of model IDs that are free to use (no per-token cost)
+ * Updated regularly as providers change their pricing
+ */
+export const FREE_MODELS = new Set([
+  // OpenRouter free models
+  "meta-llama/llama-3.3-70b-instruct",
+  "nvidia/llama-3.1-nemotron-70b-instruct",
+  "qwen/qwen-2.5-72b-instruct",
+  "deepseek/deepseek-v3",
+  "deepseek/deepseek-r1",
+  "meta-llama/llama-4-scout-17b-16e-instruct",
+
+  // NVIDIA NIM free tier models
+  "moonshotai/kimi-k2.5",
+  "nvidia/nemotron-nano-12b-v2-vl",
+  "nvidia/llama-nemotron",
+  "qwen/qwen2.5",
+  "meta/llama-4",
+
+  // Groq free tier models
+  "deepseek-r1-distill-llama-70b",
+  "meta-llama/llama-4-maverick-17b-128e-instruct",
+  "meta-llama/llama-4-scout-17b-16e-instruct",
+  "llama-3.3-70b-versatile",
+  "llama-3.3-70b-specdec",
+  "llama-3.2-3b-preview",
+  "llama-3.2-11b-vision-preview",
+  "llama-3.2-90b-vision-preview",
+  "llama-3.1-70b-versatile",
+  "llama-3.1-8b-instant",
+  "mixtral-8x7b-32768",
+
+  // Cloudflare Workers AI (free tier)
+  "llama-4-scout-17b-16e-instruct",
+  "llama-3.3-70b-instruct-fp8-fast",
+  "llama-3.1-8b-instruct-fast",
+  "gemma-3-12b-it",
+  "mistral-small-3.1-24b-instruct",
+  "qwq-32b",
+  "qwen2.5-coder-32b-instruct",
+  "deepseek-r1-distill-qwen-32b",
+]);
+
+/**
+ * Providers that offer free tiers with generous limits
+ */
+export const FREE_TIER_PROVIDERS = new Set([
+  "openrouter", // Free models available
+  "nvidia",     // Free NIM tier
+  "groq",       // Free tier with rate limits
+]);
+
+/**
+ * Check if a model is free to use (no per-token cost)
+ * Note: Free models may have rate limits
+ */
+export function isModelFree(modelId: string): boolean {
+  return FREE_MODELS.has(modelId);
+}
+
+/**
+ * Check if a provider offers a free tier
+ */
+export function hasFreeTier(providerType: string): boolean {
+  return FREE_TIER_PROVIDERS.has(providerType.toLowerCase());
+}
+
+/**
+ * Get a display name for a model with cost indicator
+ * Example: "Llama 3.3 70B (Free)" or "GPT-4o"
+ */
+export function getModelDisplayName(modelName: string, modelId: string): string {
+  const isFree = isModelFree(modelId);
+
+  // If already has "(Free)" in the name, return as-is
+  if (modelName.includes("(Free)")) {
+    return modelName;
+  }
+
+  return isFree ? `${modelName} (Free)` : modelName;
+}
+
+/**
+ * Get provider-specific information
+ */
+export function getProviderInfo(providerType: string): {
+  name: string;
+  hasFreeTier: boolean;
+  signupUrl: string;
+  docsUrl: string;
+} {
+  const type = providerType.toLowerCase();
+
+  const providers: Record<string, any> = {
+    openrouter: {
+      name: "OpenRouter",
+      hasFreeTier: true,
+      signupUrl: "https://openrouter.ai",
+      docsUrl: "https://openrouter.ai/docs",
+    },
+    nvidia: {
+      name: "NVIDIA",
+      hasFreeTier: true,
+      signupUrl: "https://build.nvidia.com",
+      docsUrl: "https://docs.api.nvidia.com/nim/",
+    },
+    groq: {
+      name: "Groq",
+      hasFreeTier: true,
+      signupUrl: "https://console.groq.com",
+      docsUrl: "https://console.groq.com/docs",
+    },
+    anthropic: {
+      name: "Anthropic",
+      hasFreeTier: false,
+      signupUrl: "https://console.anthropic.com",
+      docsUrl: "https://docs.anthropic.com",
+    },
+    openai: {
+      name: "OpenAI",
+      hasFreeTier: false,
+      signupUrl: "https://platform.openai.com",
+      docsUrl: "https://platform.openai.com/docs",
+    },
+    google: {
+      name: "Google Gemini",
+      hasFreeTier: true,
+      signupUrl: "https://aistudio.google.com",
+      docsUrl: "https://ai.google.dev/docs",
+    },
+    gemini: {
+      name: "Google Gemini",
+      hasFreeTier: true,
+      signupUrl: "https://aistudio.google.com",
+      docsUrl: "https://ai.google.dev/docs",
+    },
+    deepseek: {
+      name: "DeepSeek",
+      hasFreeTier: false,
+      signupUrl: "https://platform.deepseek.com",
+      docsUrl: "https://platform.deepseek.com/docs",
+    },
+    cloudflare: {
+      name: "Cloudflare Workers AI",
+      hasFreeTier: true,
+      signupUrl: "https://dash.cloudflare.com",
+      docsUrl: "https://developers.cloudflare.com/workers-ai/",
+    },
+  };
+
+  return providers[type] || {
+    name: providerType,
+    hasFreeTier: false,
+    signupUrl: "",
+    docsUrl: "",
+  };
+}
+
+/**
+ * Get recommended free providers for getting started
+ */
+export function getRecommendedFreeProviders(): Array<{
+  type: string;
+  name: string;
+  reason: string;
+  signupUrl: string;
+}> {
+  return [
+    {
+      type: "openrouter",
+      name: "OpenRouter",
+      reason: "Access to Llama 3.3 70B, Nemotron, and other free models",
+      signupUrl: "https://openrouter.ai",
+    },
+    {
+      type: "groq",
+      name: "Groq",
+      reason: "Ultra-fast inference on Llama models, generous free tier",
+      signupUrl: "https://console.groq.com",
+    },
+    {
+      type: "nvidia",
+      name: "NVIDIA",
+      reason: "Free access to Nemotron and other powerful models",
+      signupUrl: "https://build.nvidia.com",
+    },
+  ];
+}