karajan-code 1.59.0 → 2.0.0

package/src/proxy/compression/pipeline.js

@@ -1,270 +0,0 @@
-/**
- * Compression pipeline orchestrator.
- *
- * 5-step pipeline: extract → dedup → deterministic → ai-compress → rebuild.
- *
- * @module
- */
-
-import { createHash } from "node:crypto";
-import { compressDeterministic } from "./deterministic/index.js";
-import { countTokens } from "./deterministic/utils.js";
-
-// ---------------------------------------------------------------------------
-// Hashing
-// ---------------------------------------------------------------------------
-
-/** SHA-256 hex digest of a string. */
-function sha256(text) {
-  return createHash("sha256").update(text).digest("hex");
-}
-
-// ---------------------------------------------------------------------------
-// Adaptive pressure
-// ---------------------------------------------------------------------------
-
-/**
- * Estimate context pressure and return the token threshold above which
- * tool_results should be compressed.
- *
- * @param {Array} messages - conversation messages
- * @param {number} modelMaxTokens - model context window size in tokens
- * @returns {{ ratio: number, threshold: number, level: string }}
- */
-export function estimatePressure(messages, modelMaxTokens) {
-  const totalTokens = countTokens(JSON.stringify(messages));
-  const ratio = totalTokens / modelMaxTokens;
-
-  if (ratio > 0.9) return { ratio, threshold: 200, level: "critical" };
-  if (ratio > 0.8) return { ratio, threshold: 200, level: "high" };
-  if (ratio >= 0.5) return { ratio, threshold: 500, level: "medium" };
-  return { ratio, threshold: 2000, level: "low" };
-}
-
-// ---------------------------------------------------------------------------
-// Caches
-// ---------------------------------------------------------------------------
-
-/** Cache: hash → compressed text (avoids re-compressing same content). */
-const compressionCache = new Map();
-
-/** Cache: hash → exact original string (preserves identical strings for KV cache warming). */
-const sessionCache = new Map();
-
-/** Reset caches (for testing). */
-export function _resetCaches() {
-  compressionCache.clear();
-  sessionCache.clear();
-}
-
-// ---------------------------------------------------------------------------
-// Deduplication
-// ---------------------------------------------------------------------------
-
-/**
- * Deduplicate tool results: if the same content (by hash) appeared in an
- * earlier turn, replace with a back-reference.
- *
- * @param {Array<{id: string, toolName: string, text: string, turnIndex: number}>} results
- * @returns {Map<string, string>} id → replacement text (only for deduped entries)
- */
-function dedup(results) {
-  const seen = new Map(); // hash → first turnIndex
-  const replacements = new Map();
-
-  for (const r of results) {
-    const hash = sha256(r.text);
-    if (seen.has(hash)) {
-      const firstTurn = seen.get(hash);
-      if (r.turnIndex > firstTurn) {
-        replacements.set(r.id, `[See turn ${firstTurn}, unchanged]`);
-      }
-    } else {
-      seen.set(hash, r.turnIndex);
-    }
-  }
-
-  return replacements;
-}
-
-// ---------------------------------------------------------------------------
-// Persist scheduler
-// ---------------------------------------------------------------------------
-
-/**
- * Create a debounced persistence scheduler for caches.
- *
- * @param {() => Promise<void>} flushFn - function that writes caches to disk
- * @param {number} intervalMs - debounce interval in ms
- * @returns {{ markDirty: () => void, flush: () => Promise<void>, destroy: () => void }}
- */
-export function createPersistScheduler(flushFn, intervalMs = 30_000) {
-  let timer = null;
-  let dirty = false;
-
-  const flush = async () => {
-    if (timer) {
-      clearTimeout(timer);
-      timer = null;
-    }
-    dirty = false;
-    await flushFn();
-  };
-
-  const markDirty = () => {
-    dirty = true;
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => flush(), intervalMs);
-  };
-
-  const onSignal = () => {
-    if (dirty) {
-      flush();
-    }
-  };
-
-  process.on("SIGTERM", onSignal);
-  process.on("SIGINT", onSignal);
-
-  const destroy = () => {
-    if (timer) {
-      clearTimeout(timer);
-      timer = null;
-    }
-    process.removeListener("SIGTERM", onSignal);
-    process.removeListener("SIGINT", onSignal);
-  };
-
-  return { markDirty, flush, destroy };
-}
-
-// ---------------------------------------------------------------------------
-// Main pipeline
-// ---------------------------------------------------------------------------
-
-/**
- * Compress tool_results in a request body using the 5-step pipeline.
- *
- * @param {object} body - parsed JSON request body
- * @param {object} adapter - provider adapter (extractToolResults, rebuildMessages)
- * @param {object} [config={}] - pipeline configuration
- * @param {number} [config.modelMaxTokens=200000] - model context window
- * @param {boolean} [config.aiEnabled=false] - whether AI compression is enabled
- * @param {Function} [config.compressWithAI] - AI compression function(text, toolName) → string
- * @returns {Promise<{ body: object, stats: object }>}
- */
-export async function compressRequest(body, adapter, config = {}) {
-  const {
-    modelMaxTokens = 200_000,
-    aiEnabled = false,
-    compressWithAI = null,
-  } = config;
-
-  const messages = body.messages || [];
-
-  const stats = {
-    originalTokens: 0,
-    compressedTokens: 0,
-    cacheHits: 0,
-    deterministicHits: 0,
-    aiHits: 0,
-  };
-
-  // Step 1: Extract
-  const toolResults = adapter.extractToolResults(messages);
-  if (!toolResults || toolResults.length === 0) {
-    return { body, stats };
-  }
-
-  // Adaptive pressure
-  const { threshold } = estimatePressure(messages, modelMaxTokens);
-
-  // Step 2: Dedup
-  const dedupMap = dedup(toolResults);
-
-  // Build compressed map: id → compressed text
-  const compressedMap = new Map();
-
-  for (const result of toolResults) {
-    const originalTokens = countTokens(result.text);
-    stats.originalTokens += originalTokens;
-
-    // Deduped?
-    if (dedupMap.has(result.id)) {
-      const replacement = dedupMap.get(result.id);
-      compressedMap.set(result.id, replacement);
-      stats.compressedTokens += countTokens(replacement);
-      continue;
-    }
-
-    // Below threshold? Keep original
-    if (originalTokens < threshold) {
-      stats.compressedTokens += originalTokens;
-      continue;
-    }
-
-    const hash = sha256(result.text);
-
-    // Check compression cache
-    if (compressionCache.has(hash)) {
-      const cached = compressionCache.get(hash);
-      compressedMap.set(result.id, cached);
-      stats.compressedTokens += countTokens(cached);
-      stats.cacheHits += 1;
-      continue;
-    }
-
-    // Check session cache (exact string reuse for KV warming)
-    if (sessionCache.has(hash)) {
-      stats.compressedTokens += originalTokens;
-      stats.cacheHits += 1;
-      continue;
-    }
-
-    // Step 3: Deterministic compression
-    let compressed = result.text;
-    let wasCompressed = false;
-
-    const det = compressDeterministic(result.text, result.toolName);
-    if (det.compressed) {
-      compressed = det.text;
-      wasCompressed = true;
-      stats.deterministicHits += 1;
-    }
-
-    // Step 4: AI compression (optional)
-    const compressedTokens = countTokens(compressed);
-    if (
-      aiEnabled &&
-      compressWithAI &&
-      compressedTokens >= threshold &&
-      !wasCompressed
-    ) {
-      try {
-        const aiResult = await compressWithAI(compressed, result.toolName);
-        if (aiResult && countTokens(aiResult) < compressedTokens) {
-          compressed = aiResult;
-          stats.aiHits += 1;
-        }
-      } catch {
-        // AI compression failed; keep deterministic result
-      }
-    }
-
-    if (compressed !== result.text) {
-      compressedMap.set(result.id, compressed);
-      compressionCache.set(hash, compressed);
-      stats.compressedTokens += countTokens(compressed);
-    } else {
-      // Not compressed — store in session cache for KV warming
-      sessionCache.set(hash, result.text);
-      stats.compressedTokens += originalTokens;
-    }
-  }
-
-  // Step 5: Rebuild
-  const rebuiltMessages = adapter.rebuildMessages(messages, compressedMap);
-  const newBody = { ...body, messages: rebuiltMessages };
-
-  return { body: newBody, stats };
-}

package/src/proxy/middleware/prompt-injector.js

@@ -1,165 +0,0 @@
-/**
- * Prompt Injection middleware for the KJ proxy.
- *
- * Intercepts API requests and injects additional content into the system
- * prompt on-the-fly, based on registered injection fragments.
- *
- * Supports Anthropic, OpenAI, and Gemini provider formats.
- */
-
-/**
- * Registry that holds keyed prompt-injection fragments.
- * Fragments are concatenated (newline-separated) when retrieved.
- */
-export class PromptInjectionRegistry {
-  /** @type {Map<string, string>} */
-  #entries = new Map();
-
-  /**
-   * Register a prompt fragment under the given key.
-   * Overwrites any previous value for that key.
-   * @param {string} key
-   * @param {string} content
-   */
-  register(key, content) {
-    this.#entries.set(key, content);
-  }
-
-  /**
-   * Remove a previously registered fragment.
-   * @param {string} key
-   */
-  unregister(key) {
-    this.#entries.delete(key);
-  }
-
-  /**
-   * Return all registered fragments concatenated with newlines.
-   * Returns empty string when registry is empty.
-   * @returns {string}
-   */
-  getAll() {
-    if (this.#entries.size === 0) return "";
-    return [...this.#entries.values()].join("\n");
-  }
-
-  /** Remove all registered fragments. */
-  clear() {
-    this.#entries.clear();
-  }
-}
-
-/**
- * Inject content into the system prompt for a given provider.
- * Mutates the parsed body object in-place.
- *
- * @param {object} parsed - Parsed JSON request body
- * @param {string} content - Content to inject
- * @param {string} provider - "anthropic" | "openai" | "gemini"
- */
-function injectSystemPrompt(parsed, content, provider) {
-  switch (provider) {
-    case "anthropic":
-      injectAnthropic(parsed, content);
-      break;
-    case "openai":
-      injectOpenAI(parsed, content);
-      break;
-    case "gemini":
-      injectGemini(parsed, content);
-      break;
-    default:
-      // Unknown provider — attempt OpenAI-style as a sensible default
-      injectOpenAI(parsed, content);
-      break;
-  }
-}
-
-/**
- * Anthropic: body.system is either a string or an array of content blocks.
- */
-function injectAnthropic(parsed, content) {
-  if (typeof parsed.system === "string") {
-    parsed.system = parsed.system + "\n" + content;
-  } else if (Array.isArray(parsed.system)) {
-    parsed.system.push({ type: "text", text: content });
-  } else {
-    // No system prompt yet — create one
-    parsed.system = content;
-  }
-}
-
-/**
- * OpenAI: messages[0] with role "system". Append to its content.
- */
-function injectOpenAI(parsed, content) {
-  if (!Array.isArray(parsed.messages) || parsed.messages.length === 0) {
-    parsed.messages = [{ role: "system", content }];
-    return;
-  }
-
-  const first = parsed.messages[0];
-  if (first.role === "system") {
-    first.content = (first.content || "") + "\n" + content;
-  } else {
-    // No system message — prepend one
-    parsed.messages.unshift({ role: "system", content });
-  }
-}
-
-/**
- * Gemini: body.systemInstruction.parts — append a new text part.
- */
-function injectGemini(parsed, content) {
-  if (!parsed.systemInstruction) {
-    parsed.systemInstruction = { parts: [{ text: content }] };
-    return;
-  }
-
-  if (!Array.isArray(parsed.systemInstruction.parts)) {
-    parsed.systemInstruction.parts = [];
-  }
-
-  parsed.systemInstruction.parts.push({ text: content });
-}
-
-/**
- * Create a proxy middleware that injects prompt fragments from the registry
- * into every API request's system prompt.
- *
- * @param {PromptInjectionRegistry} registry
- * @returns {(ctx: object, next: () => Promise<void>) => Promise<void>}
- */
-export function createPromptInjector(registry) {
-  return async function promptInjectorMiddleware(ctx, next) {
-    const content = registry.getAll();
-
-    // Nothing to inject — pass through unchanged
-    if (!content) {
-      return next();
-    }
-
-    // Only intercept POST requests with a body
-    if (ctx.req.method !== "POST" || !ctx.body) {
-      return next();
-    }
-
-    let parsed;
-    try {
-      parsed = JSON.parse(ctx.body);
-    } catch {
-      // Not valid JSON — pass through
-      return next();
-    }
-
-    injectSystemPrompt(parsed, content, ctx.provider);
-
-    const modified = JSON.stringify(parsed);
-    ctx.modifiedBody = modified;
-
-    // Recalculate Content-Length for the modified body
-    ctx.req.headers["content-length"] = String(Buffer.byteLength(modified));
-
-    return next();
-  };
-}

package/src/proxy/middleware/response-interceptor.js

@@ -1,223 +0,0 @@
-import { EventEmitter } from "node:events";
-
-/**
- * Create a response interceptor middleware that extracts tool calls, usage data,
- * and text content from AI provider responses without buffering.
- *
- * For SSE (text/event-stream) responses, it parses each "data: " line inline.
- * For non-streaming JSON responses, it parses the completed body.
- *
- * Events emitted on the provided EventEmitter:
- *   - tool_call        {name, id}
- *   - tool_call_complete {id}
- *   - text_delta       {text}
- *   - usage            {input_tokens, output_tokens}
- *   - message_complete {}
- *
- * @param {object} [config]
- * @param {EventEmitter} [config.emitter] - EventEmitter to emit events on (created if not provided)
- * @returns {{ middleware: (ctx: object, next: () => Promise<void>) => Promise<void>, emitter: EventEmitter }}
- */
-export function createResponseInterceptor(config = {}) {
-  const emitter = config.emitter || new EventEmitter();
-
-  // Track accumulated tool input per tool id
-  const toolInputBuffers = new Map();
-
-  function handleSSELine(line) {
-    if (!line.startsWith("data: ")) return;
-    const payload = line.slice(6).trim();
-    if (payload === "[DONE]") return;
-
-    let event;
-    try {
-      event = JSON.parse(payload);
-    } catch {
-      return; // Malformed JSON, skip
-    }
-
-    processAnthropicEvent(event);
-  }
-
-  function processAnthropicEvent(event) {
-    const type = event.type;
-
-    if (type === "content_block_start") {
-      const block = event.content_block;
-      if (block && block.type === "tool_use") {
-        toolInputBuffers.set(block.id, "");
-        emitter.emit("tool_call", { name: block.name, id: block.id });
-      }
-    } else if (type === "content_block_delta") {
-      const delta = event.delta;
-      if (delta && delta.type === "input_json_delta") {
-        const id = findActiveToolId(event);
-        if (id && toolInputBuffers.has(id)) {
-          toolInputBuffers.set(id, toolInputBuffers.get(id) + (delta.partial_json || ""));
-        }
-      } else if (delta && delta.type === "text_delta") {
-        emitter.emit("text_delta", { text: delta.text || "" });
-      }
-    } else if (type === "content_block_stop") {
-      const id = findActiveToolId(event);
-      if (id && toolInputBuffers.has(id)) {
-        toolInputBuffers.delete(id);
-        emitter.emit("tool_call_complete", { id });
-      }
-    } else if (type === "message_delta") {
-      if (event.usage) {
-        emitter.emit("usage", {
-          input_tokens: event.usage.input_tokens,
-          output_tokens: event.usage.output_tokens,
-        });
-      }
-    } else if (type === "message_start") {
-      if (event.message && event.message.usage) {
-        emitter.emit("usage", {
-          input_tokens: event.message.usage.input_tokens,
-          output_tokens: event.message.usage.output_tokens,
-        });
-      }
-    } else if (type === "message_stop") {
-      emitter.emit("message_complete", {});
-    }
-  }
-
-  /**
-   * Resolve the tool ID from the event. Anthropic events use `index` to refer
-   * to the content block, but we track by id. For events with an index, we map
-   * it to the id stored at creation time. To keep things simple and avoid
-   * maintaining an index->id map, we accept an explicit `id` field if present
-   * or fall back to the first (and often only) active tool.
-   */
-  function findActiveToolId(event) {
-    if (event.id) return event.id;
-    // Fall back to the first active tool (works for single-tool scenarios)
-    const keys = [...toolInputBuffers.keys()];
-    return keys.length > 0 ? keys[keys.length - 1] : null;
-  }
-
-  /**
-   * Process a non-streaming JSON response body.
-   */
-  function processJsonBody(bodyStr) {
-    let body;
-    try {
-      body = JSON.parse(bodyStr);
-    } catch {
-      return;
-    }
-
-    // Extract tool_use blocks from content array
-    if (Array.isArray(body.content)) {
-      for (const block of body.content) {
-        if (block.type === "tool_use") {
-          emitter.emit("tool_call", { name: block.name, id: block.id });
-          emitter.emit("tool_call_complete", { id: block.id });
-        } else if (block.type === "text") {
-          emitter.emit("text_delta", { text: block.text || "" });
-        }
-      }
-    }
-
-    // Extract usage
-    if (body.usage) {
-      emitter.emit("usage", {
-        input_tokens: body.usage.input_tokens,
-        output_tokens: body.usage.output_tokens,
-      });
-    }
-
-    emitter.emit("message_complete", {});
-  }
-
-  /**
-   * Middleware function compatible with the proxy server's Koa-style middleware.
-   * Wraps ctx.res.write and ctx.res.end to tap into the response stream.
-   */
-  async function middleware(ctx, next) {
-    const origWrite = ctx.res.write.bind(ctx.res);
-    const origEnd = ctx.res.end.bind(ctx.res);
-    const origWriteHead = ctx.res.writeHead.bind(ctx.res);
-
-    let isSSE = false;
-    let isJSON = false;
-    let lineBuf = ""; // Buffer for partial SSE lines across chunks
-    const jsonChunks = []; // Accumulate non-streaming JSON body
-
-    function processSSEChunk(text) {
-      lineBuf += text;
-      const lines = lineBuf.split("\n");
-      // Keep the last element as it may be incomplete
-      lineBuf = lines.pop() || "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed) {
-          handleSSELine(trimmed);
-        }
-      }
-    }
-
-    // Intercept writeHead to detect content-type
-    ctx.res.writeHead = function interceptWriteHead(statusCode, ...args) {
-      // headers can be in args[0] (object) or args[1] with reasonPhrase in args[0]
-      const headers = typeof args[0] === "object" ? args[0] : args[1];
-      const ct = findHeader(headers, "content-type") || "";
-      isSSE = ct.includes("text/event-stream");
-      isJSON = ct.includes("application/json");
-      return origWriteHead(statusCode, ...args);
-    };
-
-    // Intercept write to parse chunks inline
-    ctx.res.write = function interceptWrite(chunk, encoding, callback) {
-      if (isSSE) {
-        processSSEChunk(typeof chunk === "string" ? chunk : chunk.toString());
-      } else if (isJSON) {
-        jsonChunks.push(typeof chunk === "string" ? chunk : chunk.toString());
-      }
-      return origWrite(chunk, encoding, callback);
-    };
-
-    // Intercept end to handle final chunk and JSON body
-    ctx.res.end = function interceptEnd(chunk, encoding, callback) {
-      if (chunk) {
-        if (isSSE) {
-          processSSEChunk(typeof chunk === "string" ? chunk : chunk.toString());
-        } else if (isJSON) {
-          jsonChunks.push(typeof chunk === "string" ? chunk : chunk.toString());
-        }
-      }
-      // Flush remaining SSE buffer
-      if (isSSE && lineBuf.trim()) {
-        handleSSELine(lineBuf.trim());
-        lineBuf = "";
-      }
-      // Process complete JSON body
-      if (isJSON && jsonChunks.length > 0) {
-        processJsonBody(jsonChunks.join(""));
-      }
-      return origEnd(chunk, encoding, callback);
-    };
-
-    await next();
-  }
-
-  function findHeader(headers, name) {
-    if (!headers) return undefined;
-    // Headers might be an object or an array of [key, value] pairs
-    if (Array.isArray(headers)) {
-      for (let i = 0; i < headers.length; i += 2) {
-        if (typeof headers[i] === "string" && headers[i].toLowerCase() === name) {
-          return headers[i + 1];
-        }
-      }
-      return undefined;
-    }
-    for (const key of Object.keys(headers)) {
-      if (key.toLowerCase() === name) return headers[key];
-    }
-    return undefined;
-  }
-
-  return { middleware, emitter };
-}