zevairouter 1.0.154 → 1.0.155

package/src/app/api/media-providers/tts/voices/route.js

@@ -1,99 +0,0 @@
-import { VOICE_FETCHERS } from "open-sse/handlers/ttsCore.js";
-import { NextResponse } from "next/server";
-
-// Map locale code → country name
-const LOCALE_NAMES = new Intl.DisplayNames(["en"], { type: "region" });
-const LANG_NAMES   = new Intl.DisplayNames(["en"], { type: "language" });
-
-function countryName(code) {
-  try { return LOCALE_NAMES.of(code); } catch { return code; }
-}
-function langName(code) {
-  try { return LANG_NAMES.of(code); } catch { return code; }
-}
-
-/**
- * GET /api/media-providers/tts/voices
- * Query:
- *   ?provider=edge-tts | local-device | elevenlabs  (default: edge-tts)
- *   ?lang=en     (optional filter by lang code)
- *   ?apiKey=xxx  (required for elevenlabs)
- */
-export async function GET(request) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const provider   = searchParams.get("provider") || "edge-tts";
-    const langFilter = searchParams.get("lang");
-    const apiKey     = searchParams.get("apiKey");
-
-    const fetcher = VOICE_FETCHERS[provider];
-    if (!fetcher) {
-      return NextResponse.json({ error: `Provider '${provider}' does not support voice listing` }, { status: 400 });
-    }
-
-    // ElevenLabs requires API key
-    const raw = provider === "elevenlabs" ? await fetcher(apiKey) : await fetcher();
-    const useElevenShape = provider === "elevenlabs" || provider === "gemini";
-    let voices;
-
-    if (provider === "local-device") {
-      voices = raw.map((v) => ({
-        id:      v.id,
-        name:    v.name,
-        locale:  v.locale.replace("_", "-"),
-        lang:    v.lang,
-        country: v.country,
-        countryName: countryName(v.country),
-        langName:    langName(v.lang),
-        gender:  v.gender,
-      }));
-    } else if (useElevenShape) {
-      voices = raw.map((v) => ({
-        id:      v.voice_id,
-        name:    v.name,
-        locale:  v.labels?.language || "en",
-        lang:    (v.labels?.language || "en").split("-")[0],
-        country: "",
-        countryName: "",
-        langName:    langName((v.labels?.language || "en").split("-")[0]),
-        gender:  v.labels?.gender || "",
-        category: v.category,
-      }));
-    } else {
-      // edge-tts (default)
-      voices = raw.map((v) => {
-        const [lang, country] = v.Locale.split("-");
-        return {
-          id:      v.ShortName,
-          name:    (v.FriendlyName || v.ShortName)
-            .replace("Microsoft ", "")
-            .replace(/ Online \(Natural\) - /g, " ("),
-          locale:  v.Locale,
-          lang,
-          country: country || "",
-          countryName: countryName(country || lang),
-          langName:    langName(lang),
-          gender:  v.Gender,
-        };
-      });
-    }
-
-    // Apply filter
-    if (langFilter) voices = voices.filter((v) => v.lang === langFilter);
-
-    // Group by language
-    const byLang = {};
-    for (const v of voices) {
-      const key = v.lang;
-      if (!byLang[key]) byLang[key] = { code: key, name: v.langName, voices: [] };
-      byLang[key].voices.push(v);
-    }
-
-    // Sorted language list
-    const languages = Object.values(byLang).sort((a, b) => a.name.localeCompare(b.name));
-
-    return NextResponse.json({ voices, languages, byLang });
-  } catch (err) {
-    return NextResponse.json({ error: err.message || "Failed to fetch voices" }, { status: 502 });
-  }
-}

package/src/app/api/metrics/route.js

@@ -1,33 +0,0 @@
-import { getActiveRequests, getProviderConnections, getUsageStats } from "@/lib/db/index.js";
-import { responseCache } from "@/lib/responseCache.js";
-
-function metric(name, help, type, value) {
-  return `# HELP ${name} ${help}\n# TYPE ${name} ${type}\n${name} ${Number(value) || 0}\n`;
-}
-
-export async function GET() {
-  const [stats, requestActivity, connections] = await Promise.all([
-    getUsageStats("all"),
-    getActiveRequests(),
-    getProviderConnections({ isActive: true }),
-  ]);
-  const cache = responseCache.getStats();
-  const active = (requestActivity.activeRequests || [])
-    .reduce((sum, request) => sum + (request.count || 0), 0);
-
-  const body = [
-    metric("zevai_requests_total", "Completed routed requests.", "counter", stats.totalRequests),
-    metric("zevai_prompt_tokens_total", "Prompt tokens processed.", "counter", stats.totalPromptTokens),
-    metric("zevai_completion_tokens_total", "Completion tokens processed.", "counter", stats.totalCompletionTokens),
-    metric("zevai_cost_total", "Estimated provider cost.", "counter", stats.totalCost),
-    metric("zevai_active_requests", "Requests currently in flight.", "gauge", active),
-    metric("zevai_active_provider_connections", "Configured active provider connections.", "gauge", connections.length),
-    metric("zevai_cache_hits_total", "Response cache hits.", "counter", cache.hits),
-    metric("zevai_cache_misses_total", "Response cache misses.", "counter", cache.misses),
-    metric("zevai_cache_entries", "Responses currently cached.", "gauge", cache.entries),
-  ].join("");
-
-  return new Response(body, {
-    headers: { "Content-Type": "text/plain; version=0.0.4; charset=utf-8" },
-  });
-}

package/src/app/api/models/alias/route.js

@@ -1,53 +0,0 @@
-import { NextResponse } from "next/server";
-import { getModelAliases, setModelAlias, deleteModelAlias } from "@/models";
-
-export const dynamic = "force-dynamic";
-
-// GET /api/models/alias - Get all aliases
-export async function GET() {
-  try {
-    const aliases = await getModelAliases();
-    return NextResponse.json({ aliases });
-  } catch (error) {
-    console.log("Error fetching aliases:", error);
-    return NextResponse.json({ error: "Failed to fetch aliases" }, { status: 500 });
-  }
-}
-
-// PUT /api/models/alias - Set model alias
-export async function PUT(request) {
-  try {
-    const body = await request.json();
-    const { model, alias } = body;
-
-    if (!model || !alias) {
-      return NextResponse.json({ error: "Model and alias required" }, { status: 400 });
-    }
-
-    await setModelAlias(alias, model);
-
-    return NextResponse.json({ success: true, model, alias });
-  } catch (error) {
-    console.log("Error updating alias:", error);
-    return NextResponse.json({ error: "Failed to update alias" }, { status: 500 });
-  }
-}
-
-// DELETE /api/models/alias?alias=xxx - Delete alias
-export async function DELETE(request) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const alias = searchParams.get("alias");
-
-    if (!alias) {
-      return NextResponse.json({ error: "Alias required" }, { status: 400 });
-    }
-
-    await deleteModelAlias(alias);
-
-    return NextResponse.json({ success: true });
-  } catch (error) {
-    console.log("Error deleting alias:", error);
-    return NextResponse.json({ error: "Failed to delete alias" }, { status: 500 });
-  }
-}

package/src/app/api/models/availability/route.js

@@ -1,103 +0,0 @@
-import { NextResponse } from "next/server";
-import {
-  getProviderConnections,
-  updateProviderConnection,
-} from "@/lib/localDb";
-
-const MODEL_LOCK_PREFIX = "modelLock_";
-
-function getActiveModelLocks(connection) {
-  const now = Date.now();
-  return Object.entries(connection)
-    .filter(([key, value]) => key.startsWith(MODEL_LOCK_PREFIX) && value)
-    .map(([key, value]) => ({
-      key,
-      model: key.slice(MODEL_LOCK_PREFIX.length) || "__all",
-      until: value,
-      active: new Date(value).getTime() > now,
-    }))
-    .filter((lock) => lock.active);
-}
-
-export async function GET() {
-  try {
-    const connections = await getProviderConnections();
-    const models = [];
-
-    for (const connection of connections) {
-      const locks = getActiveModelLocks(connection);
-      for (const lock of locks) {
-        models.push({
-          provider: connection.provider,
-          model: lock.model,
-          status: "cooldown",
-          until: lock.until,
-          connectionId: connection.id,
-          connectionName: connection.name || connection.email || connection.id,
-          lastError: connection.lastError || null,
-        });
-      }
-
-      if (locks.length === 0 && connection.testStatus === "unavailable") {
-        models.push({
-          provider: connection.provider,
-          model: "__all",
-          status: "unavailable",
-          connectionId: connection.id,
-          connectionName: connection.name || connection.email || connection.id,
-          lastError: connection.lastError || null,
-        });
-      }
-    }
-
-    return NextResponse.json({
-      models,
-      unavailableCount: models.length,
-    });
-  } catch (error) {
-    console.error("[API] Failed to get model availability:", error);
-    return NextResponse.json(
-      { error: "Failed to fetch model availability" },
-      { status: 500 },
-    );
-  }
-}
-
-export async function POST(request) {
-  try {
-    const { action, provider, model } = await request.json();
-
-    if (action !== "clearCooldown" || !provider || !model) {
-      return NextResponse.json({ error: "Invalid request" }, { status: 400 });
-    }
-
-    const connections = await getProviderConnections({ provider });
-    const lockKey = `${MODEL_LOCK_PREFIX}${model}`;
-
-    await Promise.all(
-      connections
-        .filter((connection) => connection[lockKey])
-        .map((connection) =>
-          updateProviderConnection(connection.id, {
-            [lockKey]: null,
-            ...(connection.testStatus === "unavailable"
-              ? {
-                  testStatus: "active",
-                  lastError: null,
-                  lastErrorAt: null,
-                  backoffLevel: 0,
-                }
-              : {}),
-          }),
-        ),
-    );
-
-    return NextResponse.json({ ok: true });
-  } catch (error) {
-    console.error("[API] Failed to clear model cooldown:", error);
-    return NextResponse.json(
-      { error: "Failed to clear cooldown" },
-      { status: 500 },
-    );
-  }
-}

package/src/app/api/models/custom/route.js

@@ -1,48 +0,0 @@
-import { NextResponse } from "next/server";
-import { getCustomModels, addCustomModel, deleteCustomModel } from "@/models";
-
-export const dynamic = "force-dynamic";
-
-// GET /api/models/custom - List all custom models
-export async function GET() {
-  try {
-    const models = await getCustomModels();
-    return NextResponse.json({ models });
-  } catch (error) {
-    console.log("Error fetching custom models:", error);
-    return NextResponse.json({ error: "Failed to fetch custom models" }, { status: 500 });
-  }
-}
-
-// POST /api/models/custom - Add custom model
-export async function POST(request) {
-  try {
-    const { providerAlias, id, type, name } = await request.json();
-    if (!providerAlias || !id) {
-      return NextResponse.json({ error: "providerAlias and id required" }, { status: 400 });
-    }
-    const added = await addCustomModel({ providerAlias, id, type: type || "llm", name });
-    return NextResponse.json({ success: true, added });
-  } catch (error) {
-    console.log("Error adding custom model:", error);
-    return NextResponse.json({ error: "Failed to add custom model" }, { status: 500 });
-  }
-}
-
-// DELETE /api/models/custom?providerAlias=xxx&id=yyy&type=zzz
-export async function DELETE(request) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const providerAlias = searchParams.get("providerAlias");
-    const id = searchParams.get("id");
-    const type = searchParams.get("type") || "llm";
-    if (!providerAlias || !id) {
-      return NextResponse.json({ error: "providerAlias and id required" }, { status: 400 });
-    }
-    await deleteCustomModel({ providerAlias, id, type });
-    return NextResponse.json({ success: true });
-  } catch (error) {
-    console.log("Error deleting custom model:", error);
-    return NextResponse.json({ error: "Failed to delete custom model" }, { status: 500 });
-  }
-}

package/src/app/api/models/disabled/route.js

@@ -1,50 +0,0 @@
-import { NextResponse } from "next/server";
-import { getDisabledModels, disableModels, enableModels } from "@/lib/disabledModelsDb";
-
-export const dynamic = "force-dynamic";
-
-// GET /api/models/disabled?providerAlias=xxx
-export async function GET(request) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const providerAlias = searchParams.get("providerAlias");
-    const all = await getDisabledModels();
-    if (providerAlias) return NextResponse.json({ ids: all[providerAlias] || [] });
-    return NextResponse.json({ disabled: all });
-  } catch (error) {
-    console.log("Error fetching disabled models:", error);
-    return NextResponse.json({ error: "Failed to fetch disabled models" }, { status: 500 });
-  }
-}
-
-// POST /api/models/disabled  body: { providerAlias, ids: [...] }
-export async function POST(request) {
-  try {
-    const { providerAlias, ids } = await request.json();
-    if (!providerAlias || !Array.isArray(ids)) {
-      return NextResponse.json({ error: "providerAlias and ids[] required" }, { status: 400 });
-    }
-    await disableModels(providerAlias, ids);
-    return NextResponse.json({ success: true });
-  } catch (error) {
-    console.log("Error disabling models:", error);
-    return NextResponse.json({ error: "Failed to disable models" }, { status: 500 });
-  }
-}
-
-// DELETE /api/models/disabled?providerAlias=xxx[&id=yyy]
-export async function DELETE(request) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const providerAlias = searchParams.get("providerAlias");
-    const id = searchParams.get("id");
-    if (!providerAlias) {
-      return NextResponse.json({ error: "providerAlias required" }, { status: 400 });
-    }
-    await enableModels(providerAlias, id ? [id] : []);
-    return NextResponse.json({ success: true });
-  } catch (error) {
-    console.log("Error enabling models:", error);
-    return NextResponse.json({ error: "Failed to enable models" }, { status: 500 });
-  }
-}

package/src/app/api/models/route.js

@@ -1,68 +0,0 @@
-import { NextResponse } from "next/server";
-import { getModelAliases, setModelAlias } from "@/models";
-import { getDisabledModels } from "@/lib/disabledModelsDb";
-import { AI_MODELS } from "@/shared/constants/config";
-import { getProviderAlias } from "@/shared/constants/providers";
-
-// GET /api/models - Get models with aliases
-export async function GET() {
-  try {
-    const modelAliases = await getModelAliases();
-    const disabled = await getDisabledModels();
-
-    const models = AI_MODELS
-      .filter((m) => {
-        const alias = getProviderAlias(m.provider) || m.provider;
-        const list = disabled[alias] || disabled[m.provider] || [];
-        return !list.includes(m.model);
-      })
-      .map((m) => {
-        const fullModel = `${m.provider}/${m.model}`;
-        // alias map shape is { aliasName: "provider/model" } — reverse-lookup the
-        // alias whose VALUE points at this model (model.js:197 resolves aliases[alias]).
-        const alias = Object.keys(modelAliases).find((a) => modelAliases[a] === fullModel) || m.model;
-        return {
-          ...m,
-          fullModel,
-          alias,
-        };
-      });
-
-    return NextResponse.json({ models });
-  } catch (error) {
-    console.log("Error fetching models:", error);
-    return NextResponse.json({ error: "Failed to fetch models" }, { status: 500 });
-  }
-}
-
-// PUT /api/models - Update model alias
-export async function PUT(request) {
-  try {
-    const body = await request.json();
-    const { model, alias } = body;
-
-    if (!model || !alias) {
-      return NextResponse.json({ error: "Model and alias required" }, { status: 400 });
-    }
-
-    const modelAliases = await getModelAliases();
-
-    // alias map shape is { aliasName: "provider/model" }; the alias name is the KEY.
-    // Reject if this alias name is already bound to a *different* model.
-    const existingModel = Object.entries(modelAliases).find(
-      ([key, val]) => key === alias && val !== model
-    );
-
-    if (existingModel) {
-      return NextResponse.json({ error: "Alias already in use" }, { status: 400 });
-    }
-
-    // Update alias — setModelAlias(alias, model)
-    await setModelAlias(alias, model);
-
-    return NextResponse.json({ success: true, model, alias });
-  } catch (error) {
-    console.log("Error updating alias:", error);
-    return NextResponse.json({ error: "Failed to update alias" }, { status: 500 });
-  }
-}

package/src/app/api/models/test/ping.js

@@ -1,191 +0,0 @@
-import { getApiKeys } from "@/lib/localDb";
-import { UPDATER_CONFIG } from "@/shared/constants/config";
-import { getConsistentMachineId } from "@/shared/utils/machineId";
-
-const CLI_TOKEN_SALT = "zevai-cli-auth";
-
-function createSilentWavFile() {
-  const sampleRate = 16000;
-  const channels = 1;
-  const bitsPerSample = 16;
-  const durationMs = 250;
-  const sampleCount = Math.max(1, Math.floor((sampleRate * durationMs) / 1000));
-  const dataSize = sampleCount * channels * (bitsPerSample / 8);
-  const buffer = new ArrayBuffer(44 + dataSize);
-  const view = new DataView(buffer);
-
-  const writeAscii = (offset, value) => {
-    for (let i = 0; i < value.length; i += 1) {
-      view.setUint8(offset + i, value.charCodeAt(i));
-    }
-  };
-
-  writeAscii(0, "RIFF");
-  view.setUint32(4, 36 + dataSize, true);
-  writeAscii(8, "WAVE");
-  writeAscii(12, "fmt ");
-  view.setUint32(16, 16, true);
-  view.setUint16(20, 1, true);
-  view.setUint16(22, channels, true);
-  view.setUint32(24, sampleRate, true);
-  view.setUint32(28, sampleRate * channels * (bitsPerSample / 8), true);
-  view.setUint16(32, channels * (bitsPerSample / 8), true);
-  view.setUint16(34, bitsPerSample, true);
-  writeAscii(36, "data");
-  view.setUint32(40, dataSize, true);
-
-  return new Blob([buffer], { type: "audio/wav" });
-}
-
-async function getInternalHeaders() {
-  let apiKey = null;
-  try {
-    const keys = await getApiKeys(true);
-    apiKey = keys.find((k) => k.isActive !== false)?.key || null;
-  } catch {}
-
-  const headers = { "Content-Type": "application/json" };
-  if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
-  headers["x-zevai-cli-token"] = await getConsistentMachineId(CLI_TOKEN_SALT);
-  return headers;
-}
-
-export async function pingModelByKind(model, kind, baseUrl = `http://127.0.0.1:${process.env.PORT || UPDATER_CONFIG.appPort}`) {
-  const headers = await getInternalHeaders();
-  const start = Date.now();
-
-  if (kind === "embedding") {
-    const res = await fetch(`${baseUrl}/api/v1/embeddings`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({ model, input: "test" }),
-      signal: AbortSignal.timeout(15000),
-    });
-    const latencyMs = Date.now() - start;
-    const rawText = await res.text().catch(() => "");
-    let parsed = null;
-    try { parsed = rawText ? JSON.parse(rawText) : null; } catch {}
-
-    if (!res.ok) {
-      const detail = parsed?.error?.message || parsed?.error || rawText;
-      return { ok: false, latencyMs, error: `HTTP ${res.status}${detail ? `: ${String(detail).slice(0, 240)}` : ""}`, status: res.status };
-    }
-    const hasEmbedding = Array.isArray(parsed?.data) && parsed.data.length > 0 && Array.isArray(parsed.data[0]?.embedding);
-    if (!hasEmbedding) {
-      return { ok: false, latencyMs, status: res.status, error: "Provider returned no embedding data" };
-    }
-    return { ok: true, latencyMs, error: null, status: res.status };
-  }
-
-  if (kind === "image") {
-    const res = await fetch(`${baseUrl}/api/v1/images/generations`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({ model, prompt: "test" }),
-      signal: AbortSignal.timeout(15000),
-    });
-    const latencyMs = Date.now() - start;
-    const rawText = await res.text().catch(() => "");
-    let parsed = null;
-    try { parsed = rawText ? JSON.parse(rawText) : null; } catch {}
-
-    if (!res.ok) {
-      const detail = parsed?.error?.message || parsed?.msg || parsed?.message || parsed?.error || rawText;
-      return { ok: false, latencyMs, error: `HTTP ${res.status}${detail ? `: ${String(detail).slice(0, 240)}` : ""}`, status: res.status };
-    }
-
-    const hasImages = Array.isArray(parsed?.data) && parsed.data.length > 0;
-    if (!hasImages) {
-      return { ok: false, latencyMs, status: res.status, error: "Provider returned no image data for this model" };
-    }
-    return { ok: true, latencyMs, error: null, status: res.status };
-  }
-
-  if (kind === "stt") {
-    const form = new FormData();
-    const sampleAudio = createSilentWavFile();
-    form.append("file", sampleAudio, "test.wav");
-    form.append("model", model);
-
-    const res = await fetch(`${baseUrl}/api/v1/audio/transcriptions`, {
-      method: "POST",
-      headers: Object.fromEntries(Object.entries(headers).filter(([key]) => key.toLowerCase() !== "content-type")),
-      body: form,
-      signal: AbortSignal.timeout(15000),
-    });
-    const latencyMs = Date.now() - start;
-    const rawText = await res.text().catch(() => "");
-    let parsed = null;
-    try { parsed = rawText ? JSON.parse(rawText) : null; } catch {}
-
-    if (!res.ok) {
-      const detail = parsed?.error?.message || parsed?.msg || parsed?.message || parsed?.error || rawText;
-      return { ok: false, latencyMs, error: `HTTP ${res.status}${detail ? `: ${String(detail).slice(0, 240)}` : ""}`, status: res.status };
-    }
-
-    const text = typeof parsed?.text === "string" ? parsed.text : "";
-    if (!text.trim()) {
-      return { ok: false, latencyMs, status: res.status, error: "Provider returned no transcription text for this model" };
-    }
-    return { ok: true, latencyMs, error: null, status: res.status };
-  }
-
-  const res = await fetch(`${baseUrl}/api/v1/chat/completions`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({
-      model,
-      max_tokens: 1,
-      stream: false,
-      messages: [{ role: "user", content: "hi" }],
-    }),
-    signal: AbortSignal.timeout(15000),
-  });
-  const latencyMs = Date.now() - start;
-
-  const rawText = await res.text().catch(() => "");
-  let parsed = null;
-  try { parsed = rawText ? JSON.parse(rawText) : null; } catch {}
-
-  if (!res.ok) {
-    const detail = parsed?.error?.message || parsed?.msg || parsed?.message || parsed?.error || rawText;
-    return { ok: false, latencyMs, error: `HTTP ${res.status}${detail ? `: ${String(detail).slice(0, 240)}` : ""}`, status: res.status };
-  }
-
-  const providerStatus = parsed?.status;
-  const providerMsg = parsed?.msg || parsed?.message;
-  const hasProviderErrorStatus = providerStatus !== undefined
-    && providerStatus !== null
-    && String(providerStatus) !== "200"
-    && String(providerStatus) !== "0";
-  if (hasProviderErrorStatus && providerMsg) {
-    return {
-      ok: false,
-      latencyMs,
-      status: res.status,
-      error: `Provider status ${providerStatus}: ${String(providerMsg).slice(0, 240)}`,
-    };
-  }
-
-  if (parsed?.error) {
-    const providerError = parsed?.error?.message || parsed?.error || "Provider returned an error";
-    return {
-      ok: false,
-      latencyMs,
-      status: res.status,
-      error: String(providerError).slice(0, 240),
-    };
-  }
-
-  const hasChoices = Array.isArray(parsed?.choices) && parsed.choices.length > 0;
-  if (!hasChoices) {
-    return {
-      ok: false,
-      latencyMs,
-      status: res.status,
-      error: "Provider returned no completion choices for this model",
-    };
-  }
-
-  return { ok: true, latencyMs, error: null, status: res.status };
-}

package/src/app/api/models/test/route.js

@@ -1,14 +0,0 @@
-import { NextResponse } from "next/server";
-import { pingModelByKind } from "./ping";
-
-// POST /api/models/test - Ping a single model via internal completions or embeddings
-export async function POST(request) {
-  try {
-    const { model, kind } = await request.json();
-    if (!model) return NextResponse.json({ error: "Model required" }, { status: 400 });
-    const result = await pingModelByKind(model, kind || "llm");
-    return NextResponse.json(result);
-  } catch (err) {
-    return NextResponse.json({ ok: false, error: err.message }, { status: 500 });
-  }
-}