swayrouter 1.0.0

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

@@ -0,0 +1,78 @@
+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) {
+
+      state.send = async () => {
+        if (state.closed) return;
+        try {
+
+          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`));
+          }
+
+          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);
+        }
+      };
+
+      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/routes/api/v1/api/chat/route.js

@@ -0,0 +1,36 @@
+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/routes/api/v1/chat/completions/route.js

@@ -0,0 +1,28 @@
+import { handleChat } from "@/sse/handlers/chat.js";
+import { initTranslators } from "open-sse/translator/index.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();
+
+  return await handleChat(request);
+}

package/src/routes/api/v1/images/edits/route.js

@@ -0,0 +1,70 @@
+import { NextResponse } from "next/server";
+import { getSettings, getActiveProviderRows } from "@/lib/localDb.js";
+import { proxyAwareFetch } from "@/utils/proxyFetch.js";
+import { bodyBytesExceeded, isImageType, normalizeOutput, parseAllowlist, redactError, validateOutput } from "../imageValidation.js";
+
+const MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+const MAX_BODY_BYTES = 10 * 1024 * 1024;
+const IMAGE_PROVIDER_ERROR = "Image provider request failed";
+const IMAGE_EDIT_ERROR = "Image editing failed";
+
+export async function POST(request) {
+  try {
+    if (bodyBytesExceeded(request, MAX_BODY_BYTES)) return NextResponse.json({ error: "Request body too large" }, { status: 413 });
+    if (!String(request.headers.get("content-type") || "").toLowerCase().includes("multipart/form-data")) return NextResponse.json({ error: "multipart/form-data is required" }, { status: 400 });
+    const form = await request.formData();
+    const image = form.get("image");
+    if (!(image instanceof File) || !image.size) return NextResponse.json({ error: "image file is required" }, { status: 400 });
+    if (image.size > MAX_IMAGE_BYTES) return NextResponse.json({ error: "image exceeds 8 MB limit" }, { status: 413 });
+    if (!isImageType(image.type)) return NextResponse.json({ error: "image must be PNG, JPEG, WebP, or GIF" }, { status: 400 });
+    const mask = form.get("mask");
+    if (mask !== null && (!(mask instanceof File) || !mask.size || mask.size > MAX_IMAGE_BYTES || !isImageType(mask.type))) return NextResponse.json({ error: "mask must be a valid image up to 8 MB" }, { status: 400 });
+    const n = form.get("n");
+    const nValue = n === null || n === "" ? 1 : Number(n);
+    if (!Number.isInteger(nValue) || nValue < 1 || nValue > 4) return NextResponse.json({ error: "n must be between 1 and 4" }, { status: 400 });
+    const size = form.get("size");
+    if (size !== null && !["256x256", "512x512", "1024x1024"].includes(size)) return NextResponse.json({ error: "unsupported image size" }, { status: 400 });
+    const responseFormat = form.get("response_format");
+    if (responseFormat !== null && !["url", "b64_json"].includes(responseFormat)) return NextResponse.json({ error: "unsupported response_format" }, { status: 400 });
+
+    const prompt = form.get("prompt");
+    if (typeof prompt !== "string" || !prompt.trim() || prompt.length > 8000) return NextResponse.json({ error: "prompt is required and must be at most 8000 characters" }, { status: 400 });
+    const settings = await getSettings();
+    const enabled = parseAllowlist(settings?.mediaProviders ?? process.env.SWAY_MEDIA_PROVIDERS);
+    if (!enabled.size) return NextResponse.json({ error: "Image generation is disabled" }, { status: 404 });
+    const provider = String(form.get("provider") || [...enabled][0]).toLowerCase();
+    if (!enabled.has(provider)) return NextResponse.json({ error: "Media provider is not enabled" }, { status: 404 });
+    const connection = (await getActiveProviderRows()).find((row) => String(row.provider || "").toLowerCase() === provider);
+    if (!connection) return NextResponse.json({ error: "No active media provider connection" }, { status: 404 });
+    const baseUrl = connection.providerSpecificData?.baseUrl || connection.baseUrl || "";
+    if (!baseUrl) return NextResponse.json({ error: "Media provider has no base URL" }, { status: 502 });
+    const upstream = new FormData();
+    upstream.append("image", image, image.name || "image");
+    if (mask instanceof File) upstream.append("mask", mask, mask.name || "mask");
+    upstream.append("prompt", prompt);
+    for (const key of ["model", "size", "response_format"]) {
+      const value = form.get(key);
+      if (typeof value === "string" && value) upstream.append(key, value);
+    }
+    upstream.append("n", String(nValue));
+    const token = connection.accessToken || connection.apiKey;
+    const headers = token ? { authorization: `Bearer ${token}` } : {};
+    const response = await proxyAwareFetch(`${String(baseUrl).replace(/\/$/, "")}/images/edits`, { method: "POST", headers, body: upstream, signal: request.signal });
+    const text = await response.text();
+    let payload;
+    try { payload = JSON.parse(text); } catch { payload = null; }
+    if (!response.ok) {
+      console.error("[images/edits][upstream]", {
+        status: response.status,
+        response: text.slice(0, 500),
+      });
+      return NextResponse.json({ error: IMAGE_PROVIDER_ERROR }, { status: 502 });
+    }
+    const data = Array.isArray(payload?.data) ? payload.data.map(normalizeOutput).filter(Boolean) : [];
+    if (!validateOutput(data)) return NextResponse.json({ error: "Provider returned no valid image output" }, { status: 502 });
+    return NextResponse.json({ created: payload.created || Math.floor(Date.now() / 1000), data });
+  } catch (error) {
+    console.error("[images/edits]", redactError(error));
+    return NextResponse.json({ error: IMAGE_EDIT_ERROR }, { status: 502 });
+  }
+}

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

@@ -0,0 +1,50 @@
+import { NextResponse } from "next/server";
+import { getSettings, getActiveProviderRows } from "@/lib/localDb.js";
+import { proxyAwareFetch } from "@/utils/proxyFetch.js";
+import { bodyBytesExceeded, normalizeOutput, parseAllowlist, redactError, validateGenerationBody, validateOutput } from "../imageValidation.js";
+
+const MAX_BODY_BYTES = 256 * 1024;
+const IMAGE_GENERATION_ERROR = "Image generation failed";
+
+async function callMediaProvider(provider, body, request) {
+  const rows = await getActiveProviderRows();
+  const connection = rows.find((row) => String(row.provider || "").toLowerCase() === provider);
+  if (!connection) throw new Error("No active media provider connection");
+  const baseUrl = connection.providerSpecificData?.baseUrl || connection.baseUrl || "";
+  if (!baseUrl) throw new Error("Media provider has no base URL");
+  const url = `${String(baseUrl).replace(/\/$/, "")}/images/generations`;
+  const headers = { "content-type": "application/json", accept: "application/json" };
+  const token = connection.accessToken || connection.apiKey;
+  if (token) headers.authorization = `Bearer ${token}`;
+  const response = await proxyAwareFetch(url, { method: "POST", headers, body: JSON.stringify(body), signal: request.signal });
+  const text = await response.text();
+  let payload;
+  try { payload = JSON.parse(text); } catch { payload = null; }
+  if (!response.ok) {
+    throw new Error(`Media provider returned HTTP ${response.status}`);
+  }
+  return payload;
+}
+
+export async function POST(request) {
+  try {
+    if (bodyBytesExceeded(request, MAX_BODY_BYTES)) return NextResponse.json({ error: "Request body too large" }, { status: 413 });
+    const body = await request.json();
+    const validation = validateGenerationBody(body);
+    if (validation.error) return NextResponse.json({ error: validation.error }, { status: 400 });
+    const normalizedBody = validation.value; const n = normalizedBody.n; const providers = parseAllowlist((await getSettings()).mediaProviders ?? process.env.SWAY_MEDIA_PROVIDERS);
+    if (!providers.size) return NextResponse.json({ error: "Image generation is disabled" }, { status: 404 });
+    const provider = String(normalizedBody.provider || [...providers][0]).toLowerCase();
+    if (!providers.has(provider)) return NextResponse.json({ error: "Media provider is not enabled" }, { status: 404 });
+    const safeBody = { ...normalizedBody }; delete safeBody.provider; delete safeBody.n;
+    safeBody.n = n;
+    const result = await callMediaProvider(provider, safeBody, request);
+    const data = Array.isArray(result?.data) ? result.data.map(normalizeOutput).filter(Boolean) : [];
+    if (!validateOutput(data)) return NextResponse.json({ error: "Provider returned no valid image output" }, { status: 502 });
+    return NextResponse.json({ created: result.created || Math.floor(Date.now() / 1000), data });
+
+  } catch (error) {
+    console.error("[images/generations]", redactError(error));
+    return NextResponse.json({ error: IMAGE_GENERATION_ERROR }, { status: 502 });
+  }
+}

package/src/routes/api/v1/images/imageValidation.js

@@ -0,0 +1,45 @@
+export const MAX_PROMPT_LENGTH = 8000;
+export const MAX_IMAGES = 4;
+export const MAX_OUTPUT_BYTES = 32 * 1024 * 1024;
+
+export function parseAllowlist(raw) {
+  const values = Array.isArray(raw) ? raw : String(raw || "").split(",");
+  return new Set(values.map((value) => String(value).trim().toLowerCase()).filter(Boolean));
+}
+
+export function validateGenerationBody(body) {
+  if (!body || typeof body !== "object" || typeof body.prompt !== "string" || !body.prompt.trim()) return { error: "prompt is required" };
+  if (body.prompt.length > MAX_PROMPT_LENGTH) return { error: "prompt is too long" };
+  const n = body.n === undefined ? 1 : Number(body.n);
+  if (!Number.isInteger(n) || n < 1 || n > MAX_IMAGES) return { error: "n must be between 1 and 4" };
+  if (body.size !== undefined && !["256x256", "512x512", "1024x1024"].includes(body.size)) return { error: "unsupported image size" };
+  if (body.response_format !== undefined && !["url", "b64_json"].includes(body.response_format)) return { error: "unsupported response_format" };
+  return { value: { ...body, n } };
+}
+
+export function normalizeOutput(item) {
+  if (!item || typeof item !== "object") return null;
+  if (typeof item.b64_json === "string" && item.b64_json.length > 0) return { b64_json: item.b64_json };
+  if (typeof item.url === "string" && /^https?:\/\//i.test(item.url)) return { url: item.url };
+  return null;
+}
+
+export function validateOutput(data) {
+  return Array.isArray(data) && data.length > 0 && data.length <= MAX_IMAGES && JSON.stringify(data).length <= MAX_OUTPUT_BYTES;
+}
+
+export function bodyBytesExceeded(request, maxBytes) {
+  const raw = request.headers.get("content-length");
+  if (!raw) return false;
+  const value = Number(raw);
+  return !Number.isSafeInteger(value) || value > maxBytes;
+}
+
+export function isImageType(type) {
+  return /^image\/(png|jpeg|webp|gif)$/i.test(String(type || ""));
+}
+
+export function redactError(error) {
+  return String(error?.message || error || "media operation failed")
+    .replace(/(authorization|token|api[_-]?key|password)\s*[:=]\s*[^\s,;&]+/gi, "$1=[redacted]");
+}

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

@@ -0,0 +1,87 @@
+const CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Allow-Headers": "*"
+};
+
+export async function OPTIONS() {
+  return new Response(null, { headers: CORS_HEADERS });
+}
+
+function countValueChars(value) {
+  if (value == null) return 0;
+  if (typeof value === "string") return value.length;
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value).length;
+  }
+  if (Array.isArray(value)) {
+    return value.reduce((total, item) => total + countValueChars(item), 0);
+  }
+  if (typeof value === "object") {
+    return Object.entries(value).reduce((total, [key, item]) => {
+      return total + key.length + countValueChars(item);
+    }, 0);
+  }
+  return 0;
+}
+
+function countContentBlockChars(block) {
+  if (block == null) return 0;
+  if (typeof block === "string") return block.length;
+  if (typeof block !== "object") return countValueChars(block);
+
+  switch (block.type) {
+    case "text":
+      return countValueChars(block.text);
+    case "tool_use":
+      return countValueChars(block.name) + countValueChars(block.input);
+    case "tool_result":
+      return countValueChars(block.content);
+    case "thinking":
+      return countValueChars(block.thinking);
+    default:
+      return countValueChars(block);
+  }
+}
+
+function countMessageChars(message) {
+  if (!message || typeof message !== "object") return 0;
+  const content = message.content;
+
+  if (typeof content === "string") return content.length;
+  if (Array.isArray(content)) {
+    return content.reduce((total, block) => total + countContentBlockChars(block), 0);
+  }
+  return countValueChars(content);
+}
+
+export function estimateAnthropicInputTokens(body = {}) {
+  const messages = Array.isArray(body.messages) ? body.messages : [];
+  let totalChars = countValueChars(body.system) + countValueChars(body.tools);
+
+  for (const msg of messages) {
+    totalChars += countMessageChars(msg);
+  }
+
+  return Math.ceil(totalChars / 4);
+}
+
+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 }
+    });
+  }
+
+  const inputTokens = estimateAnthropicInputTokens(body);
+
+  return new Response(JSON.stringify({
+    input_tokens: inputTokens
+  }), {
+    headers: { "Content-Type": "application/json", ...CORS_HEADERS }
+  });
+}

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

@@ -0,0 +1,26 @@
+import { handleChat } from "@/sse/handlers/chat.js";
+import { initTranslators } from "open-sse/translator/index.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();
+  return await handleChat(request);
+}