wyxrouter 0.4.71

package/src/app/api/usage/stream/route.js

@@ -0,0 +1,79 @@
+import { getUsageStats, statsEmitter, getActiveRequests } from "@/lib/usageDb";
+
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+  const encoder = new TextEncoder();
+  const state = { closed: false, keepalive: null, send: null, sendPending: null, cachedStats: null };
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      // Full stats refresh (heavy) + immediate lightweight push
+      state.send = async () => {
+        if (state.closed) return;
+        try {
+          // Push lightweight update immediately so UI reflects changes fast
+          if (state.cachedStats) {
+            const { activeRequests, recentRequests, errorProvider } = await getActiveRequests();
+            const quickStats = { ...state.cachedStats, activeRequests, recentRequests, errorProvider };
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(quickStats)}\n\n`));
+          }
+          // Then do full recalc and update cache
+          const stats = await getUsageStats();
+          state.cachedStats = stats;
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(stats)}\n\n`));
+        } catch {
+          state.closed = true;
+          statsEmitter.off("update", state.send);
+          statsEmitter.off("pending", state.sendPending);
+          clearInterval(state.keepalive);
+        }
+      };
+
+      // Lightweight push: only refresh activeRequests + recentRequests on pending changes
+      state.sendPending = async () => {
+        if (state.closed || !state.cachedStats) return;
+        try {
+          const { activeRequests, recentRequests, errorProvider } = await getActiveRequests();
+          const stats = { ...state.cachedStats, activeRequests, recentRequests, errorProvider };
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(stats)}\n\n`));
+        } catch {
+          state.closed = true;
+          statsEmitter.off("update", state.send);
+          statsEmitter.off("pending", state.sendPending);
+          clearInterval(state.keepalive);
+        }
+      };
+
+      await state.send();
+
+      statsEmitter.on("update", state.send);
+      statsEmitter.on("pending", state.sendPending);
+
+      state.keepalive = setInterval(() => {
+        if (state.closed) { clearInterval(state.keepalive); return; }
+        try {
+          controller.enqueue(encoder.encode(": ping\n\n"));
+        } catch {
+          state.closed = true;
+          clearInterval(state.keepalive);
+        }
+      }, 25000);
+    },
+
+    cancel() {
+      state.closed = true;
+      statsEmitter.off("update", state.send);
+      statsEmitter.off("pending", state.sendPending);
+      clearInterval(state.keepalive);
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    },
+  });
+}

package/src/app/api/v1/api/chat/route.js

@@ -0,0 +1,37 @@
+import { handleChat } from "@/sse/handlers/chat.js";
+import { initTranslators } from "open-sse/translator/index.js";
+import { transformToOllama } from "open-sse/utils/ollamaTransform.js";
+
+let initialized = false;
+
+async function ensureInitialized() {
+  if (!initialized) {
+    await initTranslators();
+    initialized = true;
+  }
+}
+
+export async function OPTIONS() {
+  return new Response(null, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      "Access-Control-Allow-Headers": "*"
+    }
+  });
+}
+
+export async function POST(request) {
+  await ensureInitialized();
+  
+  const clonedReq = request.clone();
+  let modelName = "llama3.2";
+  try {
+    const body = await clonedReq.json();
+    modelName = body.model || "llama3.2";
+  } catch {}
+
+  const response = await handleChat(request);
+  return transformToOllama(response, modelName);
+}
+

package/src/app/api/v1/audio/speech/route.js

@@ -0,0 +1,16 @@
+import { handleTts } from "@/sse/handlers/tts.js";
+
+export async function OPTIONS() {
+  return new Response(null, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "POST, OPTIONS",
+      "Access-Control-Allow-Headers": "*",
+    },
+  });
+}
+
+/** POST /v1/audio/speech - OpenAI-compatible TTS endpoint */
+export async function POST(request) {
+  return await handleTts(request);
+}

package/src/app/api/v1/audio/transcriptions/route.js

@@ -0,0 +1,19 @@
+import { handleStt } from "@/sse/handlers/stt.js";
+
+// Allow large audio uploads — 5min for processing large files
+export const maxDuration = 300;
+
+export async function OPTIONS() {
+  return new Response(null, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "POST, OPTIONS",
+      "Access-Control-Allow-Headers": "*",
+    },
+  });
+}
+
+/** POST /v1/audio/transcriptions - OpenAI Whisper compatible STT */
+export async function POST(request) {
+  return await handleStt(request);
+}

package/src/app/api/v1/audio/voices/route.js

@@ -0,0 +1,68 @@
+import { AI_PROVIDERS } from "@/shared/constants/providers";
+
+// Provider → internal voices API. Edge/local-device share the generic endpoint.
+const PROVIDER_API = {
+  elevenlabs: (origin) => `${origin}/api/media-providers/tts/elevenlabs/voices`,
+  deepgram: (origin) => `${origin}/api/media-providers/tts/deepgram/voices`,
+  inworld: (origin) => `${origin}/api/media-providers/tts/inworld/voices`,
+  "edge-tts": (origin) => `${origin}/api/media-providers/tts/voices?provider=edge-tts`,
+  "local-device": (origin) => `${origin}/api/media-providers/tts/voices?provider=local-device`,
+};
+
+export async function OPTIONS() {
+  return new Response(null, {
+    headers: { "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Methods": "GET, OPTIONS" },
+  });
+}
+
+// GET /v1/audio/voices?provider={p}[&lang=xx]
+// Returns OpenAI-style list with each voice's full model id ready for /v1/audio/speech
+export async function GET(request) {
+  try {
+    const { searchParams, origin } = new URL(request.url);
+    const provider = searchParams.get("provider");
+    const lang = searchParams.get("lang");
+
+    if (!provider || !PROVIDER_API[provider]) {
+      return Response.json(
+        { error: { message: `provider must be one of: ${Object.keys(PROVIDER_API).join(", ")}`, type: "invalid_request_error" } },
+        { status: 400, headers: { "Access-Control-Allow-Origin": "*" } },
+      );
+    }
+
+    const baseUrl = PROVIDER_API[provider](origin);
+    const url = lang ? `${baseUrl}${baseUrl.includes("?") ? "&" : "?"}lang=${encodeURIComponent(lang)}` : baseUrl;
+    const res = await fetch(url, { cache: "no-store" });
+    const data = await res.json();
+    if (!res.ok || data.error) {
+      return Response.json(
+        { error: { message: data.error || `Upstream ${res.status}`, type: "server_error" } },
+        { status: res.status, headers: { "Access-Control-Allow-Origin": "*" } },
+      );
+    }
+
+    // Internal API shape: { voices } when lang filter, else { byLang, languages }
+    const rawVoices = lang
+      ? (data.voices || [])
+      : Object.values(data.byLang || {}).flatMap((l) => l.voices || []);
+
+    // Use provider alias for /v1/audio/speech model param (matches skill convention e.g. el/, dg/, edge-tts/)
+    const alias = AI_PROVIDERS[provider]?.alias || provider;
+    const data_out = rawVoices.map((v) => ({
+      id: v.id,
+      name: v.name,
+      lang: v.lang || "",
+      gender: v.gender || "",
+      model: `${alias}/${v.id}`,
+    }));
+
+    return Response.json({ object: "list", data: data_out }, {
+      headers: { "Access-Control-Allow-Origin": "*" },
+    });
+  } catch (err) {
+    return Response.json(
+      { error: { message: err.message || "Failed", type: "server_error" } },
+      { status: 502, headers: { "Access-Control-Allow-Origin": "*" } },
+    );
+  }
+}

package/src/app/api/v1/chat/completions/route.js

@@ -0,0 +1,35 @@
+import { handleChat } from "@/sse/handlers/chat.js";
+import { initTranslators } from "open-sse/translator/index.js";
+
+let initialized = false;
+
+/**
+ * Initialize translators once
+ */
+async function ensureInitialized() {
+  if (!initialized) {
+    await initTranslators();
+    initialized = true;
+  }
+}
+
+/**
+ * Handle CORS preflight
+ */
+export async function OPTIONS() {
+  return new Response(null, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      "Access-Control-Allow-Headers": "*"
+    }
+  });
+}
+
+export async function POST(request) {  
+  // Fallback to local handling
+  await ensureInitialized();
+  
+  return await handleChat(request);
+}
+

package/src/app/api/v1/embeddings/route.js

@@ -0,0 +1,21 @@
+import { handleEmbeddings } from "@/sse/handlers/embeddings.js";
+
+/**
+ * Handle CORS preflight
+ */
+export async function OPTIONS() {
+  return new Response(null, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "POST, OPTIONS",
+      "Access-Control-Allow-Headers": "*"
+    }
+  });
+}
+
+/**
+ * POST /v1/embeddings - OpenAI-compatible embeddings endpoint
+ */
+export async function POST(request) {
+  return await handleEmbeddings(request);
+}

package/src/app/api/v1/images/generations/route.js

@@ -0,0 +1,16 @@
+import { handleImageGeneration } from "@/sse/handlers/imageGeneration.js";
+
+export async function OPTIONS() {
+  return new Response(null, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "POST, OPTIONS",
+      "Access-Control-Allow-Headers": "*",
+    },
+  });
+}
+
+/** POST /v1/images/generations - OpenAI-compatible image generation endpoint */
+export async function POST(request) {
+  return await handleImageGeneration(request);
+}

package/src/app/api/v1/messages/count_tokens/route.js

@@ -0,0 +1,52 @@
+const CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Allow-Headers": "*"
+};
+
+/**
+ * Handle CORS preflight
+ */
+export async function OPTIONS() {
+  return new Response(null, { headers: CORS_HEADERS });
+}
+
+/**
+ * POST /v1/messages/count_tokens - Mock token count response
+ */
+export async function POST(request) {
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return new Response(JSON.stringify({ error: "Invalid JSON body" }), {
+      status: 400,
+      headers: { "Content-Type": "application/json", ...CORS_HEADERS }
+    });
+  }
+
+  // Estimate token count based on content length
+  const messages = body.messages || [];
+  let totalChars = 0;
+  for (const msg of messages) {
+    if (typeof msg.content === "string") {
+      totalChars += msg.content.length;
+    } else if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part.type === "text" && part.text) {
+          totalChars += part.text.length;
+        }
+      }
+    }
+  }
+
+  // Rough estimate: ~4 chars per token
+  const inputTokens = Math.ceil(totalChars / 4);
+
+  return new Response(JSON.stringify({
+    input_tokens: inputTokens
+  }), {
+    headers: { "Content-Type": "application/json", ...CORS_HEADERS }
+  });
+}
+

package/src/app/api/v1/messages/route.js

@@ -0,0 +1,36 @@
+import { handleChat } from "@/sse/handlers/chat.js";
+import { initTranslators } from "open-sse/translator/index.js";
+
+let initialized = false;
+
+/**
+ * Initialize translators once
+ */
+async function ensureInitialized() {
+  if (!initialized) {
+    await initTranslators();
+    initialized = true;
+  }
+}
+
+/**
+ * Handle CORS preflight
+ */
+export async function OPTIONS() {
+  return new Response(null, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      "Access-Control-Allow-Headers": "*"
+    }
+  });
+}
+
+/**
+ * POST /v1/messages - Claude format (auto convert via handleChat)
+ */
+export async function POST(request) {
+  await ensureInitialized();
+  return await handleChat(request);
+}
+

package/src/app/api/v1/models/[kind]/route.js

@@ -0,0 +1,55 @@
+import { buildModelsList } from "../route.js";
+
+// URL slug → service kind(s). `web` covers both webSearch and webFetch.
+const KIND_SLUG_MAP = {
+  "image": ["image"],
+  "tts": ["tts"],
+  "stt": ["stt"],
+  "embedding": ["embedding"],
+  "image-to-text": ["imageToText"],
+  "web": ["webSearch", "webFetch"],
+};
+
+export async function OPTIONS() {
+  return new Response(null, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, OPTIONS",
+      "Access-Control-Allow-Headers": "*",
+    },
+  });
+}
+
+/**
+ * GET /v1/models/{kind} - OpenAI-compatible models list filtered by capability.
+ * Supported kinds: image, tts, stt, embedding, image-to-text, web.
+ */
+export async function GET(_request, { params }) {
+  try {
+    const { kind } = await params;
+    const kindFilter = KIND_SLUG_MAP[kind];
+
+    if (!kindFilter) {
+      return Response.json(
+        {
+          error: {
+            message: `Unknown model kind: ${kind}. Supported: ${Object.keys(KIND_SLUG_MAP).join(", ")}`,
+            type: "invalid_request_error",
+          },
+        },
+        { status: 404, headers: { "Access-Control-Allow-Origin": "*" } }
+      );
+    }
+
+    const data = await buildModelsList(kindFilter);
+    return Response.json({ object: "list", data }, {
+      headers: { "Access-Control-Allow-Origin": "*" },
+    });
+  } catch (error) {
+    console.log("Error fetching models by kind:", error);
+    return Response.json(
+      { error: { message: error.message, type: "server_error" } },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,110 @@
+import { PROVIDER_MODELS } from "open-sse/config/providerModels.js";
+import { AI_PROVIDERS, ALIAS_TO_ID } from "@/shared/constants/providers";
+
+const KIND_ENDPOINT = {
+  llm: "/v1/chat/completions",
+  image: "/v1/images/generations",
+  tts: "/v1/audio/speech",
+  stt: "/v1/audio/transcriptions",
+  embedding: "/v1/embeddings",
+  imageToText: "/v1/chat/completions",
+  webSearch: "/v1/search",
+  webFetch: "/v1/fetch",
+};
+
+const TTS_VOICES_API = new Set(["elevenlabs", "edge-tts", "deepgram", "inworld", "local-device"]);
+
+function buildInfo({ alias, providerId, model, kind, providerInfo }) {
+  const out = {
+    id: `${alias}/${model.id}`,
+    name: model.name || model.id,
+    kind,
+    owned_by: alias,
+    endpoint: KIND_ENDPOINT[kind] || null,
+  };
+  if (model.params) out.params = model.params;
+  if (model.capabilities) out.capabilities = model.capabilities;
+  if (model.options) out.options = model.options;
+  if (model.dimensions) out.dimensions = model.dimensions;
+  if (model.contextWindow) out.contextWindow = model.contextWindow;
+  if (kind === "tts" && TTS_VOICES_API.has(providerId)) {
+    out.voicesUrl = `/v1/audio/voices?provider=${providerId}`;
+  }
+  if (kind === "webSearch" && providerInfo?.searchConfig) {
+    const cfg = providerInfo.searchConfig;
+    if (cfg.searchTypes) out.searchTypes = cfg.searchTypes;
+    if (cfg.maxMaxResults) out.maxResults = cfg.maxMaxResults;
+    if (cfg.requiredOptions) out.required = cfg.requiredOptions;
+  }
+  return out;
+}
+
+// id format: "{alias}/{modelId}" - alias may also be providerId
+function lookup(fullId) {
+  if (!fullId || !fullId.includes("/")) return null;
+  const slash = fullId.indexOf("/");
+  const alias = fullId.slice(0, slash);
+  const modelId = fullId.slice(slash + 1);
+  const providerId = ALIAS_TO_ID[alias] || alias;
+  const providerInfo = AI_PROVIDERS[providerId];
+
+  // PROVIDER_MODELS lookup (by alias key, fallback to providerId)
+  const list = PROVIDER_MODELS[alias] || PROVIDER_MODELS[providerId] || [];
+  const m = list.find((x) => x.id === modelId);
+  if (m) {
+    const kind = m.type || "llm";
+    return buildInfo({ alias, providerId, model: m, kind, providerInfo });
+  }
+
+  // Sub-configs (TTS/STT/embedding only-in-config)
+  const subs = [
+    ["tts", providerInfo?.ttsConfig],
+    ["stt", providerInfo?.sttConfig],
+    ["embedding", providerInfo?.embeddingConfig],
+  ];
+  for (const [kind, cfg] of subs) {
+    const sm = cfg?.models?.find((x) => x.id === modelId);
+    if (sm) return buildInfo({ alias, providerId, model: sm, kind, providerInfo });
+  }
+
+  // Web search/fetch — virtual model id "search" / "fetch"
+  if (modelId === "search" && providerInfo?.searchConfig) {
+    return buildInfo({
+      alias, providerId, kind: "webSearch", providerInfo,
+      model: { id: "search", name: `${providerInfo.name} Search`, params: ["query", "max_results", "country", "language", "time_range", "domain_filter", "search_type"] },
+    });
+  }
+  if (modelId === "fetch" && providerInfo?.fetchConfig) {
+    return buildInfo({
+      alias, providerId, kind: "webFetch", providerInfo,
+      model: { id: "fetch", name: `${providerInfo.name} Fetch`, params: ["url", "format", "max_characters"] },
+    });
+  }
+  return null;
+}
+
+export async function OPTIONS() {
+  return new Response(null, {
+    headers: { "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Methods": "GET, OPTIONS" },
+  });
+}
+
+// GET /v1/models/info?id={alias}/{modelId} — metadata for a single model
+export async function GET(request) {
+  const { searchParams } = new URL(request.url);
+  const id = searchParams.get("id");
+  if (!id) {
+    return Response.json(
+      { error: { message: "Missing required query param: id (e.g. ?id=openai/dall-e-3)", type: "invalid_request_error" } },
+      { status: 400, headers: { "Access-Control-Allow-Origin": "*" } },
+    );
+  }
+  const info = lookup(id);
+  if (!info) {
+    return Response.json(
+      { error: { message: `Model not found: ${id}`, type: "not_found" } },
+      { status: 404, headers: { "Access-Control-Allow-Origin": "*" } },
+    );
+  }
+  return Response.json(info, { headers: { "Access-Control-Allow-Origin": "*" } });
+}