clauderipple 0.2.0

package/dist/router/src/providers/openai/index.js

@@ -0,0 +1,193 @@
+// OpenAI-compatible adapter: Anthropic Messages in, vendor Chat Completions or
+// Responses SSE out, translated back to Anthropic Messages. It never synthesizes
+// cache figures; the request log reflects cached tokens only when the vendor sends them.
+import http from "node:http";
+import { credentialHeaderValues, redactErrorText } from "../../redact.js";
+import { SseParser } from "../chatgpt/sse.js";
+import { estimateTokens, formatSse, OpenAiStreamMapper, toOpenAiRequest } from "./translate.js";
+const PING_MS = 15_000;
+function anthropicError(status, type, message) {
+    return { status, body: JSON.stringify({ type: "error", error: { type, message } }) };
+}
+function vendorMessage(text) {
+    try {
+        const json = JSON.parse(text);
+        const candidate = json.error?.message ?? json.message ?? json.detail;
+        if (typeof candidate === "string")
+            return candidate.slice(0, 500);
+    }
+    catch { /* retain the response text */ }
+    return text.replace(/\s+/g, " ").trim().slice(0, 500) || "upstream request failed";
+}
+export function mapHttpError(status, text) {
+    const message = `OpenAI-compatible provider: ${vendorMessage(text)}`;
+    if (status === 401 || status === 403)
+        return anthropicError(401, "authentication_error", message);
+    if (status === 429)
+        return anthropicError(429, "rate_limit_error", message);
+    if (status >= 500)
+        return anthropicError(529, "api_error", message);
+    return anthropicError(400, "invalid_request_error", message);
+}
+function endpoint(base, wire) {
+    return `${base.replace(/\/+$/, "")}/${wire === "chat" ? "chat/completions" : "responses"}`;
+}
+function write(res, value) {
+    if (res.writableEnded || res.destroyed)
+        return 0;
+    res.write(value);
+    return Buffer.byteLength(value);
+}
+export class OpenAiCompatibleAdapter {
+    name;
+    cfg;
+    log;
+    lastInputByKey = new Map();
+    constructor(name, cfg, log) {
+        this.name = name;
+        this.cfg = cfg;
+        this.log = log;
+    }
+    rememberInput(key, usage) {
+        const total = usage.input_tokens + usage.cache_read_input_tokens;
+        if (total <= 0)
+            return;
+        this.lastInputByKey.set(key, total);
+        if (this.lastInputByKey.size > 500)
+            this.lastInputByKey.delete(this.lastInputByKey.keys().next().value);
+    }
+    /** Handle a fully-read Messages request. Model/effort have already been resolved by routing. */
+    async handle(req, res, path, json, model, effort) {
+        if (path.startsWith("/v1/messages/count_tokens")) {
+            const body = JSON.stringify({ input_tokens: estimateTokens(json) });
+            res.writeHead(200, { "content-type": "application/json", "content-length": String(Buffer.byteLength(body)) }).end(body);
+            return { status: 200, bytes: Buffer.byteLength(body), note: "estimated" };
+        }
+        const wire = this.cfg.wire ?? "chat";
+        const modelEffortLevels = this.cfg.models?.find((entry) => entry.id === model)?.effortLevels;
+        const caps = this.cfg.caps && modelEffortLevels === undefined
+            ? this.cfg.caps
+            : {
+                ...(this.cfg.caps ?? {}),
+                reasoning: modelEffortLevels && modelEffortLevels.length > 0 ? "effort" : "none",
+                effortLevels: modelEffortLevels ?? this.cfg.caps?.effortLevels ?? [],
+            };
+        const upstreamRequest = toOpenAiRequest(json, {
+            model,
+            wire,
+            ...(effort ? { effort } : {}),
+            caps,
+            ...(this.cfg.identity === undefined ? {} : { identity: this.cfg.identity }),
+            ...(this.cfg.instructionsAppend ? { instructionsAppend: this.cfg.instructionsAppend } : {}),
+        });
+        const requestBody = JSON.stringify(upstreamRequest);
+        const upstreamHeaders = { "content-type": "application/json", accept: "text/event-stream", ...(this.cfg.headers ?? {}) };
+        const upstreamSecrets = credentialHeaderValues(Object.entries(upstreamHeaders));
+        // Same input floor behavior as the ChatGPT adapter: the CLI snapshots message_start before usage arrives.
+        const key = JSON.stringify({ model, wire, system: json.system ?? "", user: json.messages.find((message) => message.role === "user")?.content ?? "" });
+        const startInput = Math.max(estimateTokens(json), this.lastInputByKey.get(key) ?? 0);
+        const controller = new AbortController();
+        const onClose = () => controller.abort();
+        res.on("close", onClose);
+        let upstream;
+        try {
+            upstream = await fetch(endpoint(this.cfg.url, wire), {
+                method: "POST",
+                headers: upstreamHeaders,
+                body: requestBody,
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            res.off("close", onClose);
+            if (controller.signal.aborted)
+                return { status: 0, bytes: 0, note: "client closed" };
+            const out = anthropicError(502, "api_error", `OpenAI-compatible provider unreachable: ${error.message}`);
+            if (!res.headersSent)
+                res.writeHead(out.status, { "content-type": "application/json" }).end(out.body);
+            throw error;
+        }
+        if (!upstream.ok || !upstream.body) {
+            const text = await upstream.text().catch(() => "");
+            const safeText = redactErrorText(text, upstreamSecrets);
+            const out = mapHttpError(upstream.status, safeText);
+            this.log.warn(`openai ${this.name}: upstream ${upstream.status} for ${model}: ${safeText.slice(0, 400)}`);
+            res.off("close", onClose);
+            res.writeHead(out.status, { "content-type": "application/json", "content-length": String(Buffer.byteLength(out.body)) }).end(out.body);
+            return { status: out.status, bytes: Buffer.byteLength(out.body), note: `upstream ${upstream.status}` };
+        }
+        const wantStream = json.stream === true;
+        const mapper = new OpenAiStreamMapper(model, startInput);
+        const parser = new SseParser();
+        const reader = upstream.body.getReader();
+        const decoder = new TextDecoder();
+        let bytes = 0;
+        let ping;
+        if (wantStream) {
+            res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
+            for (const event of mapper.start())
+                bytes += write(res, formatSse(event));
+            ping = setInterval(() => {
+                if (!res.writableEnded)
+                    bytes += write(res, formatSse({ event: "ping", data: { type: "ping" } }));
+            }, PING_MS);
+        }
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                for (const event of parser.feed(decoder.decode(value, { stream: true }))) {
+                    const output = mapper.feed(event, wire);
+                    this.rememberInput(key, mapper.usage);
+                    if (wantStream)
+                        for (const anthropic of output)
+                            bytes += write(res, formatSse(anthropic));
+                    if (mapper.isFinished)
+                        break;
+                }
+                if (mapper.isFinished)
+                    break;
+            }
+            if (!mapper.isFinished) {
+                const tail = mapper.finish();
+                if (wantStream)
+                    for (const event of tail)
+                        bytes += write(res, formatSse(event));
+            }
+        }
+        catch (error) {
+            if (!controller.signal.aborted) {
+                const tail = mapper.fail(`stream interrupted: ${error.message}`);
+                if (wantStream)
+                    for (const event of tail)
+                        bytes += write(res, formatSse(event));
+            }
+        }
+        finally {
+            if (ping)
+                clearInterval(ping);
+            res.off("close", onClose);
+            try {
+                await reader.cancel();
+            }
+            catch { /* already closed */ }
+        }
+        if (!wantStream) {
+            const body = JSON.stringify(mapper.message());
+            bytes = Buffer.byteLength(body);
+            res.writeHead(200, { "content-type": "application/json", "content-length": String(bytes) }).end(body);
+        }
+        else if (!res.writableEnded) {
+            res.end();
+        }
+        const usage = mapper.usage;
+        return {
+            status: 200,
+            bytes,
+            note: `in=${usage.input_tokens} cached=${usage.cache_read_input_tokens} out=${usage.output_tokens} stop=${mapper.stopReason}`,
+            usage: { input: usage.input_tokens, cached: usage.cache_read_input_tokens, output: usage.output_tokens },
+            stopReason: mapper.stopReason,
+        };
+    }
+}