waypoi 0.0.0

package/dist/src/routes/images.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerImageRoutes = registerImageRoutes;
+const crypto_1 = require("crypto");
+const router_1 = require("../routing/router");
+const repositories_1 = require("../storage/repositories");
+const scheduler_1 = require("../pools/scheduler");
+const modelRegistry_1 = require("../providers/modelRegistry");
+const imageGeneration_1 = require("../services/imageGeneration");
+const requestCapture_1 = require("../middleware/requestCapture");
+async function registerImageRoutes(app, paths) {
+    // POST /v1/images/generations
+    app.post("/v1/images/generations", async (req, reply) => {
+        const body = req.body;
+        if (!body?.prompt) {
+            reply.code(400).send({ error: { message: "prompt is required" } });
+            return;
+        }
+        const model = await (0, imageGeneration_1.resolveGenerationModel)(paths, body.model);
+        if (!model) {
+            reply.code(400).send({ error: { message: "No diffusion model available. Add or enable a provider model." } });
+            return;
+        }
+        const requestId = (0, crypto_1.randomUUID)();
+        const start = Date.now();
+        const controller = new AbortController();
+        req.raw.on("close", () => controller.abort());
+        try {
+            const generated = await (0, imageGeneration_1.runImageGeneration)(paths, { ...body, model }, req.headers, controller.signal);
+            setHeaders(reply, generated.headers);
+            reply.code(generated.statusCode).send(generated.payload);
+            (0, requestCapture_1.setCaptureRouting)(reply, {
+                publicModel: model,
+                endpointId: generated.route.endpointId,
+                endpointName: generated.route.endpointName,
+                upstreamModel: generated.route.upstreamModel,
+            });
+            await (0, repositories_1.logRequest)(paths, buildLog(requestId, model, {
+                attempt: {
+                    endpoint: {
+                        id: generated.route.endpointId,
+                        name: generated.route.endpointName,
+                    },
+                    upstreamModel: generated.route.upstreamModel,
+                    response: {
+                        statusCode: generated.statusCode,
+                    },
+                },
+            }, Date.now() - start, false));
+        }
+        catch (error) {
+            const errorType = error.type ?? error.name;
+            (0, requestCapture_1.setCaptureError)(reply, { type: errorType, message: error.message });
+            await (0, repositories_1.logRequest)(paths, {
+                requestId,
+                ts: new Date(),
+                route: { publicModel: model },
+                request: { stream: false },
+                result: {
+                    errorType,
+                    errorMessage: error.message
+                }
+            });
+            if (errorType === "invalid_request") {
+                reply.code(400).send({ error: { message: error.message } });
+                return;
+            }
+            if (errorType === "tls_verify_failed") {
+                reply.code(502).send({ error: { message: error.message, type: errorType } });
+                return;
+            }
+            const status = errorType === "no_endpoints" ||
+                errorType === "protocol_stream_unsupported" ||
+                errorType === "unsupported_protocol" ||
+                errorType === "invalid_protocol_config"
+                ? 400
+                : errorType === "rate_limited"
+                    ? 429
+                    : 502;
+            reply.code(status).send({ error: { message: "Image generation unavailable", type: errorType } });
+        }
+    });
+    // POST /v1/images/edits (passthrough)
+    app.post("/v1/images/edits", async (req, reply) => {
+        const body = req.body;
+        if (!body?.prompt) {
+            reply.code(400).send({ error: { message: "prompt is required" } });
+            return;
+        }
+        const model = body.model ?? await pickDefaultDiffusionModel(paths);
+        if (!model) {
+            reply.code(400).send({ error: { message: "No diffusion model available" } });
+            return;
+        }
+        const requestId = (0, crypto_1.randomUUID)();
+        const start = Date.now();
+        const controller = new AbortController();
+        req.raw.on("close", () => controller.abort());
+        try {
+            const outcome = await (0, router_1.routeRequest)(paths, model, "/v1/images/edits", body, req.headers, controller.signal, {
+                endpointType: "diffusion",
+                requiredInput: ["image"],
+                requiredOutput: ["image"],
+            });
+            const upstreamBody = await readBody(outcome.attempt.response);
+            setHeaders(reply, outcome.attempt.response.headers);
+            reply.code(outcome.attempt.response.statusCode).send(upstreamBody.payload);
+            (0, requestCapture_1.setCaptureRouting)(reply, {
+                publicModel: model,
+                endpointId: outcome.attempt.endpoint.id,
+                endpointName: outcome.attempt.endpoint.name,
+                upstreamModel: outcome.attempt.upstreamModel,
+            });
+            await (0, repositories_1.logRequest)(paths, buildLog(requestId, model, outcome, Date.now() - start, false));
+        }
+        catch (error) {
+            const errorType = error.type ?? error.name;
+            (0, requestCapture_1.setCaptureError)(reply, { type: errorType, message: error.message });
+            await (0, repositories_1.logRequest)(paths, {
+                requestId,
+                ts: new Date(),
+                route: { publicModel: model },
+                request: { stream: false },
+                result: { errorType, errorMessage: error.message }
+            });
+            if (errorType === "invalid_request") {
+                reply.code(400).send({ error: { message: error.message } });
+                return;
+            }
+            if (errorType === "tls_verify_failed") {
+                reply.code(502).send({ error: { message: error.message, type: errorType } });
+                return;
+            }
+            const status = errorType === "no_endpoints" ||
+                errorType === "protocol_stream_unsupported" ||
+                errorType === "unsupported_protocol" ||
+                errorType === "invalid_protocol_config"
+                ? 400
+                : errorType === "rate_limited"
+                    ? 429
+                    : 502;
+            reply.code(status).send({ error: { message: "Image edit unavailable", type: errorType } });
+        }
+    });
+    // POST /v1/images/variations (passthrough)
+    app.post("/v1/images/variations", async (req, reply) => {
+        const body = req.body;
+        const model = body?.model ?? await pickDefaultImageEditModel(paths);
+        if (!model) {
+            reply.code(400).send({ error: { message: "No diffusion model available" } });
+            return;
+        }
+        const requestId = (0, crypto_1.randomUUID)();
+        const start = Date.now();
+        const controller = new AbortController();
+        req.raw.on("close", () => controller.abort());
+        try {
+            const outcome = await (0, router_1.routeRequest)(paths, model, "/v1/images/variations", (body ?? {}), req.headers, controller.signal, {
+                endpointType: "diffusion",
+                requiredInput: ["image"],
+                requiredOutput: ["image"],
+            });
+            const upstreamBody = await readBody(outcome.attempt.response);
+            setHeaders(reply, outcome.attempt.response.headers);
+            reply.code(outcome.attempt.response.statusCode).send(upstreamBody.payload);
+            (0, requestCapture_1.setCaptureRouting)(reply, {
+                publicModel: model,
+                endpointId: outcome.attempt.endpoint.id,
+                endpointName: outcome.attempt.endpoint.name,
+                upstreamModel: outcome.attempt.upstreamModel,
+            });
+            await (0, repositories_1.logRequest)(paths, buildLog(requestId, model, outcome, Date.now() - start, false));
+        }
+        catch (error) {
+            const errorType = error.type ?? error.name;
+            (0, requestCapture_1.setCaptureError)(reply, { type: errorType, message: error.message });
+            await (0, repositories_1.logRequest)(paths, {
+                requestId,
+                ts: new Date(),
+                route: { publicModel: model },
+                request: { stream: false },
+                result: { errorType, errorMessage: error.message }
+            });
+            if (errorType === "invalid_request") {
+                reply.code(400).send({ error: { message: error.message } });
+                return;
+            }
+            if (errorType === "tls_verify_failed") {
+                reply.code(502).send({ error: { message: error.message, type: errorType } });
+                return;
+            }
+            const status = errorType === "no_endpoints" ||
+                errorType === "protocol_stream_unsupported" ||
+                errorType === "unsupported_protocol" ||
+                errorType === "invalid_protocol_config"
+                ? 400
+                : errorType === "rate_limited"
+                    ? 429
+                    : 502;
+            reply.code(status).send({ error: { message: "Image variation unavailable", type: errorType } });
+        }
+    });
+}
+async function pickDefaultDiffusionModel(paths) {
+    const smart = await (0, scheduler_1.selectPoolCandidates)(paths, "smart", {
+        requiredInput: ["text"],
+        requiredOutput: ["image"],
+    }, {
+        operation: "images_generation",
+        stream: false,
+    });
+    if (smart && smart.candidates.length > 0) {
+        return "smart";
+    }
+    const byCapabilities = await (0, modelRegistry_1.pickBestProviderModelByCapabilities)(paths, { requiredInput: ["text"], requiredOutput: ["image"] }, "diffusion");
+    if (byCapabilities) {
+        return byCapabilities;
+    }
+    return null;
+}
+async function pickDefaultImageEditModel(paths) {
+    const smart = await (0, scheduler_1.selectPoolCandidates)(paths, "smart", {
+        requiredInput: ["image", "text"],
+        requiredOutput: ["image"],
+    }, {
+        operation: "images_edits",
+        stream: false,
+    });
+    if (smart && smart.candidates.length > 0) {
+        return "smart";
+    }
+    const byCapabilities = await (0, modelRegistry_1.pickBestProviderModelByCapabilities)(paths, { requiredInput: ["image"], requiredOutput: ["image"] }, "diffusion");
+    if (byCapabilities) {
+        return byCapabilities;
+    }
+    return pickDefaultDiffusionModel(paths);
+}
+function setHeaders(reply, headers) {
+    for (const [key, value] of Object.entries(headers)) {
+        if (Array.isArray(value)) {
+            reply.header(key.toLowerCase(), value.join(", "));
+        }
+        else {
+            reply.header(key.toLowerCase(), value);
+        }
+    }
+}
+async function readBody(response) {
+    const chunks = [];
+    for await (const chunk of response.body) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const buffer = Buffer.concat(chunks);
+    const contentType = normalizeContentType(response.headers);
+    if (contentType.includes("application/json")) {
+        try {
+            return { payload: JSON.parse(buffer.toString("utf8")) };
+        }
+        catch {
+            return { payload: buffer };
+        }
+    }
+    return { payload: buffer };
+}
+function normalizeContentType(headers) {
+    const ct = headers["content-type"] ?? headers["Content-Type"];
+    if (Array.isArray(ct))
+        return ct.join(", ");
+    return ct ?? "";
+}
+function buildLog(requestId, model, outcome, latencyMs, stream) {
+    return {
+        requestId,
+        ts: new Date(),
+        route: {
+            publicModel: model,
+            endpointId: outcome.attempt.endpoint.id,
+            endpointName: outcome.attempt.endpoint.name,
+            upstreamModel: outcome.attempt.upstreamModel
+        },
+        request: { stream },
+        result: {
+            statusCode: outcome.attempt.response.statusCode,
+            latencyMs,
+            totalTokens: null
+        }
+    };
+}

package/dist/src/routes/mcp.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMcpRoutes = registerMcpRoutes;
+const config_1 = require("../config");
+const registry_1 = require("../mcp/registry");
+const discovery_1 = require("../mcp/discovery");
+/**
+ * MCP Routes
+ *
+ * Admin API for managing MCP servers and tools.
+ *
+ * Endpoints:
+ *   GET    /admin/mcp/servers           - List all MCP servers
+ *   POST   /admin/mcp/servers           - Add a new MCP server
+ *   GET    /admin/mcp/servers/:id       - Get server by ID
+ *   PUT    /admin/mcp/servers/:id       - Update server
+ *   DELETE /admin/mcp/servers/:id       - Remove server
+ *   POST   /admin/mcp/servers/:id/connect    - Connect and discover tools
+ *   POST   /admin/mcp/servers/:id/disconnect - Disconnect from server
+ *
+ *   GET    /admin/mcp/tools             - List all discovered tools
+ *   POST   /admin/mcp/tools/discover    - Discover tools from all servers
+ *   POST   /admin/mcp/tools/execute     - Execute a tool
+ */
+async function registerMcpRoutes(app, paths) {
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Server management
+    // ─────────────────────────────────────────────────────────────────────────────
+    app.get("/admin/mcp/servers", async (_req, reply) => {
+        try {
+            const servers = await (0, registry_1.listMcpServers)(paths);
+            const builtin = (0, discovery_1.getBuiltinVirtualServer)();
+            return reply.send({
+                object: "list",
+                data: [
+                    ...(builtin ? [builtin] : []),
+                    ...servers.map((s) => ({
+                        ...s,
+                        connected: (0, discovery_1.isServerConnected)(s.id),
+                    })),
+                ],
+            });
+        }
+        catch (error) {
+            app.log.error(error, "Failed to list MCP servers");
+            return reply.status(500).send({
+                error: { message: "Failed to list servers", type: "internal_error" },
+            });
+        }
+    });
+    app.post("/admin/mcp/servers", async (req, reply) => {
+        try {
+            if (!req.body?.name || !req.body?.url) {
+                return reply.status(400).send({
+                    error: { message: "name and url are required", type: "invalid_request" },
+                });
+            }
+            const server = await (0, registry_1.addMcpServer)(paths, req.body);
+            return reply.status(201).send(server);
+        }
+        catch (error) {
+            if (error.message.includes("already exists")) {
+                return reply.status(409).send({
+                    error: { message: error.message, type: "conflict" },
+                });
+            }
+            app.log.error(error, "Failed to add MCP server");
+            return reply.status(500).send({
+                error: { message: "Failed to add server", type: "internal_error" },
+            });
+        }
+    });
+    app.get("/admin/mcp/servers/:id", async (req, reply) => {
+        try {
+            if (req.params.id === discovery_1.BUILTIN_SERVER_ID) {
+                const builtin = (0, discovery_1.getBuiltinVirtualServer)();
+                if (!builtin) {
+                    return reply.status(404).send({
+                        error: { message: "Built-in server not yet initialized", type: "not_found" },
+                    });
+                }
+                return reply.send({
+                    ...builtin,
+                    tools: (0, discovery_1.getCachedToolsForServer)(discovery_1.BUILTIN_SERVER_ID),
+                });
+            }
+            const server = await (0, registry_1.getMcpServer)(paths, req.params.id);
+            if (!server) {
+                return reply.status(404).send({
+                    error: { message: "Server not found", type: "not_found" },
+                });
+            }
+            return reply.send({
+                ...server,
+                connected: (0, discovery_1.isServerConnected)(server.id),
+                tools: (0, discovery_1.getCachedToolsForServer)(server.id),
+            });
+        }
+        catch (error) {
+            app.log.error(error, "Failed to get MCP server");
+            return reply.status(500).send({
+                error: { message: "Failed to get server", type: "internal_error" },
+            });
+        }
+    });
+    app.put("/admin/mcp/servers/:id", async (req, reply) => {
+        try {
+            const server = await (0, registry_1.updateMcpServer)(paths, req.params.id, req.body || {});
+            if (!server) {
+                return reply.status(404).send({
+                    error: { message: "Server not found", type: "not_found" },
+                });
+            }
+            return reply.send(server);
+        }
+        catch (error) {
+            app.log.error(error, "Failed to update MCP server");
+            return reply.status(500).send({
+                error: { message: "Failed to update server", type: "internal_error" },
+            });
+        }
+    });
+    app.delete("/admin/mcp/servers/:id", async (req, reply) => {
+        try {
+            if (req.params.id === discovery_1.BUILTIN_SERVER_ID) {
+                return reply.status(403).send({
+                    error: { message: "Cannot delete the built-in waypoi server", type: "forbidden" },
+                });
+            }
+            // Disconnect first
+            await (0, discovery_1.disconnectServer)(req.params.id);
+            const deleted = await (0, registry_1.removeMcpServer)(paths, req.params.id);
+            if (!deleted) {
+                return reply.status(404).send({
+                    error: { message: "Server not found", type: "not_found" },
+                });
+            }
+            return reply.status(204).send();
+        }
+        catch (error) {
+            app.log.error(error, "Failed to remove MCP server");
+            return reply.status(500).send({
+                error: { message: "Failed to remove server", type: "internal_error" },
+            });
+        }
+    });
+    app.post("/admin/mcp/servers/:id/connect", async (req, reply) => {
+        try {
+            if (req.params.id === discovery_1.BUILTIN_SERVER_ID) {
+                const port = config_1.appConfig.port;
+                const tools = await (0, discovery_1.discoverBuiltinTools)(paths, `http://localhost:${port}/mcp`);
+                return reply.send({
+                    connected: true,
+                    toolCount: tools.length,
+                    tools: tools.map((t) => ({ name: t.name, description: t.description })),
+                });
+            }
+            const server = await (0, registry_1.getMcpServer)(paths, req.params.id);
+            if (!server) {
+                return reply.status(404).send({
+                    error: { message: "Server not found", type: "not_found" },
+                });
+            }
+            const tools = await (0, discovery_1.discoverServerTools)(paths, server);
+            return reply.send({
+                connected: true,
+                toolCount: tools.length,
+                tools: tools.map((t) => ({ name: t.name, description: t.description })),
+            });
+        }
+        catch (error) {
+            app.log.error(error, "Failed to connect to MCP server");
+            return reply.status(500).send({
+                error: { message: "Failed to connect", type: "connection_error" },
+            });
+        }
+    });
+    app.post("/admin/mcp/servers/:id/disconnect", async (req, reply) => {
+        try {
+            if (req.params.id === discovery_1.BUILTIN_SERVER_ID) {
+                return reply.status(403).send({
+                    error: { message: "Cannot disconnect the built-in waypoi server", type: "forbidden" },
+                });
+            }
+            await (0, discovery_1.disconnectServer)(req.params.id);
+            return reply.send({ disconnected: true });
+        }
+        catch (error) {
+            app.log.error(error, "Failed to disconnect from MCP server");
+            return reply.status(500).send({
+                error: { message: "Failed to disconnect", type: "internal_error" },
+            });
+        }
+    });
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Tool management
+    // ─────────────────────────────────────────────────────────────────────────────
+    app.get("/admin/mcp/tools", async (_req, reply) => {
+        try {
+            const tools = (0, discovery_1.getCachedTools)();
+            return reply.send({
+                object: "list",
+                data: tools,
+            });
+        }
+        catch (error) {
+            app.log.error(error, "Failed to list tools");
+            return reply.status(500).send({
+                error: { message: "Failed to list tools", type: "internal_error" },
+            });
+        }
+    });
+    app.post("/admin/mcp/tools/discover", async (_req, reply) => {
+        try {
+            const tools = await (0, discovery_1.discoverAllTools)(paths);
+            return reply.send({
+                discovered: tools.length,
+                tools: tools.map((t) => ({
+                    name: t.name,
+                    description: t.description,
+                    serverName: t.serverName,
+                })),
+            });
+        }
+        catch (error) {
+            app.log.error(error, "Failed to discover tools");
+            return reply.status(500).send({
+                error: { message: "Failed to discover tools", type: "internal_error" },
+            });
+        }
+    });
+    app.post("/admin/mcp/tools/execute", async (req, reply) => {
+        try {
+            if (!req.body?.name) {
+                return reply.status(400).send({
+                    error: { message: "Tool name is required", type: "invalid_request" },
+                });
+            }
+            const result = await (0, discovery_1.executeTool)(req.body.name, req.body.arguments ?? {});
+            if (result.isError) {
+                return reply.status(500).send({
+                    error: { message: result.content, type: "tool_error" },
+                });
+            }
+            return reply.send({
+                result: result.content,
+            });
+        }
+        catch (error) {
+            app.log.error(error, "Failed to execute tool");
+            return reply.status(500).send({
+                error: { message: "Failed to execute tool", type: "internal_error" },
+            });
+        }
+    });
+}

package/dist/src/routes/mcpService.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMcpServiceRoutes = registerMcpServiceRoutes;
+exports.closeMcpServiceRoutes = closeMcpServiceRoutes;
+const service_1 = require("../mcp/service");
+let activeMcpService = null;
+async function registerMcpServiceRoutes(app, paths, deps) {
+    const mcpService = (0, service_1.createMcpService)(paths, deps);
+    activeMcpService = mcpService;
+    app.route({
+        method: ["GET", "POST", "DELETE"],
+        url: "/mcp",
+        handler: async (req, reply) => {
+            if (!isLocalRequest(req)) {
+                reply.code(403).send({
+                    error: {
+                        message: "Forbidden: /mcp is restricted to localhost",
+                        type: "forbidden",
+                    },
+                });
+                return;
+            }
+            if (req.method === "GET") {
+                reply.code(405).header("Allow", "POST, DELETE").send("Method Not Allowed");
+                return;
+            }
+            await mcpService.handleRequest(req.raw, reply.raw, req.body);
+            reply.hijack();
+        },
+    });
+}
+async function closeMcpServiceRoutes() {
+    if (!activeMcpService) {
+        return;
+    }
+    await activeMcpService.close();
+    activeMcpService = null;
+}
+function isLocalRequest(req) {
+    const address = normalizeAddress(req.ip ?? req.socket.remoteAddress);
+    if (address && !isLocalHost(address)) {
+        return false;
+    }
+    const hostCandidates = [
+        firstHeaderValue(req.headers.host),
+        firstHeaderValue(req.headers["x-forwarded-host"]),
+        extractHostFromOrigin(firstHeaderValue(req.headers.origin)),
+    ]
+        .map((value) => normalizeHost(value))
+        .filter((value) => Boolean(value));
+    return hostCandidates.every((host) => isLocalHost(host));
+}
+function firstHeaderValue(header) {
+    if (typeof header === "string") {
+        return header;
+    }
+    if (Array.isArray(header) && header.length > 0) {
+        return header[0];
+    }
+    return undefined;
+}
+function extractHostFromOrigin(origin) {
+    if (!origin)
+        return undefined;
+    try {
+        const parsed = new URL(origin);
+        return parsed.host;
+    }
+    catch {
+        return undefined;
+    }
+}
+function normalizeHost(value) {
+    if (!value)
+        return null;
+    const host = value.split(",")[0].trim().toLowerCase();
+    if (!host)
+        return null;
+    if (host.startsWith("[")) {
+        const end = host.indexOf("]");
+        if (end > -1) {
+            return host.slice(1, end);
+        }
+    }
+    return host.split(":")[0];
+}
+function normalizeAddress(value) {
+    if (!value)
+        return null;
+    const trimmed = value.trim().toLowerCase();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("::ffff:")) {
+        return trimmed.replace("::ffff:", "");
+    }
+    return trimmed;
+}
+function isLocalHost(host) {
+    return host === "localhost" || host === "127.0.0.1" || host === "::1";
+}

package/dist/src/routes/models.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerModelsRoutes = registerModelsRoutes;
+const modelRegistry_1 = require("../providers/modelRegistry");
+async function registerModelsRoutes(app, paths) {
+    app.get("/v1/models", async (req, reply) => {
+        const query = (req.query ?? {});
+        const availableOnly = query.available_only === true || query.available_only === "true";
+        const concrete = await (0, modelRegistry_1.listModelsForApi)(paths, { availableOnly });
+        const smart = await (0, modelRegistry_1.getAvailableSmartPool)(paths);
+        const poolEntries = smart
+            ? [
+                {
+                    id: smart.alias,
+                    object: "model",
+                    owned_by: "waypoi",
+                    endpoint_type: inferEndpointType(smart.capabilities.output),
+                    capabilities: smart.capabilities,
+                    slug: smart.alias,
+                    waypoi_pool: {
+                        id: smart.id,
+                        strategy: smart.strategy,
+                        candidateCount: smart.candidateCount,
+                        scoreSource: "benchmark.livebench",
+                    },
+                },
+            ]
+            : [];
+        const data = [...concrete, ...poolEntries];
+        // Include both `data` and `models` for broader client compatibility.
+        reply.send({ object: "list", data, models: data });
+    });
+}
+function inferEndpointType(output) {
+    if (output.includes("text")) {
+        return "llm";
+    }
+    if (output.includes("embedding")) {
+        return "embedding";
+    }
+    if (output.includes("image")) {
+        return "diffusion";
+    }
+    if (output.includes("audio")) {
+        return "audio";
+    }
+    return "llm";
+}