waypoi 0.0.0

package/dist/src/utils/messageMedia.js

@@ -0,0 +1,285 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanMessageModalities = scanMessageModalities;
+exports.normalizeMessagesForUpstream = normalizeMessagesForUpstream;
+const path_1 = __importDefault(require("path"));
+const imageCache_1 = require("../storage/imageCache");
+function scanMessageModalities(messages) {
+    const result = { hasImage: false, hasAudio: false };
+    if (!Array.isArray(messages)) {
+        return result;
+    }
+    for (const message of messages) {
+        if (!message || typeof message !== "object") {
+            continue;
+        }
+        const content = message.content;
+        if (!Array.isArray(content)) {
+            continue;
+        }
+        for (const part of content) {
+            if (!part || typeof part !== "object") {
+                continue;
+            }
+            const type = part.type;
+            if (type === "image_url" || type === "input_image" || type === "image") {
+                result.hasImage = true;
+            }
+            if (type === "input_audio" || type === "audio") {
+                result.hasAudio = true;
+            }
+        }
+    }
+    return result;
+}
+async function normalizeMessagesForUpstream(paths, messages) {
+    if (!Array.isArray(messages)) {
+        return messages;
+    }
+    const normalized = [];
+    for (const message of messages) {
+        if (!message || typeof message !== "object") {
+            normalized.push(message);
+            continue;
+        }
+        const nextMessage = { ...message };
+        const content = nextMessage.content;
+        if (!Array.isArray(content)) {
+            normalized.push(nextMessage);
+            continue;
+        }
+        const nextContent = [];
+        for (const rawPart of content) {
+            if (!rawPart || typeof rawPart !== "object") {
+                nextContent.push(rawPart);
+                continue;
+            }
+            const part = { ...rawPart };
+            const type = part.type;
+            if (type === "video") {
+                throw invalidRequestError("Video content is not supported in v1 omni mode.");
+            }
+            if (type === "image" && typeof part.image === "string") {
+                nextContent.push({ type: "image_url", image_url: { url: part.image } });
+                continue;
+            }
+            if (type === "image_url") {
+                nextContent.push(await normalizeImageUrlPart(paths, part));
+                continue;
+            }
+            if (type === "audio" && typeof part.audio === "string") {
+                nextContent.push(await normalizeAudioValue(paths, part.audio));
+                continue;
+            }
+            if (type === "input_audio") {
+                nextContent.push(await normalizeInputAudioPart(paths, part));
+                continue;
+            }
+            nextContent.push(part);
+        }
+        nextMessage.content = nextContent;
+        normalized.push(nextMessage);
+    }
+    return normalized;
+}
+async function normalizeImageUrlPart(paths, part) {
+    const imageUrlObject = (part.image_url ?? {});
+    const value = imageUrlObject.url;
+    if (typeof value !== "string" || value.length === 0) {
+        return part;
+    }
+    if (value.startsWith("data:")) {
+        return part;
+    }
+    const hash = extractLocalHash(value);
+    if (!hash) {
+        return part;
+    }
+    const mediaPath = await (0, imageCache_1.getMediaPath)(paths, hash);
+    const mediaEntry = await (0, imageCache_1.getMediaEntry)(paths, hash);
+    if (!mediaPath || !mediaEntry) {
+        throw invalidRequestError("Referenced image not found in cache.");
+    }
+    const file = await Promise.resolve().then(() => __importStar(require("fs/promises")));
+    const buffer = await file.readFile(mediaPath);
+    const dataUrl = `data:${mediaEntry.mimeType};base64,${buffer.toString("base64")}`;
+    return {
+        ...part,
+        type: "image_url",
+        image_url: {
+            ...imageUrlObject,
+            url: dataUrl,
+        },
+    };
+}
+async function normalizeInputAudioPart(paths, part) {
+    const inputAudio = (part.input_audio ?? {});
+    const data = inputAudio.data;
+    const url = inputAudio.url;
+    if (typeof data === "string" && data.length > 0) {
+        return {
+            ...part,
+            type: "input_audio",
+            input_audio: {
+                ...inputAudio,
+            },
+        };
+    }
+    if (typeof url === "string" && url.length > 0) {
+        const resolved = await resolveLocalMediaUrl(paths, url);
+        return {
+            ...part,
+            type: "input_audio",
+            input_audio: resolved,
+        };
+    }
+    throw invalidRequestError("input_audio requires either data or a local media url.");
+}
+async function normalizeAudioValue(paths, value) {
+    if (value.startsWith("data:")) {
+        const parsed = parseDataUrl(value);
+        return {
+            type: "input_audio",
+            input_audio: {
+                data: parsed.base64,
+                format: parsed.format,
+            },
+        };
+    }
+    if (looksLikeBase64(value)) {
+        return {
+            type: "input_audio",
+            input_audio: {
+                data: value,
+            },
+        };
+    }
+    const resolved = await resolveLocalMediaUrl(paths, value);
+    return {
+        type: "input_audio",
+        input_audio: resolved,
+    };
+}
+async function resolveLocalMediaUrl(paths, url) {
+    const hash = extractLocalHash(url);
+    if (!hash) {
+        throw invalidRequestError("Only local /admin/media or /admin/images URLs are allowed for input_audio.");
+    }
+    const mediaPath = await (0, imageCache_1.getMediaPath)(paths, hash);
+    const mediaEntry = await (0, imageCache_1.getMediaEntry)(paths, hash);
+    if (!mediaPath || !mediaEntry) {
+        throw invalidRequestError("Referenced media not found in cache.");
+    }
+    const file = await Promise.resolve().then(() => __importStar(require("fs/promises")));
+    const buffer = await file.readFile(mediaPath);
+    return {
+        data: buffer.toString("base64"),
+        format: audioFormatFromMime(mediaEntry.mimeType, mediaPath),
+    };
+}
+function extractLocalHash(url) {
+    const normalized = normalizeLocalUrl(url);
+    if (!normalized) {
+        return null;
+    }
+    const mediaMatch = normalized.match(/^\/admin\/(media|images)\/([a-f0-9]{16})$/i);
+    if (!mediaMatch) {
+        return null;
+    }
+    return mediaMatch[2];
+}
+function normalizeLocalUrl(url) {
+    if (url.startsWith("/")) {
+        return url;
+    }
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            return null;
+        }
+        if (!["localhost", "127.0.0.1", "::1"].includes(parsed.hostname)) {
+            return null;
+        }
+        return parsed.pathname;
+    }
+    catch {
+        return null;
+    }
+}
+function parseDataUrl(value) {
+    const match = value.match(/^data:([^;]+);base64,(.+)$/i);
+    if (!match) {
+        throw invalidRequestError("Invalid data URL for audio input.");
+    }
+    return {
+        base64: match[2].replace(/\s+/g, ""),
+        format: audioFormatFromMime(match[1]),
+    };
+}
+function audioFormatFromMime(mimeType, filePath) {
+    const lower = mimeType.toLowerCase();
+    if (lower.includes("wav"))
+        return "wav";
+    if (lower.includes("mpeg") || lower.includes("mp3"))
+        return "mp3";
+    if (lower.includes("ogg"))
+        return "ogg";
+    if (lower.includes("webm"))
+        return "webm";
+    if (lower.includes("mp4") || lower.includes("m4a"))
+        return "m4a";
+    if (filePath) {
+        const ext = path_1.default.extname(filePath).slice(1).toLowerCase();
+        if (ext)
+            return ext;
+    }
+    return undefined;
+}
+function looksLikeBase64(value) {
+    if (value.length < 32) {
+        return false;
+    }
+    return /^[A-Za-z0-9+/=\s]+$/.test(value);
+}
+function invalidRequestError(message) {
+    const error = new Error(message);
+    error.type = "invalid_request";
+    error.retryable = false;
+    return error;
+}

package/dist/src/utils/modelCapabilities.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCapabilities = resolveCapabilities;
+exports.inferCapabilities = inferCapabilities;
+exports.supportsRequirements = supportsRequirements;
+function resolveCapabilities(mapping, endpointType, upstreamCaps) {
+    if (mapping.capabilities) {
+        return normalizeCapabilities(mapping.capabilities, "configured");
+    }
+    if (upstreamCaps) {
+        return normalizeCapabilities(upstreamCaps, "inferred");
+    }
+    const inferred = inferCapabilities(mapping.publicName, endpointType);
+    warnInference(mapping.publicName, endpointType, inferred);
+    return normalizeCapabilities(inferred, "inferred");
+}
+function inferCapabilities(modelName, endpointType) {
+    const name = modelName.toLowerCase();
+    if (endpointType === "embedding") {
+        return { input: ["text"], output: ["embedding"] };
+    }
+    if (endpointType === "diffusion") {
+        return { input: ["text"], output: ["image"] };
+    }
+    if (endpointType === "audio") {
+        if (isTtsModelName(name)) {
+            return { input: ["text"], output: ["audio"] };
+        }
+        return { input: ["audio"], output: ["text"] };
+    }
+    if (endpointType === "video") {
+        if (isImageToVideoModelName(name)) {
+            return { input: ["text", "image"], output: ["video"] };
+        }
+        return { input: ["text"], output: ["video"] };
+    }
+    if (isVisionModelName(name)) {
+        return { input: ["text", "image"], output: ["text"], supportsTools: true, supportsStreaming: true };
+    }
+    return { input: ["text"], output: ["text"], supportsTools: true, supportsStreaming: true };
+}
+function supportsRequirements(capabilities, requirements) {
+    if (!requirements) {
+        return true;
+    }
+    if (requirements.requiredInput && requirements.requiredInput.length > 0) {
+        for (const modality of requirements.requiredInput) {
+            if (!capabilities.input.includes(modality)) {
+                return false;
+            }
+        }
+    }
+    if (requirements.requiredOutput && requirements.requiredOutput.length > 0) {
+        for (const modality of requirements.requiredOutput) {
+            if (!capabilities.output.includes(modality)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function normalizeCapabilities(capabilities, source) {
+    return {
+        input: normalizeModalities(capabilities.input),
+        output: normalizeModalities(capabilities.output),
+        supportsTools: capabilities.supportsTools,
+        supportsStreaming: capabilities.supportsStreaming,
+        source,
+    };
+}
+function normalizeModalities(modalities) {
+    const allowed = ["text", "image", "audio", "embedding", "video"];
+    const unique = new Set();
+    for (const modality of modalities) {
+        if (allowed.includes(modality)) {
+            unique.add(modality);
+        }
+    }
+    return allowed.filter((modality) => unique.has(modality));
+}
+function isTtsModelName(name) {
+    return (name.includes("tts") ||
+        name.includes("speech") ||
+        name.includes("voice") ||
+        name.includes("audio-gen"));
+}
+function isVisionModelName(name) {
+    return (name.includes("vision") ||
+        name.includes("vl") ||
+        name.includes("omni") ||
+        name.includes("multimodal"));
+}
+function isImageToVideoModelName(name) {
+    return (name.includes("i2v") ||
+        name.includes("image-to-video") ||
+        name.includes("img2vid") ||
+        name.includes("kf2v"));
+}
+const capabilityInferenceWarnings = new Set();
+function warnInference(modelName, endpointType, capabilities) {
+    const key = `${endpointType}:${modelName}`;
+    if (capabilityInferenceWarnings.has(key)) {
+        return;
+    }
+    capabilityInferenceWarnings.add(key);
+    console.warn(`[waypoi] Inferred capabilities for model '${modelName}' on ${endpointType}: ` +
+        `${capabilities.input.join("+")}->${capabilities.output.join("+")}`);
+}

package/dist/src/utils/modelDiscovery.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveModelMappings = resolveModelMappings;
+exports.discoverUpstreamModels = discoverUpstreamModels;
+const undici_1 = require("undici");
+async function resolveModelMappings(endpoint, mappings) {
+    let models = null;
+    try {
+        models = await discoverUpstreamModels(endpoint);
+    }
+    catch {
+        models = null;
+    }
+    if (!models || models.length === 0) {
+        return mappings;
+    }
+    // If exactly one model, use it as the upstream for all mappings
+    // that don't already have an explicit upstream different from the public name
+    if (models.length === 1) {
+        const sole = models[0];
+        console.log(`[model-discovery] Single model found: ${sole.id}`);
+        return mappings.map((mapping) => {
+            // If user specified explicit upstream (public=upstream format), keep it
+            // Otherwise, use the discovered model as upstream
+            if (mapping.publicName !== mapping.upstreamModel) {
+                // User specified explicit mapping, keep it
+                return mapping;
+            }
+            // Public and upstream are the same (user just gave public name)
+            // Replace upstream with discovered model
+            console.log(`[model-discovery] Mapping ${mapping.publicName} -> ${sole.id}`);
+            return {
+                ...mapping,
+                upstreamModel: sole.id,
+                capabilities: mapping.capabilities ?? sole.capabilities,
+            };
+        });
+    }
+    // Multiple models - check if any mapping's upstream matches available models
+    console.log(`[model-discovery] ${models.length} models found: ${models
+        .slice(0, 5)
+        .map((model) => model.id)
+        .join(", ")}${models.length > 5 ? "..." : ""}`);
+    const byId = new Map(models.map((model) => [model.id, model]));
+    return mappings.map((mapping) => {
+        if (mapping.capabilities) {
+            return mapping;
+        }
+        const matched = byId.get(mapping.upstreamModel) ?? byId.get(mapping.publicName);
+        if (!matched?.capabilities) {
+            return mapping;
+        }
+        return {
+            ...mapping,
+            capabilities: matched.capabilities,
+        };
+    });
+}
+async function discoverUpstreamModels(endpoint) {
+    const dispatcher = endpoint.insecureTls
+        ? new undici_1.Agent({ connect: { rejectUnauthorized: false } })
+        : undefined;
+    const { url, headers } = buildDiscoveryRequest(endpoint);
+    const response = await (0, undici_1.request)(url, {
+        method: "GET",
+        headersTimeout: 3000,
+        bodyTimeout: 3000,
+        dispatcher,
+        headers,
+    });
+    const body = (await readJson(response.body));
+    response.body.resume();
+    if (response.statusCode < 200 || response.statusCode >= 300) {
+        throw new Error(`model discovery failed with status ${response.statusCode}`);
+    }
+    const list = Array.isArray(body?.data) ? body.data : [];
+    const models = [];
+    for (const item of list) {
+        if (!item.id) {
+            continue;
+        }
+        const modelInfo = { id: item.id };
+        const capabilities = extractCapabilities(item);
+        if (capabilities) {
+            modelInfo.capabilities = capabilities;
+        }
+        models.push(modelInfo);
+    }
+    return models;
+}
+function buildDiscoveryRequest(endpoint) {
+    const authType = endpoint.auth?.type ?? "bearer";
+    const headers = {};
+    const url = new URL(buildModelListUrl(endpoint.baseUrl));
+    const apiKey = endpoint.apiKey?.trim();
+    if (apiKey && authType === "query") {
+        const keyParam = endpoint.auth?.keyParam?.trim() || "api_key";
+        url.searchParams.set(keyParam, apiKey);
+    }
+    else if (apiKey && authType === "header") {
+        const headerName = endpoint.auth?.headerName?.trim() || endpoint.auth?.keyParam?.trim() || "x-api-key";
+        const prefix = endpoint.auth?.keyPrefix?.trim();
+        headers[headerName] = prefix ? `${prefix} ${apiKey}` : apiKey;
+    }
+    else if (apiKey && authType !== "none") {
+        headers.authorization = `Bearer ${apiKey}`;
+    }
+    return { url: url.toString(), headers };
+}
+function buildModelListUrl(baseUrl) {
+    const parsed = new URL(baseUrl);
+    const pathname = parsed.pathname.replace(/\/+$/, "");
+    if (!pathname) {
+        parsed.pathname = "/v1/models";
+    }
+    else if (pathname.endsWith("/v1")) {
+        parsed.pathname = `${pathname}/models`;
+    }
+    else {
+        parsed.pathname = `${pathname}/v1/models`;
+    }
+    return parsed.toString();
+}
+function extractCapabilities(item) {
+    const fromCapabilities = item.capabilities;
+    if (fromCapabilities?.input && fromCapabilities?.output) {
+        const input = normalizeModalities(fromCapabilities.input);
+        const output = normalizeModalities(fromCapabilities.output);
+        if (input.length > 0 && output.length > 0) {
+            return {
+                input,
+                output,
+                supportsTools: fromCapabilities.supportsTools,
+                supportsStreaming: fromCapabilities.supportsStreaming,
+                source: "inferred",
+            };
+        }
+    }
+    const input = normalizeModalities(item.input_modalities ?? []);
+    const output = normalizeModalities(item.output_modalities ?? []);
+    if (input.length > 0 && output.length > 0) {
+        return { input, output, source: "inferred" };
+    }
+    return undefined;
+}
+function normalizeModalities(values) {
+    const normalized = new Set();
+    for (const value of values) {
+        const lower = value.toLowerCase();
+        if (lower === "text" || lower === "image" || lower === "audio" || lower === "embedding") {
+            normalized.add(lower);
+        }
+    }
+    return Array.from(normalized);
+}
+async function readJson(stream) {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    if (chunks.length === 0) {
+        return null;
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/src/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// Auto-generated from git tags. Do not edit manually.
+exports.VERSION = "0.7.2-alpha.1";

package/dist/src/workers/captureRetention.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startCaptureRetentionWorker = startCaptureRetentionWorker;
+exports.stopCaptureRetentionWorker = stopCaptureRetentionWorker;
+const captureRepository_1 = require("../storage/captureRepository");
+let retentionTimer = null;
+function startCaptureRetentionWorker(paths) {
+    const run = async () => {
+        try {
+            await (0, captureRepository_1.runCaptureRetention)(paths);
+        }
+        catch {
+            // ignore background errors
+        }
+    };
+    retentionTimer = setInterval(run, 10 * 60 * 1000);
+    retentionTimer.unref();
+    void run();
+}
+function stopCaptureRetentionWorker() {
+    if (retentionTimer) {
+        clearInterval(retentionTimer);
+        retentionTimer = null;
+    }
+}

package/dist/src/workers/configWatcher.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startConfigWatcher = startConfigWatcher;
+exports.stopConfigWatcher = stopConfigWatcher;
+exports.getConfigWatcher = getConfigWatcher;
+const fs_1 = require("fs");
+const events_1 = require("events");
+const DEBOUNCE_MS = 500;
+class ConfigWatcherImpl extends events_1.EventEmitter {
+    watcher = null;
+    debounceTimer = null;
+    isWatching = false;
+    configPath;
+    constructor(configPath) {
+        super();
+        this.configPath = configPath;
+    }
+    start() {
+        if (this.isWatching)
+            return;
+        try {
+            this.watcher = (0, fs_1.watch)(this.configPath, (eventType) => {
+                // Handle both 'change' and 'rename' events
+                // Some editors do atomic saves (write temp → rename)
+                if (eventType === "change" || eventType === "rename") {
+                    this.debouncedEmit();
+                }
+            });
+            this.watcher.on("error", (error) => {
+                this.emit("error", error);
+            });
+            this.isWatching = true;
+            console.log("[config-watcher] Watching for config changes");
+        }
+        catch (error) {
+            // File might not exist yet, that's okay
+            console.log("[config-watcher] Config file not found, will retry on next access");
+        }
+    }
+    debouncedEmit() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+            console.log("[config-watcher] Config file changed, triggering reload");
+            this.emit("config:updated");
+            this.debounceTimer = null;
+        }, DEBOUNCE_MS);
+    }
+    stop() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        this.isWatching = false;
+        console.log("[config-watcher] Stopped watching");
+    }
+}
+let globalWatcher = null;
+/**
+ * Start watching the config file for changes.
+ * Returns an EventEmitter that emits "config:updated" when the file changes.
+ */
+function startConfigWatcher(paths) {
+    if (globalWatcher) {
+        return globalWatcher;
+    }
+    const watcher = new ConfigWatcherImpl(paths.configPath);
+    watcher.start();
+    globalWatcher = watcher;
+    return watcher;
+}
+/**
+ * Stop the config watcher.
+ */
+function stopConfigWatcher() {
+    if (globalWatcher) {
+        globalWatcher.stop();
+        globalWatcher = null;
+    }
+}
+/**
+ * Get the current config watcher instance (if running).
+ */
+function getConfigWatcher() {
+    return globalWatcher;
+}