@goodandready/dsh-key-rotation 0.8.76 → 0.8.78

package/lib/transports/anthropic.js

@@ -0,0 +1,125 @@
+// lib/transports/anthropic.js — Anthropic Claude Messages wire protocol parsing (#546).
+// Handles event discrimination, text/thinking deltas, and split-event usage accumulation.
+
+import { normalizeUsageTokens } from './tokens.js';
+
+/**
+ * Parses an Anthropic event payload.
+ * @param {string|object} data
+ * @returns {object|null}
+ */
+export function parseAnthropicEvent(data) {
+  if (!data) return null;
+  if (typeof data === 'object') return data;
+  if (typeof data !== 'string') return null;
+
+  const trimmed = data.trim();
+  if (!trimmed) return null;
+
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extracts content or reasoning delta from an Anthropic event.
+ * @param {object} event
+ * @returns {{
+ *   type: string,
+ *   text: string|null,
+ *   thinking: string|null,
+ *   partialJson: string|null,
+ *   stopReason: string|null
+ * }}
+ */
+export function extractAnthropicDelta(event) {
+  if (!event || typeof event !== 'object') {
+    return { type: 'unknown', text: null, thinking: null, partialJson: null, stopReason: null };
+  }
+
+  const type = event.type || 'unknown';
+
+  if (type === 'content_block_delta') {
+    const delta = event.delta || {};
+    const deltaType = delta.type;
+    return {
+      type,
+      text: deltaType === 'text_delta' && typeof delta.text === 'string' ? delta.text : null,
+      thinking: deltaType === 'thinking_delta' && typeof delta.thinking === 'string' ? delta.thinking : null,
+      partialJson: deltaType === 'input_json_delta' && typeof delta.partial_json === 'string' ? delta.partial_json : null,
+      stopReason: null,
+    };
+  }
+
+  if (type === 'message_delta') {
+    return {
+      type,
+      text: null,
+      thinking: null,
+      partialJson: null,
+      stopReason: event.delta?.stop_reason ?? null,
+    };
+  }
+
+  return { type, text: null, thinking: null, partialJson: null, stopReason: null };
+}
+
+/**
+ * Creates an accumulator for Anthropic streaming usage.
+ * Anthropic provides input tokens at `message_start` and output tokens at `message_delta`.
+ *
+ * @returns {{
+ *   accumulate: (event: object) => void,
+ *   getUsage: () => object,
+ *   reset: () => void
+ * }}
+ */
+export function createAnthropicUsageAccumulator() {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheReadTokens = 0;
+  let cacheWriteTokens = 0;
+  let rawStart = null;
+  let rawDelta = null;
+
+  function accumulate(event) {
+    if (!event || typeof event !== 'object') return;
+
+    if (event.type === 'message_start' && event.message?.usage) {
+      rawStart = event.message.usage;
+      const norm = normalizeUsageTokens(rawStart);
+      inputTokens = norm.inputTokens;
+      cacheReadTokens = norm.cacheReadTokens;
+      cacheWriteTokens = norm.cacheWriteTokens;
+    } else if (event.type === 'message_delta' && event.usage) {
+      rawDelta = event.usage;
+      const norm = normalizeUsageTokens(rawDelta);
+      outputTokens = norm.outputTokens;
+    }
+  }
+
+  function getUsage() {
+    const total = inputTokens + outputTokens;
+    return {
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      totalTokens: total,
+      raw: { start: rawStart, delta: rawDelta },
+    };
+  }
+
+  function reset() {
+    inputTokens = 0;
+    outputTokens = 0;
+    cacheReadTokens = 0;
+    cacheWriteTokens = 0;
+    rawStart = null;
+    rawDelta = null;
+  }
+
+  return { accumulate, getUsage, reset };
+}

package/lib/transports/index.js

@@ -0,0 +1,23 @@
+// lib/transports/index.js — Unified network transports and token normalization layer (#546).
+
+export {
+  normalizeUsageTokens,
+  extractTotalTokens,
+} from './tokens.js';
+
+export {
+  createSseDecoder,
+  parseSseStream,
+} from './sse.js';
+
+export {
+  parseOpenAiChunk,
+  extractOpenAiDelta,
+  extractOpenAiUsage,
+} from './openai.js';
+
+export {
+  parseAnthropicEvent,
+  extractAnthropicDelta,
+  createAnthropicUsageAccumulator,
+} from './anthropic.js';

package/lib/transports/openai.js

@@ -0,0 +1,93 @@
+// lib/transports/openai.js — OpenAI wire protocol parsing (#546).
+// Handles JSON deltas, reasoning streams, tool calls, and usage payloads.
+
+import { normalizeUsageTokens } from './tokens.js';
+
+/**
+ * Parses an OpenAI streaming JSON data chunk.
+ * @param {string|object} data
+ * @returns {object|null}
+ */
+export function parseOpenAiChunk(data) {
+  if (!data) return null;
+  if (typeof data === 'object') return data;
+  if (typeof data !== 'string') return null;
+
+  const trimmed = data.trim();
+  if (!trimmed || trimmed === '[DONE]') return null;
+
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extracts content delta, reasoning delta, and tool calls from an OpenAI chunk.
+ * @param {object} chunk
+ * @returns {{
+ *   content: string|null,
+ *   reasoningContent: string|null,
+ *   toolCalls: Array<object>|null,
+ *   finishReason: string|null
+ * }}
+ */
+export function extractOpenAiDelta(chunk) {
+  if (!chunk || typeof chunk !== 'object') {
+    return {
+      content: null,
+      reasoningContent: null,
+      toolCalls: null,
+      finishReason: null,
+    };
+  }
+
+  const choice = Array.isArray(chunk.choices) ? chunk.choices[0] : null;
+  if (!choice) {
+    return {
+      content: null,
+      reasoningContent: null,
+      toolCalls: null,
+      finishReason: null,
+    };
+  }
+
+  const delta = choice.delta ?? {};
+  const finishReason = choice.finish_reason ?? null;
+
+  const content = typeof delta.content === 'string' ? delta.content : null;
+
+  // Support reasoning fields: DeepSeek reasoning_content, OpenAI thought/reasoning
+  const reasoningContent =
+    typeof delta.reasoning_content === 'string'
+      ? delta.reasoning_content
+      : typeof delta.reasoning === 'string'
+        ? delta.reasoning
+        : typeof delta.thought === 'string'
+          ? delta.thought
+          : null;
+
+  const toolCalls = Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0
+    ? delta.tool_calls
+    : null;
+
+  return {
+    content,
+    reasoningContent,
+    toolCalls,
+    finishReason,
+  };
+}
+
+/**
+ * Extracts and normalizes usage from an OpenAI chunk (e.g. stream_options.include_usage).
+ * @param {object} chunk
+ * @returns {object|null}
+ */
+export function extractOpenAiUsage(chunk) {
+  if (!chunk || typeof chunk !== 'object') return null;
+  const usage = chunk.usage;
+  if (!usage || typeof usage !== 'object') return null;
+  return normalizeUsageTokens(usage);
+}

package/lib/transports/sse.js

@@ -0,0 +1,160 @@
+// lib/transports/sse.js — Server-Sent Events stream decoder (#546).
+// Zero-dependency streaming parser with buffering, multi-line data support, and AbortSignal awareness.
+
+/**
+ * Creates a stateful SSE stream decoder.
+ * @param {object} [options]
+ * @param {(event: { event: string, data: string, id?: string, retry?: number }) => void} [options.onEvent]
+ * @param {(err: Error) => void} [options.onError]
+ * @returns {{ feed: (chunk: string | Uint8Array | Buffer) => void, flush: () => void, reset: () => void }}
+ */
+export function createSseDecoder(options = {}) {
+  const { onEvent, onError } = options;
+  let buffer = '';
+  let eventType = 'message';
+  let dataLines = [];
+  let eventId = undefined;
+  let retry = undefined;
+
+  function dispatchCurrent() {
+    if (dataLines.length === 0) return;
+    const dataStr = dataLines.join('\n');
+    eventType = eventType || 'message';
+
+    // Discard standard SSE end-of-stream signal
+    if (dataStr.trim() !== '[DONE]' && typeof onEvent === 'function') {
+      try {
+        onEvent({
+          event: eventType,
+          data: dataStr,
+          id: eventId,
+          retry,
+        });
+      } catch (err) {
+        if (typeof onError === 'function') onError(err);
+      }
+    }
+
+    eventType = 'message';
+    dataLines = [];
+  }
+
+  function processLine(rawLine) {
+    let line = rawLine;
+    if (line.endsWith('\r')) line = line.slice(0, -1);
+
+    // Empty line signals dispatch of current event buffer
+    if (!line) {
+      dispatchCurrent();
+      return;
+    }
+
+    // Comment line: ignored per SSE spec
+    if (line.startsWith(':')) return;
+
+    const colonIdx = line.indexOf(':');
+    let field = line;
+    let value = '';
+
+    if (colonIdx !== -1) {
+      field = line.slice(0, colonIdx);
+      value = line.slice(colonIdx + 1);
+      if (value.startsWith(' ')) value = value.slice(1);
+    }
+
+    if (field === 'event') {
+      eventType = value;
+    } else if (field === 'data') {
+      dataLines.push(value);
+    } else if (field === 'id') {
+      eventId = value;
+    } else if (field === 'retry') {
+      const parsed = parseInt(value, 10);
+      if (Number.isFinite(parsed) && parsed >= 0) retry = parsed;
+    }
+  }
+
+  function feed(chunk) {
+    if (chunk == null) return;
+    const str = typeof chunk === 'string'
+      ? chunk
+      : (chunk instanceof Uint8Array || Buffer.isBuffer(chunk)
+        ? Buffer.from(chunk).toString('utf-8')
+        : String(chunk));
+
+    buffer += str;
+    let newlineIdx;
+    while ((newlineIdx = buffer.indexOf('\n')) !== -1) {
+      const line = buffer.slice(0, newlineIdx);
+      buffer = buffer.slice(newlineIdx + 1);
+      processLine(line);
+    }
+  }
+
+  function flush() {
+    if (buffer.length > 0) {
+      const line = buffer;
+      buffer = '';
+      processLine(line);
+    }
+    dispatchCurrent();
+  }
+
+  function reset() {
+    buffer = '';
+    eventType = 'message';
+    dataLines = [];
+    eventId = undefined;
+    retry = undefined;
+  }
+
+  return { feed, flush, reset };
+}
+
+/**
+ * Async generator that consumes an async iterable of chunks and yields parsed SSE event objects.
+ * Handles AbortSignal cleanly.
+ *
+ * @param {AsyncIterable<Uint8Array | string>} asyncIterable
+ * @param {AbortSignal} [signal]
+ * @returns {AsyncGenerator<{ event: string, data: string, id?: string, retry?: number }>}
+ */
+export async function* parseSseStream(asyncIterable, signal) {
+  if (!asyncIterable) return;
+
+  const queue = [];
+  let error = null;
+
+  const decoder = createSseDecoder({
+    onEvent: (evt) => queue.push(evt),
+    onError: (err) => { error = err; },
+  });
+
+  const checkAbort = () => {
+    if (signal?.aborted) {
+      const abortError = new Error(signal.reason?.message ?? 'SSE stream aborted');
+      abortError.name = 'AbortError';
+      throw abortError;
+    }
+  };
+
+  try {
+    for await (const chunk of asyncIterable) {
+      checkAbort();
+      decoder.feed(chunk);
+      if (error) throw error;
+      while (queue.length > 0) {
+        checkAbort();
+        yield queue.shift();
+      }
+    }
+    decoder.flush();
+    if (error) throw error;
+    while (queue.length > 0) {
+      checkAbort();
+      yield queue.shift();
+    }
+  } finally {
+    decoder.reset();
+  }
+}

package/lib/transports/tokens.js

@@ -0,0 +1,124 @@
+// lib/transports/tokens.js — canonical usage token normalization (#546).
+// Converts diverse provider token usage shapes into canonical DSH token metrics.
+
+function toNonNegativeInt(val) {
+  if (typeof val === 'number' && Number.isFinite(val) && val >= 0) {
+    return Math.floor(val);
+  }
+  if (typeof val === 'string') {
+    const parsed = parseInt(val, 10);
+    if (Number.isFinite(parsed) && parsed >= 0) return parsed;
+  }
+  return null;
+}
+
+/**
+ * Normalizes provider token usage payloads into canonical DSH shape:
+ * {
+ *   inputTokens: number,
+ *   outputTokens: number,
+ *   cacheReadTokens: number,
+ *   cacheWriteTokens: number,
+ *   totalTokens: number,
+ *   raw: object
+ * }
+ *
+ * Supports OpenAI, Anthropic, Gemini, Ollama, DeepSeek, and generic formats.
+ *
+ * @param {object|null|undefined} usage Raw usage object from provider
+ * @returns {{
+ *   inputTokens: number,
+ *   outputTokens: number,
+ *   cacheReadTokens: number,
+ *   cacheWriteTokens: number,
+ *   totalTokens: number,
+ *   raw: object
+ * }}
+ */
+export function normalizeUsageTokens(usage) {
+  if (!usage || typeof usage !== 'object') {
+    return {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      totalTokens: 0,
+      raw: usage ?? {},
+    };
+  }
+
+  // 1. Input / prompt tokens
+  const input =
+    toNonNegativeInt(usage.inputTokens) ??
+    toNonNegativeInt(usage.input_tokens) ??
+    toNonNegativeInt(usage.prompt_tokens) ??
+    toNonNegativeInt(usage.promptTokenCount) ??
+    toNonNegativeInt(usage.prompt_eval_count) ??
+    0;
+
+  // 2. Output / completion tokens
+  const output =
+    toNonNegativeInt(usage.outputTokens) ??
+    toNonNegativeInt(usage.output_tokens) ??
+    toNonNegativeInt(usage.completion_tokens) ??
+    toNonNegativeInt(usage.candidatesTokenCount) ??
+    toNonNegativeInt(usage.eval_count) ??
+    0;
+
+  // 3. Cache read tokens
+  const cacheRead =
+    toNonNegativeInt(usage.cacheReadTokens) ??
+    toNonNegativeInt(usage.cache_read_input_tokens) ??
+    toNonNegativeInt(usage.prompt_tokens_details?.cached_tokens) ??
+    toNonNegativeInt(usage.cached_tokens) ??
+    toNonNegativeInt(usage.prompt_cache_hit_tokens) ??
+    toNonNegativeInt(usage.cachedContentTokenCount) ??
+    0;
+
+  // 4. Cache write / creation tokens
+  const cacheWrite =
+    toNonNegativeInt(usage.cacheWriteTokens) ??
+    toNonNegativeInt(usage.cache_creation_input_tokens) ??
+    toNonNegativeInt(usage.prompt_tokens_details?.cache_creation_tokens) ??
+    toNonNegativeInt(usage.cache_write_tokens) ??
+    toNonNegativeInt(usage.prompt_cache_miss_tokens) ??
+    0;
+
+  // 5. Total tokens
+  let total =
+    toNonNegativeInt(usage.totalTokens) ??
+    toNonNegativeInt(usage.total_tokens) ??
+    toNonNegativeInt(usage.totalTokenCount);
+
+  if (total === null) {
+    total = input + output;
+  }
+
+  return {
+    inputTokens: input,
+    outputTokens: output,
+    cacheReadTokens: cacheRead,
+    cacheWriteTokens: cacheWrite,
+    totalTokens: total,
+    raw: usage,
+  };
+}
+
+/**
+ * Extracts a single total token number for quota and TPM accounting.
+ * Returns null if no valid token counts are found.
+ * Compatible with model-quota.js extractUsageTokens.
+ *
+ * @param {object|null|undefined} usage
+ * @returns {number|null}
+ */
+export function extractTotalTokens(usage) {
+  if (!usage || typeof usage !== 'object') return null;
+
+  const normalized = normalizeUsageTokens(usage);
+  if (normalized.totalTokens > 0) return normalized.totalTokens;
+  if (normalized.inputTokens > 0 || normalized.outputTokens > 0) {
+    return normalized.inputTokens + normalized.outputTokens;
+  }
+  return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-key-rotation",
-  "version": "0.8.76",
+  "version": "0.8.78",
   "packageManager": "pnpm@10.33.2",
   "description": "Per-provider API key rotation for DeepSeek Harness: a key pool per provider, auto-created clone routes, and switching to the next key on quota/rate-limit errors. Includes a Settings section (Key Rotation) to edit the key pools, cooldown and switch codes.",
   "keywords": [
@@ -26,10 +26,14 @@
   "exports": {
     ".": "./lib/index.js",
     "./client": "./lib/client.js",
+    "./transports": "./lib/transports/index.js",
+    "./catalog": "./lib/model-catalog.js",
+    "./runway": "./lib/quota-runway.js",
     "./package.json": "./package.json",
     "./cordis.patch.yml": "./cordis.patch.yml"
   },
   "files": [
+    "lib/**/*.js",
     "lib/*.js",
     "cordis.patch.yml",
     "README.md",