waypoi 0.0.0

package/src/transport/httpClient.ts

@@ -0,0 +1,145 @@
+import { Agent, request } from "undici";
+import { EndpointDoc, UpstreamError, UpstreamResult } from "../types";
+
+const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504]);
+const TLS_VERIFY_ERROR_CODES = new Set([
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "CERT_HAS_EXPIRED",
+  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+  "ERR_TLS_CERT_ALTNAME_INVALID",
+  "ERR_TLS_CERT_SIGNATURE_ALGORITHM_UNSUPPORTED",
+]);
+
+export async function proxyUpstream(
+  endpoint: EndpointDoc,
+  path: string,
+  payload: unknown,
+  headers: Record<string, string | string[] | undefined>,
+  timeoutMs: number,
+  signal: AbortSignal,
+  options?: {
+    skipDefaultAuth?: boolean;
+  }
+): Promise<UpstreamResult> {
+  const url = new URL(path, endpoint.baseUrl).toString();
+  const dispatcher = endpoint.insecureTls
+    ? new Agent({ connect: { rejectUnauthorized: false } })
+    : undefined;
+
+  const requestHeaders: Record<string, string> = {
+    "content-type": "application/json",
+    accept: "application/json",
+    ...filterHeaders(headers)
+  };
+  if (endpoint.apiKey && !options?.skipDefaultAuth && !requestHeaders.authorization) {
+    requestHeaders.authorization = `Bearer ${endpoint.apiKey}`;
+  }
+
+  const response = await request(url, {
+    method: "POST",
+    body: JSON.stringify(payload),
+    headers: requestHeaders,
+    dispatcher,
+    signal,
+    headersTimeout: timeoutMs,
+    bodyTimeout: timeoutMs
+  });
+
+  return {
+    statusCode: response.statusCode,
+    headers: response.headers as Record<string, string | string[]>,
+    body: response.body
+  };
+}
+
+export function classifyUpstreamError(error: unknown): UpstreamError {
+  if (error instanceof Error) {
+    const err = error as UpstreamError;
+    if (typeof err.type === "string" && typeof err.retryable === "boolean") {
+      return err;
+    }
+    const code = (err as NodeJS.ErrnoException).code;
+    if (isTlsVerifyError(err, code)) {
+      err.type = "tls_verify_failed";
+      err.retryable = true;
+      return err;
+    }
+    // Connection errors
+    if (code === "ECONNREFUSED" || code === "ECONNRESET" || code === "ETIMEDOUT" || code === "ENOTFOUND") {
+      err.type = "connection";
+      err.retryable = true;
+      return err;
+    }
+    // Undici timeout errors
+    if (code === "UND_ERR_HEADERS_TIMEOUT" || code === "UND_ERR_BODY_TIMEOUT" || code === "UND_ERR_CONNECT_TIMEOUT") {
+      err.type = "timeout";
+      err.retryable = true;
+      return err;
+    }
+    if (err.name === "AbortError") {
+      err.type = "timeout";
+      err.retryable = true;
+      return err;
+    }
+    // Socket/stream errors during transfer
+    if (code === "ERR_STREAM_PREMATURE_CLOSE" || code === "EPIPE" || code === "ECONNABORTED") {
+      err.type = "stream_error";
+      err.retryable = true;
+      return err;
+    }
+    err.type = "unknown";
+    err.retryable = false;
+    return err;
+  }
+  const fallback = new Error("Unknown upstream error") as UpstreamError;
+  fallback.type = "unknown";
+  fallback.retryable = false;
+  return fallback;
+}
+
+function isTlsVerifyError(error: Error, code: string | undefined): boolean {
+  if (code && TLS_VERIFY_ERROR_CODES.has(code)) {
+    return true;
+  }
+  const message = error.message.toLowerCase();
+  return (
+    message.includes("unable to verify the first certificate") ||
+    message.includes("self-signed certificate") ||
+    message.includes("certificate verify failed")
+  );
+}
+
+export function classifyHttpStatus(statusCode: number): { retryable: boolean; type: string } {
+  if (statusCode === 429) {
+    return { retryable: true, type: "rate_limited" };
+  }
+  if (RETRYABLE_STATUSES.has(statusCode)) {
+    return { retryable: true, type: "upstream_5xx" };
+  }
+  if ([400, 401, 403].includes(statusCode)) {
+    return { retryable: false, type: "upstream_4xx" };
+  }
+  if (statusCode >= 400) {
+    return { retryable: false, type: "upstream_4xx" };
+  }
+  return { retryable: false, type: "ok" };
+}
+
+function filterHeaders(
+  headers: Record<string, string | string[] | undefined>
+): Record<string, string> {
+  const filtered: Record<string, string> = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (!value) {
+      continue;
+    }
+    const lower = key.toLowerCase();
+    if (lower === "host" || lower === "content-length") {
+      continue;
+    }
+    filtered[lower] = Array.isArray(value) ? value.join(", ") : value;
+  }
+  return filtered;
+}

package/src/types.ts

@@ -0,0 +1,322 @@
+export type HealthStatus = "up" | "down";
+export type EndpointType = "llm" | "diffusion" | "audio" | "embedding" | "video";
+export type ModelModality = "text" | "image" | "audio" | "embedding" | "video";
+
+export interface ModelCapabilities {
+  input: ModelModality[];
+  output: ModelModality[];
+  supportsTools?: boolean;
+  supportsStreaming?: boolean;
+  source?: "configured" | "inferred";
+}
+
+export interface ModelMapping {
+  publicName: string;
+  upstreamModel: string;
+  capabilities?: ModelCapabilities;
+}
+
+export interface EndpointHealth {
+  status: HealthStatus;
+  lastCheckedAt?: Date;
+  lastSuccessAt?: Date;
+  lastFailureAt?: Date;
+  consecutiveFailures: number;
+  downUntil?: Date;
+  latencyMsEwma?: number;
+}
+
+export interface ProviderModelHealth {
+  status: HealthStatus;
+  lastCheckedAt?: Date;
+  lastSuccessAt?: Date;
+  lastFailureAt?: Date;
+  consecutiveFailures: number;
+  latencyMsEwma?: number;
+  lastStatusCode?: number;
+  lastError?: string;
+}
+
+export interface EndpointLimits {
+  timeoutMs?: number;
+  maxConcurrent?: number;
+}
+
+export interface EndpointDoc {
+  id: string;
+  name: string;
+  baseUrl: string;
+  apiKey?: string;
+  disabled?: boolean;
+  insecureTls: boolean;
+  priority: number;
+  weight?: number;
+  type: EndpointType;
+  models: ModelMapping[];
+  health: EndpointHealth;
+  limits?: EndpointLimits;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface RequestLog {
+  requestId: string;
+  ts: Date;
+  route: {
+    publicModel: string;
+    endpointId?: string;
+    endpointName?: string;
+    upstreamModel?: string;
+  };
+  request: {
+    stream: boolean;
+    maxTokens?: number;
+  };
+  result: {
+    statusCode?: number;
+    latencyMs?: number;
+    errorType?: string;
+    errorMessage?: string;
+    totalTokens?: number | null;
+  };
+}
+
+export interface UpstreamResult {
+  statusCode: number;
+  headers: Record<string, string | string[]>;
+  body: NodeJS.ReadableStream;
+  rawBody?: Buffer;
+}
+
+export interface UpstreamError extends Error {
+  type: string;
+  statusCode?: number;
+  retryable: boolean;
+  triedModels?: string[];
+  poolId?: string;
+}
+
+// ========================================
+// Image Generation Types
+// ========================================
+
+export interface ImageGenerationRequest {
+  model?: string;
+  prompt: string;
+  image_url?: string;
+  n?: number;
+  size?: string;
+  quality?: string;
+  style?: string;
+  response_format?: "url" | "b64_json";
+  user?: string;
+}
+
+export interface ImageObject {
+  url?: string;
+  b64_json?: string;
+  revised_prompt?: string;
+}
+
+export interface ImageGenerationResponse {
+  created: number;
+  data: ImageObject[];
+}
+
+// ========================================
+// Audio Types
+// ========================================
+
+export interface AudioTranscriptionRequest {
+  file: Buffer;
+  model: string;
+  language?: string;
+  prompt?: string;
+  response_format?: "json" | "text" | "srt" | "verbose_json" | "vtt";
+  temperature?: number;
+  timestamp_granularities?: Array<"word" | "segment">;
+}
+
+export interface AudioTranscriptionResponse {
+  text: string;
+  task?: string;
+  language?: string;
+  duration?: number;
+  words?: Array<{ word: string; start: number; end: number }>;
+  segments?: Array<{
+    id: number;
+    seek: number;
+    start: number;
+    end: number;
+    text: string;
+    tokens: number[];
+    temperature: number;
+    avg_logprob: number;
+    compression_ratio: number;
+    no_speech_prob: number;
+  }>;
+}
+
+export interface AudioSpeechRequest {
+  model: string;
+  input: string;
+  voice: string;
+  response_format?: "mp3" | "opus" | "aac" | "flac" | "wav" | "pcm";
+  speed?: number;
+}
+
+// ========================================
+// Responses API Types (Shim)
+// ========================================
+
+export interface ResponsesApiRequest {
+  model: string;
+  input: string | Array<{ role: string; content: string }>;
+  instructions?: string;
+  tools?: unknown[];
+  tool_choice?: unknown;
+  temperature?: number;
+  top_p?: number;
+  max_tokens?: number;
+  presence_penalty?: number;
+  frequency_penalty?: number;
+  seed?: number;
+  stop?: string | string[];
+  stream?: boolean;
+  [key: string]: unknown;
+}
+
+// ========================================
+// Statistics Types
+// ========================================
+
+export interface RequestStats {
+  requestId: string;
+  timestamp: Date;
+  route: string;
+  method: string;
+  publicModel?: string;
+  endpointId?: string;
+  endpointName?: string;
+  upstreamModel?: string;
+  requestBytes: number;
+  responseBytes: number;
+  latencyMs: number;
+  statusCode: number;
+  errorType?: string;
+  totalTokens?: number | null;
+  promptTokens?: number | null;
+  completionTokens?: number | null;
+}
+
+export interface StatsAggregation {
+  window: string;
+  total: number;
+  success: number;
+  errors: number;
+  avgLatencyMs: number | null;
+  p50LatencyMs: number | null;
+  p95LatencyMs: number | null;
+  p99LatencyMs: number | null;
+  totalTokens: number;
+  tokensPerHour: number | null;
+  byModel: Record<string, { count: number; avgLatencyMs: number; tokens: number }>;
+  byEndpoint: Record<string, { count: number; avgLatencyMs: number; tokens: number; errors: number }>;
+}
+
+// ========================================
+// Session Types (for Playground)
+// ========================================
+
+export interface ChatMessage {
+  id: string;
+  role: "user" | "assistant" | "system" | "tool";
+  content: string | ChatContentPart[] | null;
+  name?: string;
+  tool_calls?: Array<{
+    id: string;
+    type: "function";
+    function: { name: string; arguments: string };
+  }>;
+  tool_call_id?: string;
+  // Image references (data URLs in legacy sessions, cache URLs in v2+ sessions)
+  images?: string[];
+  // Model that produced this message (assistant messages only)
+  model?: string;
+  createdAt: Date;
+}
+
+export type ChatContentPart =
+  | { type: "text"; text: string }
+  | { type: "image_url"; image_url: { url: string } }
+  | { type: "input_audio"; input_audio: { url?: string; data?: string; format?: string } }
+  | { type: "audio"; audio: { url?: string; data?: string; format?: string } };
+
+export interface ChatSession {
+  id: string;
+  name: string;
+  model?: string;
+  titleStatus?: "pending" | "generated" | "manual" | "failed";
+  titleUpdatedAt?: Date;
+  // Storage schema version:
+  // 1 = legacy sessions (inline data URLs)
+  // 2 = cache-backed image references
+  storageVersion: number;
+  messages: ChatMessage[];
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+// ========================================
+// MCP Types
+// ========================================
+
+export interface McpServer {
+  id: string;
+  name: string;
+  url: string;
+  enabled: boolean;
+  status: "connected" | "disconnected" | "error" | "unknown";
+  toolCount?: number;
+  lastConnectedAt?: Date;
+  lastError?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface McpTool {
+  name: string;
+  description?: string;
+  inputSchema: Record<string, unknown>;
+}
+
+// ========================================
+// Video Generation Types
+// ========================================
+
+export interface VideoGenerationRequest {
+  model?: string;
+  prompt: string;
+  negative_prompt?: string;
+  image_url?: string;
+  audio_url?: string;
+  duration?: number;
+  resolution?: string;
+  n?: number;
+  seed?: number;
+  watermark?: boolean;
+  prompt_extend?: boolean;
+  response_format?: "url" | "b64_json";
+  user?: string;
+}
+
+export interface VideoObject {
+  url?: string;
+  b64_json?: string;
+  revised_prompt?: string;
+}
+
+export interface VideoGenerationResponse {
+  created: number;
+  data: VideoObject[];
+}