@relayplane/proxy 0.2.0 → 1.1.0

package/src/streaming.ts

@@ -1,331 +0,0 @@
-/**
- * Streaming Support for RelayPlane Proxy
- *
- * Provides SSE (Server-Sent Events) streaming for LLM responses
- * and real-time updates.
- *
- * @packageDocumentation
- */
-
-import type { ServerResponse } from 'node:http';
-
-/**
- * SSE message structure
- */
-export interface SSEMessage {
-  event?: string;
-  data: unknown;
-  id?: string;
-  retry?: number;
-}
-
-/**
- * Stream writer for SSE responses
- */
-export class SSEWriter {
-  private response: ServerResponse;
-  private closed = false;
-
-  constructor(response: ServerResponse) {
-    this.response = response;
-
-    // Set SSE headers
-    response.writeHead(200, {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      'Connection': 'keep-alive',
-      'Access-Control-Allow-Origin': '*',
-    });
-
-    // Handle client disconnect
-    response.on('close', () => {
-      this.closed = true;
-    });
-  }
-
-  /**
-   * Write an SSE message
-   */
-  write(message: SSEMessage): boolean {
-    if (this.closed) return false;
-
-    const lines: string[] = [];
-
-    if (message.event) {
-      lines.push(`event: ${message.event}`);
-    }
-
-    if (message.id) {
-      lines.push(`id: ${message.id}`);
-    }
-
-    if (message.retry !== undefined) {
-      lines.push(`retry: ${message.retry}`);
-    }
-
-    // Data can be multi-line, each line needs data: prefix
-    const dataStr = typeof message.data === 'string'
-      ? message.data
-      : JSON.stringify(message.data);
-
-    for (const line of dataStr.split('\n')) {
-      lines.push(`data: ${line}`);
-    }
-
-    lines.push(''); // Empty line to end message
-    lines.push('');
-
-    try {
-      this.response.write(lines.join('\n'));
-      return true;
-    } catch {
-      this.closed = true;
-      return false;
-    }
-  }
-
-  /**
-   * Write a data-only message (convenience method)
-   */
-  writeData(data: unknown): boolean {
-    return this.write({ data });
-  }
-
-  /**
-   * Send a comment (keep-alive)
-   */
-  comment(text: string): boolean {
-    if (this.closed) return false;
-    try {
-      this.response.write(`: ${text}\n\n`);
-      return true;
-    } catch {
-      this.closed = true;
-      return false;
-    }
-  }
-
-  /**
-   * Close the stream
-   */
-  close(): void {
-    if (!this.closed) {
-      this.write({ data: '[DONE]' });
-      this.response.end();
-      this.closed = true;
-    }
-  }
-
-  /**
-   * Check if stream is still open
-   */
-  isOpen(): boolean {
-    return !this.closed;
-  }
-}
-
-/**
- * Create an SSE writer
- */
-export function createSSEWriter(response: ServerResponse): SSEWriter {
-  return new SSEWriter(response);
-}
-
-/**
- * Stream a provider response to SSE
- */
-export async function streamProviderResponse(
-  providerUrl: string,
-  request: unknown,
-  headers: Record<string, string>,
-  writer: SSEWriter,
-  callbacks?: {
-    onChunk?: (chunk: unknown) => void;
-    onComplete?: (fullResponse: unknown) => void;
-    onError?: (error: Error) => void;
-  }
-): Promise<{ success: boolean; chunks: unknown[]; ttftMs?: number }> {
-  const chunks: unknown[] = [];
-  let ttftMs: number | undefined;
-  const startTime = Date.now();
-
-  try {
-    const response = await fetch(providerUrl, {
-      method: 'POST',
-      headers: {
-        ...headers,
-        'Accept': 'text/event-stream',
-      },
-      body: JSON.stringify(request),
-    });
-
-    if (!response.ok) {
-      const error = new Error(`Provider returned ${response.status}`);
-      callbacks?.onError?.(error);
-      writer.write({
-        event: 'error',
-        data: { error: { message: error.message, status: response.status } },
-      });
-      writer.close();
-      return { success: false, chunks };
-    }
-
-    if (!response.body) {
-      const error = new Error('No response body');
-      callbacks?.onError?.(error);
-      writer.close();
-      return { success: false, chunks };
-    }
-
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-
-    while (true) {
-      const { done, value } = await reader.read();
-
-      if (done) break;
-
-      if (ttftMs === undefined) {
-        ttftMs = Date.now() - startTime;
-      }
-
-      buffer += decoder.decode(value, { stream: true });
-
-      // Parse SSE events from buffer
-      const lines = buffer.split('\n');
-      buffer = lines.pop() ?? ''; // Keep incomplete line in buffer
-
-      for (const line of lines) {
-        if (line.startsWith('data: ')) {
-          const data = line.slice(6);
-
-          if (data === '[DONE]') {
-            continue;
-          }
-
-          try {
-            const parsed = JSON.parse(data);
-            chunks.push(parsed);
-            callbacks?.onChunk?.(parsed);
-
-            // Forward to client
-            if (!writer.write({ data: parsed })) {
-              // Client disconnected
-              return { success: false, chunks, ttftMs };
-            }
-          } catch {
-            // Invalid JSON, skip
-          }
-        }
-      }
-    }
-
-    // Process any remaining buffer
-    if (buffer.startsWith('data: ')) {
-      const data = buffer.slice(6);
-      if (data && data !== '[DONE]') {
-        try {
-          const parsed = JSON.parse(data);
-          chunks.push(parsed);
-          callbacks?.onChunk?.(parsed);
-          writer.write({ data: parsed });
-        } catch {
-          // Invalid JSON
-        }
-      }
-    }
-
-    callbacks?.onComplete?.(chunks);
-    writer.close();
-
-    return { success: true, chunks, ttftMs };
-  } catch (error) {
-    callbacks?.onError?.(error instanceof Error ? error : new Error(String(error)));
-    writer.write({
-      event: 'error',
-      data: { error: { message: error instanceof Error ? error.message : 'Stream error' } },
-    });
-    writer.close();
-    return { success: false, chunks, ttftMs };
-  }
-}
-
-/**
- * Aggregate streaming chunks into a complete response
- */
-export function aggregateStreamingResponse(chunks: unknown[]): {
-  content: string;
-  usage?: { prompt_tokens: number; completion_tokens: number; total_tokens: number };
-  model?: string;
-  finish_reason?: string;
-} {
-  let content = '';
-  let usage: { prompt_tokens: number; completion_tokens: number; total_tokens: number } | undefined;
-  let model: string | undefined;
-  let finish_reason: string | undefined;
-
-  for (const chunk of chunks) {
-    if (typeof chunk !== 'object' || chunk === null) continue;
-
-    const c = chunk as Record<string, unknown>;
-
-    // Extract model
-    if (c.model && typeof c.model === 'string') {
-      model = c.model;
-    }
-
-    // Extract content from choices
-    if (Array.isArray(c.choices) && c.choices.length > 0) {
-      const choice = c.choices[0] as Record<string, unknown>;
-
-      // Delta content (streaming)
-      if (choice.delta && typeof choice.delta === 'object') {
-        const delta = choice.delta as Record<string, unknown>;
-        if (typeof delta.content === 'string') {
-          content += delta.content;
-        }
-      }
-
-      // Finish reason
-      if (choice.finish_reason && typeof choice.finish_reason === 'string') {
-        finish_reason = choice.finish_reason;
-      }
-    }
-
-    // Extract usage (usually in last chunk)
-    if (c.usage && typeof c.usage === 'object') {
-      const u = c.usage as Record<string, unknown>;
-      if (
-        typeof u.prompt_tokens === 'number' &&
-        typeof u.completion_tokens === 'number'
-      ) {
-        usage = {
-          prompt_tokens: u.prompt_tokens,
-          completion_tokens: u.completion_tokens,
-          total_tokens: (u.total_tokens as number) ?? u.prompt_tokens + u.completion_tokens,
-        };
-      }
-    }
-  }
-
-  return { content, usage, model, finish_reason };
-}
-
-/**
- * Keep-alive ping for long-running streams
- */
-export function startKeepAlive(
-  writer: SSEWriter,
-  intervalMs = 15000
-): () => void {
-  const timer = setInterval(() => {
-    if (!writer.isOpen()) {
-      clearInterval(timer);
-      return;
-    }
-    writer.comment('ping');
-  }, intervalMs);
-
-  return () => clearInterval(timer);
-}

package/src/telemetry.ts

@@ -1,343 +0,0 @@
-/**
- * RelayPlane Proxy Telemetry
- * 
- * Anonymized telemetry collection for improving model routing.
- * 
- * What we collect (exact schema):
- * - device_id: anonymous random ID
- * - task_type: inferred from token patterns, NOT prompt content
- * - model: which model was used
- * - tokens_in/out: token counts
- * - latency_ms: response time
- * - success: whether request succeeded
- * - cost_usd: estimated cost
- * 
- * What we NEVER collect:
- * - Prompts or responses
- * - File paths or contents
- * - Anything that could identify you or your project
- * 
- * @packageDocumentation
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import { getDeviceId, isTelemetryEnabled, getConfigDir } from './config.js';
-
-/**
- * Telemetry event schema (matches PITCH-v2.md)
- */
-export interface TelemetryEvent {
-  /** Anonymous device ID */
-  device_id: string;
-  
-  /** Inferred task type (from token patterns, NOT prompt content) */
-  task_type: string;
-  
-  /** Model used */
-  model: string;
-  
-  /** Input tokens */
-  tokens_in: number;
-  
-  /** Output tokens */
-  tokens_out: number;
-  
-  /** Request latency in milliseconds */
-  latency_ms: number;
-  
-  /** Whether request succeeded */
-  success: boolean;
-  
-  /** Estimated cost in USD */
-  cost_usd: number;
-  
-  /** Timestamp */
-  timestamp: string;
-}
-
-/**
- * Local telemetry store using SQLite (via Ledger)
- */
-const TELEMETRY_FILE = path.join(getConfigDir(), 'telemetry.jsonl');
-
-// In-memory buffer for audit mode
-let auditBuffer: TelemetryEvent[] = [];
-let auditMode = false;
-let offlineMode = false;
-
-/**
- * Task type inference based on token patterns
- * This infers task type from request characteristics, NOT from prompt content
- */
-export function inferTaskType(
-  inputTokens: number,
-  outputTokens: number,
-  model: string,
-  hasTools: boolean = false
-): string {
-  // Simple heuristics based on token patterns
-  const ratio = outputTokens / Math.max(inputTokens, 1);
-  
-  if (hasTools) {
-    return 'tool_use';
-  }
-  
-  if (inputTokens > 10000) {
-    return 'long_context';
-  }
-  
-  if (ratio > 5) {
-    return 'generation';
-  }
-  
-  if (ratio < 0.3 && outputTokens < 100) {
-    return 'classification';
-  }
-  
-  if (inputTokens < 500 && outputTokens < 500) {
-    return 'quick_task';
-  }
-  
-  if (inputTokens > 2000 && outputTokens > 500) {
-    return 'code_review';
-  }
-  
-  if (outputTokens > 1000) {
-    return 'content_generation';
-  }
-  
-  return 'general';
-}
-
-/**
- * Estimate cost based on model and token counts
- * Pricing as of 2024 (USD per 1M tokens)
- */
-const MODEL_PRICING: Record<string, { input: number; output: number }> = {
-  // Anthropic
-  'claude-opus-4-20250514': { input: 15.0, output: 75.0 },
-  'claude-sonnet-4-20250514': { input: 3.0, output: 15.0 },
-  'claude-3-5-sonnet-20241022': { input: 3.0, output: 15.0 },
-  'claude-3-5-sonnet-20240620': { input: 3.0, output: 15.0 },
-  'claude-3-5-haiku-20241022': { input: 0.8, output: 4.0 },
-  'claude-3-opus-20240229': { input: 15.0, output: 75.0 },
-  'claude-3-sonnet-20240229': { input: 3.0, output: 15.0 },
-  'claude-3-haiku-20240307': { input: 0.25, output: 1.25 },
-  
-  // OpenAI
-  'gpt-4o': { input: 2.5, output: 10.0 },
-  'gpt-4o-mini': { input: 0.15, output: 0.60 },
-  'gpt-4-turbo': { input: 10.0, output: 30.0 },
-  'gpt-4': { input: 30.0, output: 60.0 },
-  'gpt-3.5-turbo': { input: 0.5, output: 1.5 },
-  
-  // Default for unknown models
-  'default': { input: 1.0, output: 3.0 },
-};
-
-export function estimateCost(model: string, inputTokens: number, outputTokens: number): number {
-  const pricing = MODEL_PRICING[model] || MODEL_PRICING['default'];
-  const inputCost = (inputTokens / 1_000_000) * pricing.input;
-  const outputCost = (outputTokens / 1_000_000) * pricing.output;
-  return Math.round((inputCost + outputCost) * 10000) / 10000; // Round to 4 decimal places
-}
-
-/**
- * Set audit mode - shows telemetry payload before sending
- */
-export function setAuditMode(enabled: boolean): void {
-  auditMode = enabled;
-}
-
-/**
- * Check if audit mode is enabled
- */
-export function isAuditMode(): boolean {
-  return auditMode;
-}
-
-/**
- * Set offline mode - disables all network calls except LLM
- */
-export function setOfflineMode(enabled: boolean): void {
-  offlineMode = enabled;
-}
-
-/**
- * Check if offline mode is enabled
- */
-export function isOfflineMode(): boolean {
-  return offlineMode;
-}
-
-/**
- * Get pending audit events
- */
-export function getAuditBuffer(): TelemetryEvent[] {
-  return [...auditBuffer];
-}
-
-/**
- * Clear audit buffer
- */
-export function clearAuditBuffer(): void {
-  auditBuffer = [];
-}
-
-/**
- * Record a telemetry event
- */
-export function recordTelemetry(event: Omit<TelemetryEvent, 'device_id' | 'timestamp'>): void {
-  if (!isTelemetryEnabled() && !auditMode) {
-    return; // Telemetry disabled and not in audit mode
-  }
-  
-  const fullEvent: TelemetryEvent = {
-    ...event,
-    device_id: getDeviceId(),
-    timestamp: new Date().toISOString(),
-  };
-  
-  if (auditMode) {
-    // In audit mode, buffer events and print them
-    auditBuffer.push(fullEvent);
-    console.log('\n📊 [TELEMETRY AUDIT] The following data would be collected:');
-    console.log(JSON.stringify(fullEvent, null, 2));
-    console.log('');
-    return;
-  }
-  
-  if (!isTelemetryEnabled()) {
-    return;
-  }
-  
-  // Store locally (append to JSONL file)
-  try {
-    const configDir = getConfigDir();
-    if (!fs.existsSync(configDir)) {
-      fs.mkdirSync(configDir, { recursive: true });
-    }
-    
-    fs.appendFileSync(TELEMETRY_FILE, JSON.stringify(fullEvent) + '\n');
-  } catch (err) {
-    // Silently fail - telemetry should never break the proxy
-  }
-}
-
-/**
- * Get local telemetry data
- */
-export function getLocalTelemetry(): TelemetryEvent[] {
-  try {
-    if (!fs.existsSync(TELEMETRY_FILE)) {
-      return [];
-    }
-    
-    const data = fs.readFileSync(TELEMETRY_FILE, 'utf-8');
-    return data
-      .split('\n')
-      .filter(line => line.trim())
-      .map(line => JSON.parse(line) as TelemetryEvent);
-  } catch (err) {
-    return [];
-  }
-}
-
-/**
- * Get telemetry stats summary
- */
-export function getTelemetryStats(): {
-  totalEvents: number;
-  totalCost: number;
-  byModel: Record<string, { count: number; cost: number }>;
-  byTaskType: Record<string, { count: number; cost: number }>;
-  successRate: number;
-} {
-  const events = getLocalTelemetry();
-  
-  const byModel: Record<string, { count: number; cost: number }> = {};
-  const byTaskType: Record<string, { count: number; cost: number }> = {};
-  let totalCost = 0;
-  let successCount = 0;
-  
-  for (const event of events) {
-    totalCost += event.cost_usd;
-    if (event.success) successCount++;
-    
-    if (!byModel[event.model]) {
-      byModel[event.model] = { count: 0, cost: 0 };
-    }
-    byModel[event.model].count++;
-    byModel[event.model].cost += event.cost_usd;
-    
-    if (!byTaskType[event.task_type]) {
-      byTaskType[event.task_type] = { count: 0, cost: 0 };
-    }
-    byTaskType[event.task_type].count++;
-    byTaskType[event.task_type].cost += event.cost_usd;
-  }
-  
-  return {
-    totalEvents: events.length,
-    totalCost: Math.round(totalCost * 100) / 100,
-    byModel,
-    byTaskType,
-    successRate: events.length > 0 ? successCount / events.length : 0,
-  };
-}
-
-/**
- * Clear all local telemetry data
- */
-export function clearTelemetry(): void {
-  try {
-    if (fs.existsSync(TELEMETRY_FILE)) {
-      fs.unlinkSync(TELEMETRY_FILE);
-    }
-  } catch (err) {
-    // Silently fail
-  }
-}
-
-/**
- * Get telemetry file path
- */
-export function getTelemetryPath(): string {
-  return TELEMETRY_FILE;
-}
-
-/**
- * Print telemetry disclosure message
- */
-export function printTelemetryDisclosure(): void {
-  console.log(`
-╭─────────────────────────────────────────────────────────────────────╮
-│                    📊 TELEMETRY DISCLOSURE                          │
-╰─────────────────────────────────────────────────────────────────────╯
-
-RelayPlane collects anonymous telemetry to improve model routing.
-
-What we collect:
-  • Anonymous device ID (random, not fingerprintable)
-  • Task type (inferred from token patterns, NOT your prompts)
-  • Model used, token counts, latency, success/failure
-  • Estimated cost
-
-What we NEVER collect:
-  • Your prompts or model responses
-  • File paths or contents
-  • Anything that could identify you or your project
-
-How to verify:
-  • Run with --audit to see exact payloads before they're sent
-  • Run with --offline to disable all telemetry transmission
-  • Full source code: https://github.com/RelayPlane/proxy
-
-To opt out completely:
-  $ relayplane-proxy telemetry off
-
-Learn more: https://relayplane.com/privacy
-
-`);
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/vitest.config.ts

@@ -1,21 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    include: ['__tests__/**/*.test.ts'],
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'json', 'html'],
-    },
-    testTimeout: 10000,
-    // Run tests sequentially to avoid port conflicts
-    pool: 'forks',
-    poolOptions: {
-      forks: {
-        singleFork: true,
-      },
-    },
-  },
-});