wyxrouter 0.4.71

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

@@ -0,0 +1,99 @@
+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/models/alias/route.js

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,103 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,64 @@
+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}`;
+        return {
+          ...m,
+          fullModel,
+          alias: modelAliases[fullModel] || m.model,
+        };
+      });
+
+    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();
+
+    // Check if alias already exists for different model
+    const existingModel = Object.entries(modelAliases).find(
+      ([key, val]) => val === alias && key !== model
+    );
+
+    if (existingModel) {
+      return NextResponse.json({ error: "Alias already in use" }, { status: 400 });
+    }
+
+    // Update alias
+    await setModelAlias(model, alias);
+
+    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

@@ -0,0 +1,191 @@
+import { getApiKeys } from "@/lib/localDb";
+import { UPDATER_CONFIG } from "@/shared/constants/config";
+import { getConsistentMachineId } from "@/shared/utils/machineId";
+
+const CLI_TOKEN_SALT = "9r-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();
+    apiKey = keys.find((k) => k.isActive !== false)?.key || null;
+  } catch {}
+
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+  headers["x-9r-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

@@ -0,0 +1,14 @@
+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 });
+  }
+}