@loreai/gateway 0.14.0 → 0.14.1

package/src/server.ts

@@ -1,250 +0,0 @@
-/**
- * HTTP server for the Lore gateway proxy.
- *
- * Routes:
- *   POST /v1/messages          → Anthropic protocol (Phase 1)
- *   POST /v1/chat/completions  → OpenAI protocol (Phase 2 stub)
- *   GET  /v1/models            → Passthrough to upstream
- *   GET  /health               → Health check
- *
- * Uses `Bun.serve()` — this package targets Bun exclusively.
- */
-import type { GatewayConfig } from "./config";
-import type { GatewayRequest } from "./translate/types";
-import { parseAnthropicRequest } from "./translate/anthropic";
-import { parseOpenAIRequest, buildOpenAIResponse } from "./translate/openai";
-import { accumulateSSEResponse } from "./stream/anthropic";
-import { handleRequest } from "./pipeline";
-
-// ---------------------------------------------------------------------------
-// Version — best-effort from package.json, falls back gracefully
-// ---------------------------------------------------------------------------
-
-let version = "unknown";
-try {
-  // Bun resolves JSON imports; use require for sync + no top-level await
-  const pkg = require("../package.json") as { version?: string };
-  if (pkg.version) version = pkg.version;
-} catch {
-  // Not critical — health endpoint will report "unknown"
-}
-
-// ---------------------------------------------------------------------------
-// CORS headers — permissive for localhost development
-// ---------------------------------------------------------------------------
-
-const CORS_HEADERS: Record<string, string> = {
-  "access-control-allow-origin": "*",
-  "access-control-allow-methods": "GET, POST, OPTIONS",
-  "access-control-allow-headers": "*",
-  "access-control-max-age": "86400",
-};
-
-function withCors(response: Response): Response {
-  for (const [key, value] of Object.entries(CORS_HEADERS)) {
-    response.headers.set(key, value);
-  }
-  return response;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Convert Bun's Headers object to a plain Record<string, string>. */
-function headersToRecord(headers: Headers): Record<string, string> {
-  const record: Record<string, string> = {};
-  headers.forEach((value, key) => {
-    record[key] = value;
-  });
-  return record;
-}
-
-function jsonResponse(body: unknown, status = 200): Response {
-  return withCors(
-    new Response(JSON.stringify(body), {
-      status,
-      headers: { "content-type": "application/json" },
-    }),
-  );
-}
-
-function errorResponse(
-  status: number,
-  type: string,
-  message: string,
-): Response {
-  return jsonResponse(
-    {
-      type: "error",
-      error: { type, message },
-    },
-    status,
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Route handlers
-// ---------------------------------------------------------------------------
-
-async function handleAnthropicMessages(
-  req: Request,
-  config: GatewayConfig,
-): Promise<Response> {
-  let body: unknown;
-  try {
-    body = await req.json();
-  } catch {
-    return errorResponse(400, "invalid_request_error", "Invalid JSON body");
-  }
-
-  let gatewayReq: GatewayRequest;
-  try {
-    gatewayReq = parseAnthropicRequest(body, headersToRecord(req.headers));
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : "Failed to parse request";
-    return errorResponse(400, "invalid_request_error", msg);
-  }
-
-  try {
-    const result = await handleRequest(gatewayReq, config);
-    // Pipeline returns a Response directly (streaming or non-streaming)
-    return withCors(result);
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : "Pipeline error";
-    console.error(`[lore] pipeline error: ${msg}`);
-    return errorResponse(502, "api_error", `Gateway pipeline error: ${msg}`);
-  }
-}
-
-async function handleModelsPassthrough(config: GatewayConfig): Promise<Response> {
-  try {
-    const upstream = await fetch(`${config.upstreamAnthropic}/v1/models`, {
-      headers: { "content-type": "application/json" },
-    });
-    // Clone to a new Response so we can append CORS headers
-    const response = new Response(upstream.body, {
-      status: upstream.status,
-      statusText: upstream.statusText,
-      headers: new Headers(upstream.headers),
-    });
-    return withCors(response);
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : "Upstream unreachable";
-    return errorResponse(502, "api_error", `Failed to fetch models: ${msg}`);
-  }
-}
-
-function handleHealth(): Response {
-  return jsonResponse({ status: "ok", version });
-}
-
-async function handleOpenAIChatCompletions(
-  req: Request,
-  config: GatewayConfig,
-): Promise<Response> {
-  let body: unknown;
-  try {
-    body = await req.json();
-  } catch {
-    return errorResponse(400, "invalid_request_error", "Invalid JSON body");
-  }
-
-  let gatewayReq: GatewayRequest;
-  try {
-    gatewayReq = parseOpenAIRequest(body, headersToRecord(req.headers));
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : "Failed to parse request";
-    return errorResponse(400, "invalid_request_error", msg);
-  }
-
-  let pipelineResp: Response;
-  try {
-    pipelineResp = await handleRequest(gatewayReq, config);
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : "Pipeline error";
-    console.error(`[lore] pipeline error: ${msg}`);
-    return errorResponse(502, "api_error", `Gateway pipeline error: ${msg}`);
-  }
-
-  // Pipeline always returns internal Anthropic-format response.
-  // Translate back to OpenAI format before returning to the client.
-  if (!pipelineResp.ok) {
-    // Upstream or pipeline error — forward as-is
-    return withCors(pipelineResp);
-  }
-
-  const contentType = pipelineResp.headers.get("content-type") ?? "";
-  if (contentType.includes("text/event-stream")) {
-    // Streaming: accumulate the internal SSE then re-emit as OpenAI SSE
-    const accumulated = await accumulateSSEResponse(pipelineResp);
-    return withCors(buildOpenAIResponse(accumulated, true));
-  }
-
-  // Non-streaming: translate JSON body
-  const respBody = await pipelineResp.json();
-  return withCors(buildOpenAIResponse(respBody, false));
-}
-
-// ---------------------------------------------------------------------------
-// Server
-// ---------------------------------------------------------------------------
-
-export function startServer(config: GatewayConfig): {
-  stop: () => void;
-  port: number;
-} {
-  const server = Bun.serve({
-    port: config.port,
-    hostname: config.host,
-
-    async fetch(req: Request): Promise<Response> {
-      const url = new URL(req.url);
-      const { pathname } = url;
-      const method = req.method;
-
-      // CORS preflight
-      if (method === "OPTIONS") {
-        return withCors(new Response(null, { status: 204 }));
-      }
-
-      if (config.debug) {
-        console.error(`[lore] ${method} ${pathname}`);
-      }
-
-      try {
-        // POST /v1/messages — Anthropic protocol
-        if (method === "POST" && pathname === "/v1/messages") {
-          return await handleAnthropicMessages(req, config);
-        }
-
-        // POST /v1/chat/completions — OpenAI protocol
-        if (method === "POST" && pathname === "/v1/chat/completions") {
-          return await handleOpenAIChatCompletions(req, config);
-        }
-
-        // GET /v1/models — passthrough
-        if (method === "GET" && pathname === "/v1/models") {
-          return await handleModelsPassthrough(config);
-        }
-
-        // GET /health — health check
-        if (method === "GET" && pathname === "/health") {
-          return handleHealth();
-        }
-
-        // 404 for everything else
-        return errorResponse(404, "not_found", `No route for ${method} ${pathname}`);
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : "Internal server error";
-        console.error(`[lore] uncaught error: ${msg}`);
-        return errorResponse(500, "api_error", msg);
-      }
-    },
-  });
-
-  return {
-    stop: () => server.stop(),
-    port: server.port ?? config.port,
-  };
-}

package/src/session.ts

@@ -1,207 +0,0 @@
-/**
- * Session identification for the Lore gateway proxy.
- *
- * Raw LLM API requests carry no session ID, so the gateway injects a
- * text-block marker `[lore:<base62>]` into the first response of a new
- * session. Subsequent requests from the same session echo it back in
- * the message history, allowing the gateway to correlate turns.
- *
- * The session ID packs 8 random bytes + 4 bytes of unix timestamp
- * (seconds, big-endian) into 12 bytes, then base62-encodes them to a
- * compact alphanumeric string (~17 chars).
- *
- * A SHA-256 fingerprint of the first user message serves as a
- * belt-and-suspenders fallback for sessions that haven't received their
- * marker yet (e.g. the very first request before any response).
- *
- * This module has zero dependencies on `@loreai/core` — pure utility.
- */
-
-// ---------------------------------------------------------------------------
-// Base62 encoding
-// ---------------------------------------------------------------------------
-
-const BASE62_ALPHABET =
-  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-const BASE = 62n;
-
-/**
- * Encode a byte array to a base62 string.
- *
- * Interprets `bytes` as an unsigned big-endian integer, then repeatedly
- * divmods by 62, mapping each remainder to `BASE62_ALPHABET`. The result
- * is reversed so the most-significant digit comes first and zero-padded
- * to `minLength` for consistent output width.
- */
-export function base62Encode(bytes: Uint8Array, minLength = 0): string {
-  let n = 0n;
-  for (const b of bytes) {
-    n = (n << 8n) | BigInt(b);
-  }
-
-  if (n === 0n) return BASE62_ALPHABET[0].repeat(Math.max(1, minLength));
-
-  const chars: string[] = [];
-  while (n > 0n) {
-    chars.push(BASE62_ALPHABET[Number(n % BASE)]);
-    n /= BASE;
-  }
-
-  chars.reverse();
-
-  // Pad to minLength for consistent width
-  while (chars.length < minLength) {
-    chars.unshift(BASE62_ALPHABET[0]);
-  }
-
-  return chars.join("");
-}
-
-// ---------------------------------------------------------------------------
-// Session ID generation
-// ---------------------------------------------------------------------------
-
-/** 12 bytes → base62 → at most 17 alphanumeric characters. */
-const SESSION_ID_MIN_LENGTH = 17;
-
-/**
- * Generate a new session ID.
- *
- * Layout (12 bytes):
- *   [0..7]  — 8 random bytes (session hash)
- *   [8..11] — 4 bytes unix timestamp (seconds, big-endian)
- */
-export function generateSessionID(): string {
-  const buf = new Uint8Array(12);
-  crypto.getRandomValues(buf.subarray(0, 8));
-
-  const ts = Math.floor(Date.now() / 1000);
-  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-  view.setUint32(8, ts >>> 0, false); // big-endian
-
-  return base62Encode(buf, SESSION_ID_MIN_LENGTH);
-}
-
-// ---------------------------------------------------------------------------
-// Marker formatting / parsing
-// ---------------------------------------------------------------------------
-
-const MARKER_RE = /\[lore:([a-zA-Z0-9]+)\]/;
-
-/** Format a session ID as the injectable text marker. */
-export function formatMarker(sessionID: string): string {
-  return `[lore:${sessionID}]`;
-}
-
-/**
- * Extract a session ID from a marker string, or `null` if the text
- * does not contain a valid marker.
- */
-export function parseMarker(text: string): string | null {
-  const m = MARKER_RE.exec(text);
-  return m ? m[1] : null;
-}
-
-// ---------------------------------------------------------------------------
-// Message scanning
-// ---------------------------------------------------------------------------
-
-/**
- * Extract text from a single message's content field.
- *
- * Handles both Anthropic-style content (array of `{type:"text", text}` blocks)
- * and OpenAI-style content (plain string).
- */
-function extractTextParts(content: unknown): string[] {
-  if (typeof content === "string") return [content];
-
-  if (Array.isArray(content)) {
-    const texts: string[] = [];
-    for (const block of content) {
-      if (
-        block &&
-        typeof block === "object" &&
-        "type" in block &&
-        block.type === "text" &&
-        "text" in block &&
-        typeof block.text === "string"
-      ) {
-        texts.push(block.text);
-      }
-    }
-    return texts;
-  }
-
-  return [];
-}
-
-/**
- * Scan a message array for a `[lore:<sessionID>]` marker inside any
- * text content block. Returns the extracted session ID or `null`.
- */
-export function scanForMarker(
-  messages: Array<{ role: string; content: unknown }>,
-): string | null {
-  for (const msg of messages) {
-    for (const text of extractTextParts(msg.content)) {
-      const id = parseMarker(text);
-      if (id) return id;
-    }
-  }
-  return null;
-}
-
-// ---------------------------------------------------------------------------
-// Fingerprinting (fallback)
-// ---------------------------------------------------------------------------
-
-/**
- * Compute a SHA-256 fingerprint from the first user message's content,
- * optionally incorporating the model name and an auth credential suffix.
- *
- * Returns the first 16 hex characters of the hash. Used as the primary
- * session correlator — combined with message-count proximity to
- * disambiguate forked sessions that share the same first message.
- *
- * Including `model` and `authSuffix` ensures that a key change or model
- * switch creates a new session rather than reusing an existing one.
- */
-export async function fingerprintMessages(
-  messages: Array<{ role: string; content: unknown }>,
-  extras?: { model?: string; authSuffix?: string },
-): Promise<string> {
-  let firstUserContent = "";
-  for (const msg of messages) {
-    if (msg.role === "user") {
-      const texts = extractTextParts(msg.content);
-      firstUserContent = texts.join("");
-      break;
-    }
-  }
-
-  const material =
-    firstUserContent + (extras?.model ?? "") + (extras?.authSuffix ?? "");
-  const encoded = new TextEncoder().encode(material);
-  const hash = await crypto.subtle.digest("SHA-256", encoded);
-  const bytes = new Uint8Array(hash);
-
-  // First 16 hex chars (8 bytes)
-  let hex = "";
-  for (let i = 0; i < 8; i++) {
-    hex += bytes[i].toString(16).padStart(2, "0");
-  }
-  return hex;
-}
-
-// ---------------------------------------------------------------------------
-// Message-count proximity matching
-// ---------------------------------------------------------------------------
-
-/**
- * Maximum message count difference for two requests to be considered
- * part of the same session. Normal turns add 2–6 messages (user +
- * assistant + tool calls); a forked session drops to the fork point.
- * A threshold of 20 accommodates bursts of tool-call messages while
- * reliably distinguishing forks (which typically differ by 50+).
- */
-export const MESSAGE_COUNT_PROXIMITY_THRESHOLD = 20;