waypoi 0.0.0

package/dist/src/storage/sessionRepository.js

@@ -0,0 +1,370 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSessionsDir = resolveSessionsDir;
+exports.listSessions = listSessions;
+exports.getSession = getSession;
+exports.createSession = createSession;
+exports.updateSession = updateSession;
+exports.deleteSession = deleteSession;
+exports.addMessage = addMessage;
+exports.appendMessageContent = appendMessageContent;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const files_1 = require("./files");
+const imageCache_1 = require("./imageCache");
+/**
+ * Session Repository
+ *
+ * Manages chat sessions for the playground UI.
+ * Sessions are stored as JSON files in ~/.config/waypoi/sessions/
+ */
+function resolveSessionsDir(paths) {
+    return path_1.default.join(paths.baseDir, "sessions");
+}
+async function ensureSessionsDir(paths) {
+    await (0, files_1.ensureStorageDir)(paths);
+    const sessionsDir = resolveSessionsDir(paths);
+    await fs_1.promises.mkdir(sessionsDir, { recursive: true });
+}
+function sessionFilePath(paths, sessionId) {
+    return path_1.default.join(resolveSessionsDir(paths), `${sessionId}.json`);
+}
+async function listSessions(paths) {
+    await ensureSessionsDir(paths);
+    const sessionsDir = resolveSessionsDir(paths);
+    try {
+        const files = await fs_1.promises.readdir(sessionsDir);
+        const sessions = [];
+        for (const file of files) {
+            if (!file.endsWith(".json"))
+                continue;
+            try {
+                const filePath = path_1.default.join(sessionsDir, file);
+                const raw = await fs_1.promises.readFile(filePath, "utf8");
+                let session = parseSession(JSON.parse(raw));
+                const migrated = await migrateSessionMediaRefs(paths, session);
+                if (migrated.changed) {
+                    session = migrated.session;
+                    await saveSession(paths, session);
+                }
+                sessions.push(session);
+            }
+            catch {
+                // Skip malformed session files
+            }
+        }
+        // Sort by updatedAt descending (most recent first)
+        return sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+}
+async function getSession(paths, sessionId) {
+    await ensureSessionsDir(paths);
+    const filePath = sessionFilePath(paths, sessionId);
+    try {
+        const raw = await fs_1.promises.readFile(filePath, "utf8");
+        let session = parseSession(JSON.parse(raw));
+        const migrated = await migrateSessionMediaRefs(paths, session);
+        if (migrated.changed) {
+            session = migrated.session;
+            await saveSession(paths, session);
+        }
+        return session;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+async function createSession(paths, input) {
+    await ensureSessionsDir(paths);
+    const now = new Date();
+    const session = {
+        id: crypto_1.default.randomUUID(),
+        name: input.name ?? `Session ${now.toLocaleDateString()}`,
+        model: input.model,
+        titleStatus: input.name ? "manual" : "pending",
+        titleUpdatedAt: now,
+        storageVersion: 2,
+        messages: [],
+        createdAt: now,
+        updatedAt: now,
+    };
+    await saveSession(paths, session);
+    return session;
+}
+async function updateSession(paths, sessionId, patch) {
+    const session = await getSession(paths, sessionId);
+    if (!session)
+        return null;
+    const titleStatus = patch.titleStatus ??
+        (patch.name !== undefined ? "manual" : session.titleStatus);
+    const titleUpdatedAt = patch.titleUpdatedAt ??
+        (patch.name !== undefined || patch.titleStatus !== undefined ? new Date() : session.titleUpdatedAt);
+    const updated = {
+        ...session,
+        ...patch,
+        titleStatus,
+        titleUpdatedAt,
+        updatedAt: new Date(),
+    };
+    await saveSession(paths, updated);
+    return updated;
+}
+async function deleteSession(paths, sessionId) {
+    const filePath = sessionFilePath(paths, sessionId);
+    try {
+        await (0, imageCache_1.unmarkSessionMediaReferences)(paths, sessionId);
+        await fs_1.promises.unlink(filePath);
+        // Free any media that is now unreferenced
+        await (0, imageCache_1.cleanOrphanedMedia)(paths);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function addMessage(paths, sessionId, message) {
+    const session = await getSession(paths, sessionId);
+    if (!session)
+        return null;
+    const normalizedMessage = await normalizeMessageMediaRefs(paths, message);
+    const newMessage = {
+        ...normalizedMessage,
+        id: crypto_1.default.randomUUID(),
+        createdAt: new Date(),
+    };
+    session.messages.push(newMessage);
+    session.updatedAt = new Date();
+    await saveSession(paths, session);
+    return newMessage;
+}
+async function appendMessageContent(paths, sessionId, messageId, content) {
+    const session = await getSession(paths, sessionId);
+    if (!session)
+        return false;
+    const message = session.messages.find((m) => m.id === messageId);
+    if (!message)
+        return false;
+    message.content = (message.content ?? "") + content;
+    session.updatedAt = new Date();
+    await saveSession(paths, session);
+    return true;
+}
+async function saveSession(paths, session) {
+    const filePath = sessionFilePath(paths, session.id);
+    const json = JSON.stringify(session, null, 2);
+    await fs_1.promises.writeFile(filePath, json, "utf8");
+    await (0, imageCache_1.syncSessionMediaReferences)(paths, session.id, extractMediaHashesFromSession(session));
+}
+function parseSession(raw) {
+    const session = {
+        ...raw,
+        storageVersion: typeof raw.storageVersion === "number" ? raw.storageVersion : 1,
+        titleStatus: raw.titleStatus === "pending" ||
+            raw.titleStatus === "generated" ||
+            raw.titleStatus === "manual" ||
+            raw.titleStatus === "failed"
+            ? raw.titleStatus
+            : undefined,
+        titleUpdatedAt: raw.titleUpdatedAt ? new Date(raw.titleUpdatedAt) : undefined,
+        createdAt: new Date(raw.createdAt),
+        updatedAt: new Date(raw.updatedAt),
+        messages: Array.isArray(raw.messages)
+            ? raw.messages.map((message) => ({
+                ...message,
+                createdAt: parseMessageDate(message),
+            }))
+            : [],
+    };
+    return session;
+}
+function parseMessageDate(message) {
+    if (message.createdAt) {
+        return new Date(message.createdAt);
+    }
+    if (typeof message.timestamp === "string") {
+        return new Date(message.timestamp);
+    }
+    return new Date();
+}
+async function migrateSessionMediaRefs(paths, session) {
+    let changed = false;
+    const migratedMessages = [];
+    for (const message of session.messages) {
+        const normalized = await normalizeMessageMediaRefs(paths, message);
+        if (!changed && JSON.stringify(normalized) !== JSON.stringify(message)) {
+            changed = true;
+        }
+        migratedMessages.push({
+            ...normalized,
+            id: message.id,
+            createdAt: message.createdAt,
+        });
+    }
+    const nextStorageVersion = session.storageVersion >= 2 ? session.storageVersion : 2;
+    if (nextStorageVersion !== session.storageVersion) {
+        changed = true;
+    }
+    if (!changed) {
+        return { session, changed: false };
+    }
+    return {
+        changed: true,
+        session: {
+            ...session,
+            storageVersion: nextStorageVersion,
+            messages: migratedMessages,
+            updatedAt: new Date(),
+        },
+    };
+}
+async function normalizeMessageMediaRefs(paths, message) {
+    const next = {
+        role: message.role,
+        content: message.content ?? "",
+        name: message.name,
+        tool_calls: message.tool_calls,
+        tool_call_id: message.tool_call_id,
+        images: message.images,
+        model: message.model,
+    };
+    // Normalize convenience image list
+    if (Array.isArray(next.images)) {
+        const normalizedImages = [];
+        for (const value of next.images) {
+            const cachedUrl = await normalizeImageRefToLocalUrl(paths, value);
+            normalizedImages.push(cachedUrl);
+        }
+        next.images = normalizedImages;
+    }
+    // Normalize image_url parts in content
+    if (Array.isArray(next.content)) {
+        const normalizedContent = [];
+        for (const part of next.content) {
+            if (part &&
+                typeof part === "object" &&
+                part.type === "image_url" &&
+                part.image_url &&
+                typeof part.image_url.url === "string") {
+                const normalizedUrl = await normalizeImageRefToLocalUrl(paths, part.image_url.url);
+                normalizedContent.push({
+                    ...part,
+                    image_url: {
+                        ...part.image_url,
+                        url: normalizedUrl,
+                    },
+                });
+            }
+            else {
+                normalizedContent.push(part);
+            }
+        }
+        next.content = normalizedContent;
+    }
+    return next;
+}
+/**
+ * Normalize an image reference to a stable /admin/media/{hash} URL.
+ * If conversion fails, the ORIGINAL reference is returned so images are never
+ * silently dropped from sessions. A partial failure is far better than data loss.
+ */
+async function normalizeImageRefToLocalUrl(paths, value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return value;
+    const localHash = extractLocalMediaHash(trimmed);
+    if (localHash) {
+        return `/admin/media/${localHash}`;
+    }
+    if (/^[a-f0-9]{16}$/i.test(trimmed)) {
+        return `/admin/media/${trimmed.toLowerCase()}`;
+    }
+    if (trimmed.startsWith("data:image/") || trimmed.startsWith("data:audio/")) {
+        try {
+            const cached = await (0, imageCache_1.storeMedia)(paths, trimmed);
+            return `/admin/media/${cached.hash}`;
+        }
+        catch (err) {
+            console.error(`[waypoi] Failed to cache media ref (preserving original): ${err.message}`);
+            return value; // preserve — don't discard
+        }
+    }
+    if (/^https?:\/\//i.test(trimmed)) {
+        try {
+            const response = await fetch(trimmed, { signal: AbortSignal.timeout(10_000) });
+            if (!response.ok) {
+                console.error(`[waypoi] Failed to fetch remote image (${response.status}), preserving URL: ${trimmed.slice(0, 80)}`);
+                return value; // preserve the URL — might resolve later
+            }
+            const contentType = response.headers.get("content-type") ?? undefined;
+            const buffer = Buffer.from(await response.arrayBuffer());
+            const cached = await (0, imageCache_1.storeMedia)(paths, buffer, { mimeType: contentType });
+            return `/admin/media/${cached.hash}`;
+        }
+        catch (err) {
+            console.error(`[waypoi] Failed to fetch/cache remote image (preserving URL): ${err.message}`);
+            return value; // preserve — might be temporarily unreachable
+        }
+    }
+    // Unknown format — preserve as-is
+    return value;
+}
+function extractLocalMediaHash(value) {
+    if (value.startsWith("/")) {
+        const match = value.match(/^\/admin\/(?:media|images)\/([a-f0-9]{16})$/i);
+        return match ? match[1].toLowerCase() : null;
+    }
+    try {
+        const parsed = new URL(value);
+        if (!["http:", "https:"].includes(parsed.protocol))
+            return null;
+        if (!["localhost", "127.0.0.1", "::1"].includes(parsed.hostname))
+            return null;
+        const match = parsed.pathname.match(/^\/admin\/(?:media|images)\/([a-f0-9]{16})$/i);
+        return match ? match[1].toLowerCase() : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractMediaHashesFromSession(session) {
+    const hashes = new Set();
+    for (const message of session.messages) {
+        if (Array.isArray(message.images)) {
+            for (const imageRef of message.images) {
+                const hash = extractLocalMediaHash(imageRef);
+                if (hash)
+                    hashes.add(hash);
+            }
+        }
+        if (Array.isArray(message.content)) {
+            for (const part of message.content) {
+                if (part &&
+                    typeof part === "object" &&
+                    part.type === "image_url" &&
+                    part.image_url &&
+                    typeof part.image_url.url === "string") {
+                    const hash = extractLocalMediaHash(part.image_url.url);
+                    if (hash)
+                        hashes.add(hash);
+                }
+            }
+        }
+    }
+    return Array.from(hashes);
+}

package/dist/src/storage/statsRepository.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveStatsDir = resolveStatsDir;
+exports.ensureStatsDir = ensureStatsDir;
+exports.appendStats = appendStats;
+exports.readStatsForWindow = readStatsForWindow;
+exports.aggregateStats = aggregateStats;
+exports.rotateStats = rotateStats;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+function resolveStatsDir(paths) {
+    return path_1.default.join(paths.baseDir, "stats");
+}
+function formatDate(date) {
+    return date.toISOString().split("T")[0];
+}
+function getStatsFilePath(statsDir, date) {
+    return path_1.default.join(statsDir, `stats-${formatDate(date)}.jsonl`);
+}
+async function ensureStatsDir(paths) {
+    const statsDir = resolveStatsDir(paths);
+    await fs_1.promises.mkdir(statsDir, { recursive: true });
+}
+async function appendStats(paths, stats) {
+    await ensureStatsDir(paths);
+    const statsDir = resolveStatsDir(paths);
+    const filePath = getStatsFilePath(statsDir, stats.timestamp);
+    const line = `${JSON.stringify(stats)}\n`;
+    await fs_1.promises.appendFile(filePath, line, "utf8");
+}
+async function readStatsForWindow(paths, windowDays = 7) {
+    await ensureStatsDir(paths);
+    const statsDir = resolveStatsDir(paths);
+    const stats = [];
+    const now = new Date();
+    const cutoff = new Date(now.getTime() - windowDays * 24 * 60 * 60 * 1000);
+    // Read files for the window period
+    for (let i = 0; i <= windowDays; i++) {
+        const date = new Date(now.getTime() - i * 24 * 60 * 60 * 1000);
+        const filePath = getStatsFilePath(statsDir, date);
+        try {
+            const raw = await fs_1.promises.readFile(filePath, "utf8");
+            const lines = raw.split("\n").filter((line) => line.trim().length > 0);
+            for (const line of lines) {
+                try {
+                    const entry = JSON.parse(line);
+                    entry.timestamp = new Date(entry.timestamp);
+                    if (entry.timestamp >= cutoff) {
+                        stats.push(entry);
+                    }
+                }
+                catch {
+                    // Skip malformed lines
+                }
+            }
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    return stats.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+}
+async function aggregateStats(paths, windowMs = 7 * 24 * 60 * 60 * 1000) {
+    const windowDays = Math.ceil(windowMs / (24 * 60 * 60 * 1000));
+    const stats = await readStatsForWindow(paths, windowDays);
+    const cutoff = Date.now() - windowMs;
+    const filtered = stats.filter((s) => s.timestamp.getTime() >= cutoff);
+    if (filtered.length === 0) {
+        return {
+            window: formatWindowString(windowMs),
+            total: 0,
+            success: 0,
+            errors: 0,
+            avgLatencyMs: null,
+            p50LatencyMs: null,
+            p95LatencyMs: null,
+            p99LatencyMs: null,
+            totalTokens: 0,
+            tokensPerHour: null,
+            byModel: {},
+            byEndpoint: {}
+        };
+    }
+    const latencies = filtered.map((s) => s.latencyMs).sort((a, b) => a - b);
+    const successCount = filtered.filter((s) => !s.errorType && s.statusCode >= 200 && s.statusCode < 400).length;
+    const errorCount = filtered.filter((s) => s.errorType || s.statusCode >= 400).length;
+    let totalTokens = 0;
+    const byModel = {};
+    const byEndpoint = {};
+    for (const stat of filtered) {
+        const tokens = stat.totalTokens ?? 0;
+        totalTokens += tokens;
+        // Aggregate by model
+        if (stat.publicModel) {
+            if (!byModel[stat.publicModel]) {
+                byModel[stat.publicModel] = { count: 0, sumLatency: 0, tokens: 0 };
+            }
+            byModel[stat.publicModel].count += 1;
+            byModel[stat.publicModel].sumLatency += stat.latencyMs;
+            byModel[stat.publicModel].tokens += tokens;
+        }
+        // Aggregate by endpoint
+        if (stat.endpointId) {
+            if (!byEndpoint[stat.endpointId]) {
+                byEndpoint[stat.endpointId] = { count: 0, sumLatency: 0, tokens: 0, errors: 0, name: stat.endpointName ?? "unknown" };
+            }
+            byEndpoint[stat.endpointId].count += 1;
+            byEndpoint[stat.endpointId].sumLatency += stat.latencyMs;
+            byEndpoint[stat.endpointId].tokens += tokens;
+            if (stat.errorType || stat.statusCode >= 400) {
+                byEndpoint[stat.endpointId].errors += 1;
+            }
+        }
+    }
+    // Calculate percentiles
+    const p50 = percentile(latencies, 50);
+    const p95 = percentile(latencies, 95);
+    const p99 = percentile(latencies, 99);
+    const avgLatency = latencies.reduce((a, b) => a + b, 0) / latencies.length;
+    // Calculate tokens per hour
+    const windowHours = windowMs / (60 * 60 * 1000);
+    const tokensPerHour = windowHours > 0 ? totalTokens / windowHours : null;
+    // Transform aggregations to final format
+    const byModelFinal = {};
+    for (const [model, data] of Object.entries(byModel)) {
+        byModelFinal[model] = {
+            count: data.count,
+            avgLatencyMs: Math.round(data.sumLatency / data.count),
+            tokens: data.tokens
+        };
+    }
+    const byEndpointFinal = {};
+    for (const [id, data] of Object.entries(byEndpoint)) {
+        byEndpointFinal[id] = {
+            count: data.count,
+            avgLatencyMs: Math.round(data.sumLatency / data.count),
+            tokens: data.tokens,
+            errors: data.errors
+        };
+    }
+    return {
+        window: formatWindowString(windowMs),
+        total: filtered.length,
+        success: successCount,
+        errors: errorCount,
+        avgLatencyMs: Math.round(avgLatency),
+        p50LatencyMs: p50,
+        p95LatencyMs: p95,
+        p99LatencyMs: p99,
+        totalTokens,
+        tokensPerHour: tokensPerHour !== null ? Math.round(tokensPerHour) : null,
+        byModel: byModelFinal,
+        byEndpoint: byEndpointFinal
+    };
+}
+function percentile(sortedArr, p) {
+    if (sortedArr.length === 0)
+        return null;
+    const index = Math.ceil((p / 100) * sortedArr.length) - 1;
+    return Math.round(sortedArr[Math.max(0, index)]);
+}
+function formatWindowString(ms) {
+    const hours = ms / (60 * 60 * 1000);
+    if (hours < 24)
+        return `${Math.round(hours)}h`;
+    return `${Math.round(hours / 24)}d`;
+}
+/**
+ * Rotate stats files - delete files older than retentionDays
+ */
+async function rotateStats(paths, retentionDays = 30) {
+    await ensureStatsDir(paths);
+    const statsDir = resolveStatsDir(paths);
+    const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000);
+    let deleted = 0;
+    try {
+        const files = await fs_1.promises.readdir(statsDir);
+        for (const file of files) {
+            if (!file.startsWith("stats-") || !file.endsWith(".jsonl")) {
+                continue;
+            }
+            // Extract date from filename: stats-YYYY-MM-DD.jsonl
+            const match = file.match(/^stats-(\d{4}-\d{2}-\d{2})\.jsonl$/);
+            if (!match)
+                continue;
+            const fileDate = new Date(match[1]);
+            if (fileDate < cutoff) {
+                await fs_1.promises.unlink(path_1.default.join(statsDir, file));
+                deleted += 1;
+            }
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    return deleted;
+}

package/dist/src/transport/httpClient.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyUpstream = proxyUpstream;
+exports.classifyUpstreamError = classifyUpstreamError;
+exports.classifyHttpStatus = classifyHttpStatus;
+const undici_1 = require("undici");
+const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504]);
+const TLS_VERIFY_ERROR_CODES = new Set([
+    "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+    "SELF_SIGNED_CERT_IN_CHAIN",
+    "DEPTH_ZERO_SELF_SIGNED_CERT",
+    "CERT_HAS_EXPIRED",
+    "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+    "ERR_TLS_CERT_ALTNAME_INVALID",
+    "ERR_TLS_CERT_SIGNATURE_ALGORITHM_UNSUPPORTED",
+]);
+async function proxyUpstream(endpoint, path, payload, headers, timeoutMs, signal, options) {
+    const url = new URL(path, endpoint.baseUrl).toString();
+    const dispatcher = endpoint.insecureTls
+        ? new undici_1.Agent({ connect: { rejectUnauthorized: false } })
+        : undefined;
+    const requestHeaders = {
+        "content-type": "application/json",
+        accept: "application/json",
+        ...filterHeaders(headers)
+    };
+    if (endpoint.apiKey && !options?.skipDefaultAuth && !requestHeaders.authorization) {
+        requestHeaders.authorization = `Bearer ${endpoint.apiKey}`;
+    }
+    const response = await (0, undici_1.request)(url, {
+        method: "POST",
+        body: JSON.stringify(payload),
+        headers: requestHeaders,
+        dispatcher,
+        signal,
+        headersTimeout: timeoutMs,
+        bodyTimeout: timeoutMs
+    });
+    return {
+        statusCode: response.statusCode,
+        headers: response.headers,
+        body: response.body
+    };
+}
+function classifyUpstreamError(error) {
+    if (error instanceof Error) {
+        const err = error;
+        if (typeof err.type === "string" && typeof err.retryable === "boolean") {
+            return err;
+        }
+        const code = err.code;
+        if (isTlsVerifyError(err, code)) {
+            err.type = "tls_verify_failed";
+            err.retryable = true;
+            return err;
+        }
+        // Connection errors
+        if (code === "ECONNREFUSED" || code === "ECONNRESET" || code === "ETIMEDOUT" || code === "ENOTFOUND") {
+            err.type = "connection";
+            err.retryable = true;
+            return err;
+        }
+        // Undici timeout errors
+        if (code === "UND_ERR_HEADERS_TIMEOUT" || code === "UND_ERR_BODY_TIMEOUT" || code === "UND_ERR_CONNECT_TIMEOUT") {
+            err.type = "timeout";
+            err.retryable = true;
+            return err;
+        }
+        if (err.name === "AbortError") {
+            err.type = "timeout";
+            err.retryable = true;
+            return err;
+        }
+        // Socket/stream errors during transfer
+        if (code === "ERR_STREAM_PREMATURE_CLOSE" || code === "EPIPE" || code === "ECONNABORTED") {
+            err.type = "stream_error";
+            err.retryable = true;
+            return err;
+        }
+        err.type = "unknown";
+        err.retryable = false;
+        return err;
+    }
+    const fallback = new Error("Unknown upstream error");
+    fallback.type = "unknown";
+    fallback.retryable = false;
+    return fallback;
+}
+function isTlsVerifyError(error, code) {
+    if (code && TLS_VERIFY_ERROR_CODES.has(code)) {
+        return true;
+    }
+    const message = error.message.toLowerCase();
+    return (message.includes("unable to verify the first certificate") ||
+        message.includes("self-signed certificate") ||
+        message.includes("certificate verify failed"));
+}
+function classifyHttpStatus(statusCode) {
+    if (statusCode === 429) {
+        return { retryable: true, type: "rate_limited" };
+    }
+    if (RETRYABLE_STATUSES.has(statusCode)) {
+        return { retryable: true, type: "upstream_5xx" };
+    }
+    if ([400, 401, 403].includes(statusCode)) {
+        return { retryable: false, type: "upstream_4xx" };
+    }
+    if (statusCode >= 400) {
+        return { retryable: false, type: "upstream_4xx" };
+    }
+    return { retryable: false, type: "ok" };
+}
+function filterHeaders(headers) {
+    const filtered = {};
+    for (const [key, value] of Object.entries(headers)) {
+        if (!value) {
+            continue;
+        }
+        const lower = key.toLowerCase();
+        if (lower === "host" || lower === "content-length") {
+            continue;
+        }
+        filtered[lower] = Array.isArray(value) ? value.join(", ") : value;
+    }
+    return filtered;
+}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });