@elsium-ai/gateway 0.1.6

package/dist/index.js

@@ -0,0 +1,2591 @@
+// @bun
+// ../core/src/errors.ts
+class ElsiumError extends Error {
+  code;
+  provider;
+  model;
+  statusCode;
+  retryable;
+  retryAfterMs;
+  cause;
+  metadata;
+  constructor(details) {
+    super(details.message);
+    this.name = "ElsiumError";
+    this.code = details.code;
+    this.provider = details.provider;
+    this.model = details.model;
+    this.statusCode = details.statusCode;
+    this.retryable = details.retryable;
+    this.retryAfterMs = details.retryAfterMs;
+    this.cause = details.cause;
+    this.metadata = details.metadata;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      provider: this.provider,
+      model: this.model,
+      statusCode: this.statusCode,
+      retryable: this.retryable,
+      retryAfterMs: this.retryAfterMs,
+      metadata: this.metadata
+    };
+  }
+  static providerError(message, opts) {
+    return new ElsiumError({
+      code: "PROVIDER_ERROR",
+      message,
+      provider: opts.provider,
+      statusCode: opts.statusCode,
+      retryable: opts.retryable ?? false,
+      cause: opts.cause
+    });
+  }
+  static rateLimit(provider, retryAfterMs) {
+    return new ElsiumError({
+      code: "RATE_LIMIT",
+      message: `Rate limited by ${provider}`,
+      provider,
+      statusCode: 429,
+      retryable: true,
+      retryAfterMs
+    });
+  }
+  static authError(provider) {
+    return new ElsiumError({
+      code: "AUTH_ERROR",
+      message: `Authentication failed for ${provider}. Check your API key.`,
+      provider,
+      statusCode: 401,
+      retryable: false
+    });
+  }
+  static timeout(provider, timeoutMs) {
+    return new ElsiumError({
+      code: "TIMEOUT",
+      message: `Request to ${provider} timed out after ${timeoutMs}ms`,
+      provider,
+      retryable: true
+    });
+  }
+  static validation(message, metadata) {
+    return new ElsiumError({
+      code: "VALIDATION_ERROR",
+      message,
+      retryable: false,
+      metadata
+    });
+  }
+  static budgetExceeded(spent, budget) {
+    return new ElsiumError({
+      code: "BUDGET_EXCEEDED",
+      message: `Token budget exceeded: spent ${spent}, budget ${budget}`,
+      retryable: false,
+      metadata: { spent, budget }
+    });
+  }
+}
+// ../core/src/utils.ts
+import { randomBytes } from "crypto";
+function cryptoHex(bytes) {
+  return randomBytes(bytes).toString("hex");
+}
+function generateId(prefix = "els") {
+  const timestamp = Date.now().toString(36);
+  const random = cryptoHex(4);
+  return `${prefix}_${timestamp}_${random}`;
+}
+function generateTraceId() {
+  const timestamp = Date.now().toString(36);
+  const random = cryptoHex(6);
+  return `trc_${timestamp}_${random}`;
+}
+function extractText(content) {
+  if (typeof content === "string")
+    return content;
+  return content.filter((part) => part.type === "text" && part.text).map((part) => part.text).join("");
+}
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getRetryDelay(error, attempt, baseDelayMs, maxDelayMs) {
+  if (error && typeof error === "object" && "retryAfterMs" in error && typeof error.retryAfterMs === "number") {
+    return error.retryAfterMs;
+  }
+  return Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
+}
+function retry(fn, options = {}) {
+  const {
+    maxRetries = 3,
+    baseDelayMs = 1000,
+    maxDelayMs = 30000,
+    shouldRetry = (error) => {
+      if (error && typeof error === "object" && "retryable" in error) {
+        return error.retryable === true;
+      }
+      return false;
+    }
+  } = options;
+  return (async () => {
+    let lastError;
+    for (let attempt = 0;attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        if (attempt === maxRetries || !shouldRetry(error)) {
+          throw error;
+        }
+        const delay = getRetryDelay(error, attempt, baseDelayMs, maxDelayMs);
+        const jitter = delay * (0.5 + Math.random() * 0.5);
+        await sleep(jitter);
+      }
+    }
+    throw lastError;
+  })();
+}
+
+// ../core/src/stream.ts
+function shouldEmitCheckpoint(lastCheckpointTime, intervalMs, textLength) {
+  const elapsed = Date.now() - lastCheckpointTime;
+  return elapsed >= intervalMs && textLength > 0;
+}
+function createCheckpoint(textAccumulator, eventIndex, now) {
+  return {
+    id: generateId("ckpt"),
+    timestamp: now,
+    text: textAccumulator,
+    tokensSoFar: Math.ceil(textAccumulator.length / 1.5),
+    eventIndex
+  };
+}
+function toError(err) {
+  return err instanceof Error ? err : new Error(String(err));
+}
+function* emitErrorEvent(err, textAccumulator, onPartialRecovery) {
+  const error = toError(err);
+  if (textAccumulator.length > 0) {
+    onPartialRecovery?.(textAccumulator, error);
+    yield { type: "recovery", partialText: textAccumulator, error };
+  } else {
+    yield { type: "error", error };
+  }
+}
+
+class ElsiumStream {
+  source;
+  iterating = false;
+  constructor(source) {
+    this.source = source;
+  }
+  async* [Symbol.asyncIterator]() {
+    if (this.iterating) {
+      throw new Error("ElsiumStream supports only a single consumer");
+    }
+    this.iterating = true;
+    yield* this.source;
+  }
+  text() {
+    const source = this.source;
+    return {
+      async* [Symbol.asyncIterator]() {
+        for await (const event of source) {
+          if (event.type === "text_delta") {
+            yield event.text;
+          }
+        }
+      }
+    };
+  }
+  async toText() {
+    const parts = [];
+    for await (const text of this.text()) {
+      parts.push(text);
+    }
+    return parts.join("");
+  }
+  async toTextWithTimeout(timeoutMs) {
+    const parts = [];
+    const deadline = Date.now() + timeoutMs;
+    const iterator = this.source[Symbol.asyncIterator]();
+    try {
+      while (true) {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+          break;
+        let timer;
+        const timeoutPromise = new Promise((resolve) => {
+          timer = setTimeout(() => resolve({ value: undefined, done: true }), remaining);
+        });
+        const result = await Promise.race([iterator.next(), timeoutPromise]);
+        if (timer !== undefined)
+          clearTimeout(timer);
+        if (result.done)
+          break;
+        const event = result.value;
+        if (event.type === "text_delta") {
+          parts.push(event.text);
+        }
+      }
+    } catch (err) {
+      if (parts.length === 0)
+        throw err;
+    } finally {
+      await iterator.return?.();
+    }
+    return parts.join("");
+  }
+  async toResponse() {
+    const parts = [];
+    let usage = null;
+    let stopReason = null;
+    for await (const event of this.source) {
+      switch (event.type) {
+        case "text_delta":
+          parts.push(event.text);
+          break;
+        case "message_end":
+          usage = event.usage;
+          stopReason = event.stopReason;
+          break;
+      }
+    }
+    return { text: parts.join(""), usage, stopReason };
+  }
+  pipe(transform) {
+    return new ElsiumStream(transform(this.source));
+  }
+  resilient(options = {}) {
+    const { checkpointIntervalMs = 1000, onCheckpoint, onPartialRecovery } = options;
+    const source = this.source;
+    const resilientSource = {
+      async* [Symbol.asyncIterator]() {
+        let lastCheckpointTime = Date.now();
+        let textAccumulator = "";
+        let eventIndex = 0;
+        try {
+          for await (const event of source) {
+            eventIndex++;
+            if (event.type === "text_delta") {
+              textAccumulator += event.text;
+            }
+            yield event;
+            if (shouldEmitCheckpoint(lastCheckpointTime, checkpointIntervalMs, textAccumulator.length)) {
+              const now = Date.now();
+              const checkpoint = createCheckpoint(textAccumulator, eventIndex, now);
+              onCheckpoint?.(checkpoint);
+              yield { type: "checkpoint", checkpoint };
+              lastCheckpointTime = now;
+            }
+          }
+        } catch (err) {
+          yield* emitErrorEvent(err, textAccumulator, onPartialRecovery);
+        }
+      }
+    };
+    return new ElsiumStream(resilientSource);
+  }
+}
+var MAX_BUFFER_SIZE = 1e4;
+function createStream(executor) {
+  let resolve = null;
+  const buffer = [];
+  let done = false;
+  let error = null;
+  let dropped = 0;
+  const source = {
+    [Symbol.asyncIterator]() {
+      return {
+        next() {
+          if (buffer.length > 0) {
+            const value = buffer.shift();
+            return Promise.resolve({ value, done: false });
+          }
+          if (done) {
+            return Promise.resolve({ value: undefined, done: true });
+          }
+          if (error) {
+            return Promise.reject(error);
+          }
+          return new Promise((r) => {
+            resolve = r;
+          });
+        }
+      };
+    }
+  };
+  const emit = (event) => {
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: event, done: false });
+    } else {
+      if (buffer.length < MAX_BUFFER_SIZE) {
+        buffer.push(event);
+      } else {
+        dropped++;
+      }
+    }
+  };
+  executor(emit).then(() => {
+    if (dropped > 0) {
+      emit({
+        type: "error",
+        error: new Error(`Stream buffer overflow: ${dropped} events dropped`)
+      });
+    }
+    done = true;
+    if (resolve) {
+      const r = resolve;
+      resolve = null;
+      r({ value: undefined, done: true });
+    }
+  }).catch((e) => {
+    error = e instanceof Error ? e : new Error(String(e));
+    if (resolve) {
+      resolve({ value: { type: "error", error }, done: false });
+      resolve = null;
+    }
+  });
+  return new ElsiumStream(source);
+}
+// ../core/src/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function createLogger(options = {}) {
+  const { level = "info", pretty = false, context = {} } = options;
+  const minLevel = LOG_LEVELS[level];
+  function log(logLevel, message, data) {
+    if (LOG_LEVELS[logLevel] < minLevel)
+      return;
+    const entry = {
+      ...context,
+      level: logLevel,
+      message,
+      timestamp: new Date().toISOString(),
+      ...data ? { data } : {}
+    };
+    const output = pretty ? JSON.stringify(entry, null, 2) : JSON.stringify(entry);
+    if (logLevel === "error") {
+      console.error(output);
+    } else if (logLevel === "warn") {
+      console.warn(output);
+    } else {
+      console.log(output);
+    }
+  }
+  return {
+    debug: (msg, data) => log("debug", msg, data),
+    info: (msg, data) => log("info", msg, data),
+    warn: (msg, data) => log("warn", msg, data),
+    error: (msg, data) => log("error", msg, data),
+    child(childContext) {
+      return createLogger({
+        level,
+        pretty,
+        context: { ...context, ...childContext }
+      });
+    }
+  };
+}
+// ../core/src/circuit-breaker.ts
+function defaultShouldCount(error) {
+  if (error && typeof error === "object" && "retryable" in error) {
+    return error.retryable === true;
+  }
+  return true;
+}
+function createCircuitBreaker(config) {
+  const failureThreshold = config?.failureThreshold ?? 5;
+  const resetTimeoutMs = config?.resetTimeoutMs ?? 30000;
+  const halfOpenMaxAttempts = config?.halfOpenMaxAttempts ?? 3;
+  const windowMs = config?.windowMs ?? 60000;
+  if (failureThreshold < 1 || !Number.isFinite(failureThreshold)) {
+    throw new ElsiumError({
+      code: "CONFIG_ERROR",
+      message: "failureThreshold must be >= 1",
+      retryable: false
+    });
+  }
+  if (resetTimeoutMs < 0 || !Number.isFinite(resetTimeoutMs)) {
+    throw new ElsiumError({
+      code: "CONFIG_ERROR",
+      message: "resetTimeoutMs must be >= 0 and finite",
+      retryable: false
+    });
+  }
+  if (halfOpenMaxAttempts < 1 || !Number.isFinite(halfOpenMaxAttempts)) {
+    throw new ElsiumError({
+      code: "CONFIG_ERROR",
+      message: "halfOpenMaxAttempts must be >= 1",
+      retryable: false
+    });
+  }
+  if (windowMs < 0 || !Number.isFinite(windowMs)) {
+    throw new ElsiumError({
+      code: "CONFIG_ERROR",
+      message: "windowMs must be >= 0 and finite",
+      retryable: false
+    });
+  }
+  const onStateChange = config?.onStateChange;
+  const shouldCount = config?.shouldCount ?? defaultShouldCount;
+  let currentState = "closed";
+  let failureTimestamps = [];
+  let lastOpenedAt = 0;
+  let halfOpenAttempts = 0;
+  let halfOpenInFlight = 0;
+  function transition(to) {
+    if (currentState === to)
+      return;
+    const from = currentState;
+    currentState = to;
+    onStateChange?.(from, to);
+  }
+  function recordFailure() {
+    const now = Date.now();
+    failureTimestamps.push(now);
+    failureTimestamps = failureTimestamps.filter((t) => now - t < windowMs);
+    if (failureTimestamps.length >= failureThreshold) {
+      lastOpenedAt = now;
+      halfOpenAttempts = 0;
+      transition("open");
+    }
+  }
+  function recordSuccess() {
+    if (currentState === "half-open") {
+      failureTimestamps = [];
+      halfOpenAttempts = 0;
+      halfOpenInFlight = 0;
+      transition("closed");
+    }
+  }
+  return {
+    get state() {
+      if (currentState === "open" && Date.now() - lastOpenedAt >= resetTimeoutMs) {
+        transition("half-open");
+      }
+      return currentState;
+    },
+    get failureCount() {
+      const now = Date.now();
+      return failureTimestamps.filter((t) => now - t < windowMs).length;
+    },
+    async execute(fn) {
+      const state = this.state;
+      if (state === "open") {
+        throw new ElsiumError({
+          code: "PROVIDER_ERROR",
+          message: "Circuit breaker is open",
+          retryable: true
+        });
+      }
+      if (state === "half-open" && halfOpenInFlight >= halfOpenMaxAttempts) {
+        lastOpenedAt = Date.now();
+        transition("open");
+        throw new ElsiumError({
+          code: "PROVIDER_ERROR",
+          message: "Circuit breaker is open",
+          retryable: true
+        });
+      }
+      if (state === "half-open") {
+        halfOpenAttempts++;
+        halfOpenInFlight++;
+      }
+      try {
+        const result = await fn();
+        recordSuccess();
+        return result;
+      } catch (error) {
+        if (shouldCount(error)) {
+          recordFailure();
+        }
+        throw error;
+      } finally {
+        if (state === "half-open") {
+          halfOpenInFlight = Math.max(0, halfOpenInFlight - 1);
+        }
+      }
+    },
+    reset() {
+      failureTimestamps = [];
+      halfOpenAttempts = 0;
+      halfOpenInFlight = 0;
+      transition("closed");
+    }
+  };
+}
+// src/provider.ts
+var providerRegistry = new Map;
+var metadataRegistry = new Map;
+function registerProvider(name, factory) {
+  providerRegistry.set(name, factory);
+}
+function getProviderFactory(name) {
+  return providerRegistry.get(name);
+}
+function listProviders() {
+  return Array.from(providerRegistry.keys());
+}
+function registerProviderMetadata(name, metadata) {
+  metadataRegistry.set(name, metadata);
+}
+function getProviderMetadata(name) {
+  return metadataRegistry.get(name);
+}
+
+// src/middleware.ts
+function composeMiddleware(middlewares) {
+  return (ctx, finalNext) => {
+    let index = -1;
+    function dispatch(i) {
+      if (i <= index) {
+        return Promise.reject(new Error("Middleware next() called multiple times"));
+      }
+      index = i;
+      const fn = i < middlewares.length ? middlewares[i] : finalNext;
+      if (i === middlewares.length) {
+        return finalNext(ctx);
+      }
+      return fn(ctx, () => dispatch(i + 1));
+    }
+    return dispatch(0);
+  };
+}
+function loggingMiddleware(logger) {
+  const log = logger ?? createLogger({ level: "info" });
+  return async (ctx, next) => {
+    log.info("LLM request", {
+      provider: ctx.provider,
+      model: ctx.model,
+      traceId: ctx.traceId,
+      messageCount: ctx.request.messages.length
+    });
+    const response = await next(ctx);
+    log.info("LLM response", {
+      provider: ctx.provider,
+      model: ctx.model,
+      traceId: ctx.traceId,
+      latencyMs: response.latencyMs,
+      inputTokens: response.usage.inputTokens,
+      outputTokens: response.usage.outputTokens,
+      totalCost: response.cost.totalCost
+    });
+    return response;
+  };
+}
+function costTrackingMiddleware() {
+  let totalCost = 0;
+  let totalTokens = 0;
+  let callCount = 0;
+  const middleware = async (ctx, next) => {
+    const response = await next(ctx);
+    totalCost += response.cost.totalCost;
+    totalTokens += response.usage.totalTokens;
+    callCount++;
+    return response;
+  };
+  middleware.getTotalCost = () => totalCost;
+  middleware.getTotalTokens = () => totalTokens;
+  middleware.getCallCount = () => callCount;
+  middleware.reset = () => {
+    totalCost = 0;
+    totalTokens = 0;
+    callCount = 0;
+  };
+  return middleware;
+}
+var SENSITIVE_HEADERS = ["x-api-key", "authorization", "api-key"];
+function redactHeaders(headers) {
+  const redacted = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (SENSITIVE_HEADERS.includes(key.toLowerCase())) {
+      redacted[key] = "[REDACTED]";
+    } else {
+      redacted[key] = value;
+    }
+  }
+  return redacted;
+}
+var PROVIDER_URLS = {
+  anthropic: "https://api.anthropic.com/v1/messages",
+  openai: "https://api.openai.com/v1/chat/completions",
+  google: "https://generativelanguage.googleapis.com/v1beta/models"
+};
+function buildProviderHeaders(provider, metadata) {
+  const headers = { "Content-Type": "application/json" };
+  const apiKey = metadata._apiKey ?? "***";
+  const providerMeta = getProviderMetadata(provider);
+  const authStyle = providerMeta?.authStyle;
+  if (authStyle === "x-api-key" || provider === "anthropic") {
+    headers["x-api-key"] = apiKey;
+  } else {
+    headers.Authorization = apiKey;
+  }
+  return redactHeaders(headers);
+}
+function truncateContent(content) {
+  if (typeof content !== "string")
+    return "[complex content]";
+  if (content.length > 200)
+    return `${content.slice(0, 200)}...`;
+  return content;
+}
+function buildXRayRequest(ctx) {
+  const providerMeta = getProviderMetadata(ctx.provider);
+  return {
+    url: PROVIDER_URLS[ctx.provider] ?? providerMeta?.baseUrl ?? `https://${ctx.provider}.api/v1/messages`,
+    method: "POST",
+    headers: buildProviderHeaders(ctx.provider, ctx.metadata),
+    body: {
+      model: ctx.model,
+      messages: ctx.request.messages.map((m) => ({
+        role: m.role,
+        content: truncateContent(m.content)
+      })),
+      max_tokens: ctx.request.maxTokens,
+      ...ctx.request.temperature !== undefined ? { temperature: ctx.request.temperature } : {},
+      ...ctx.request.tools?.length ? { tools: ctx.request.tools.map((t) => t.name) } : {}
+    }
+  };
+}
+function buildXRayResponse(response) {
+  return {
+    status: 200,
+    headers: { "content-type": "application/json" },
+    body: {
+      id: response.id,
+      model: response.model,
+      stop_reason: response.stopReason,
+      content_preview: truncateContent(response.message.content)
+    }
+  };
+}
+function buildXRayData(ctx, response, latencyMs) {
+  return {
+    traceId: ctx.traceId,
+    timestamp: Date.now(),
+    provider: ctx.provider,
+    model: ctx.model,
+    latencyMs,
+    request: buildXRayRequest(ctx),
+    response: buildXRayResponse(response),
+    usage: response.usage,
+    cost: response.cost
+  };
+}
+function xrayMiddleware(options = {}) {
+  const maxHistory = options.maxHistory ?? 100;
+  const history = [];
+  const middleware = async (ctx, next) => {
+    const startTime = performance.now();
+    const response = await next(ctx);
+    const latencyMs = Math.round(performance.now() - startTime);
+    const xrayData = buildXRayData(ctx, response, latencyMs);
+    history.unshift(xrayData);
+    if (history.length > maxHistory) {
+      history.length = maxHistory;
+    }
+    return response;
+  };
+  middleware.lastCall = () => history[0] ?? null;
+  middleware.callHistory = (limit = 10) => history.slice(0, limit);
+  middleware.getByTraceId = (traceId) => history.find((d) => d.traceId === traceId);
+  middleware.clear = () => {
+    history.length = 0;
+  };
+  return middleware;
+}
+
+// src/pricing.ts
+var log = createLogger();
+var PRICING = {
+  "claude-opus-4-6": { inputPerMillion: 15, outputPerMillion: 75 },
+  "claude-sonnet-4-6": { inputPerMillion: 3, outputPerMillion: 15 },
+  "claude-haiku-4-5-20251001": { inputPerMillion: 1, outputPerMillion: 5 },
+  "gpt-4o": { inputPerMillion: 2.5, outputPerMillion: 10 },
+  "gpt-4o-mini": { inputPerMillion: 0.15, outputPerMillion: 0.6 },
+  "gpt-4.1": { inputPerMillion: 2, outputPerMillion: 8 },
+  "gpt-4.1-mini": { inputPerMillion: 0.4, outputPerMillion: 1.6 },
+  "gpt-4.1-nano": { inputPerMillion: 0.1, outputPerMillion: 0.4 },
+  "gpt-5": { inputPerMillion: 1.25, outputPerMillion: 10 },
+  "gpt-5-mini": { inputPerMillion: 0.25, outputPerMillion: 2 },
+  "gpt-5-nano": { inputPerMillion: 0.05, outputPerMillion: 0.4 },
+  o1: { inputPerMillion: 15, outputPerMillion: 60 },
+  "o1-mini": { inputPerMillion: 1.1, outputPerMillion: 4.4 },
+  o3: { inputPerMillion: 2, outputPerMillion: 8 },
+  "o3-mini": { inputPerMillion: 1.1, outputPerMillion: 4.4 },
+  "o3-pro": { inputPerMillion: 20, outputPerMillion: 80 },
+  "o4-mini": { inputPerMillion: 1.1, outputPerMillion: 4.4 },
+  "gemini-2.0-flash": { inputPerMillion: 0.1, outputPerMillion: 0.4 },
+  "gemini-2.0-flash-lite": { inputPerMillion: 0.075, outputPerMillion: 0.3 },
+  "gemini-2.5-pro": { inputPerMillion: 1.25, outputPerMillion: 10 },
+  "gemini-2.5-pro-preview-05-06": { inputPerMillion: 1.25, outputPerMillion: 10 },
+  "gemini-2.5-flash": { inputPerMillion: 0.15, outputPerMillion: 0.6 },
+  "gemini-2.5-flash-preview-04-17": { inputPerMillion: 0.15, outputPerMillion: 0.6 },
+  "gemini-2.5-flash-lite": { inputPerMillion: 0.075, outputPerMillion: 0.3 }
+};
+function resolveModelName(model) {
+  if (PRICING[model])
+    return model;
+  const base = model.replace(/-\d{4}-\d{2}-\d{2}$/, "");
+  if (base !== model && PRICING[base])
+    return base;
+  return model;
+}
+function calculateCost(model, usage) {
+  const pricing = PRICING[resolveModelName(model)];
+  if (!pricing) {
+    log.warn(`Unknown model "${model}" \u2014 cost will be reported as $0. Register pricing with registerPricing().`);
+    return {
+      inputCost: 0,
+      outputCost: 0,
+      totalCost: 0,
+      currency: "USD"
+    };
+  }
+  const inputCost = usage.inputTokens / 1e6 * pricing.inputPerMillion;
+  const outputCost = usage.outputTokens / 1e6 * pricing.outputPerMillion;
+  return {
+    inputCost: Math.round(inputCost * 1e6) / 1e6,
+    outputCost: Math.round(outputCost * 1e6) / 1e6,
+    totalCost: Math.round((inputCost + outputCost) * 1e6) / 1e6,
+    currency: "USD"
+  };
+}
+function registerPricing(model, pricing) {
+  PRICING[model] = pricing;
+}
+
+// src/providers/anthropic.ts
+var DEFAULT_BASE_URL = "https://api.anthropic.com";
+var API_VERSION = "2023-06-01";
+var DEFAULT_MAX_TOKENS = 4096;
+function createAnthropicProvider(config) {
+  const { apiKey, baseUrl = DEFAULT_BASE_URL, timeout = 60000, maxRetries = 2 } = config;
+  async function request(path, body, signal) {
+    const url = `${baseUrl}/v1${path}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": API_VERSION
+      },
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "Unknown error");
+      if (response.status === 401)
+        throw ElsiumError.authError("anthropic");
+      if (response.status === 429) {
+        const retryAfter = response.headers.get("retry-after");
+        throw ElsiumError.rateLimit("anthropic", retryAfter ? Number.parseInt(retryAfter) * 1000 : undefined);
+      }
+      throw ElsiumError.providerError(`Anthropic API error ${response.status}: ${errorBody}`, {
+        provider: "anthropic",
+        statusCode: response.status,
+        retryable: response.status >= 500
+      });
+    }
+    return response;
+  }
+  function extractSystemText(msg) {
+    if (typeof msg.content === "string")
+      return msg.content;
+    return msg.content.filter((p) => p.type === "text").map((p) => p.text).join(`
+`);
+  }
+  function formatToolResultMessage(msg) {
+    const blocks = (msg.toolResults ?? []).map((tr) => ({
+      type: "tool_result",
+      tool_use_id: tr.toolCallId,
+      content: tr.content
+    }));
+    return { role: "user", content: blocks };
+  }
+  function formatStringContent(msg, role) {
+    const blocks = [];
+    const text = msg.content;
+    if (text) {
+      blocks.push({ type: "text", text });
+    }
+    if (msg.toolCalls?.length) {
+      for (const tc of msg.toolCalls) {
+        blocks.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.name,
+          input: tc.arguments
+        });
+      }
+    }
+    if (blocks.length === 0) {
+      return { role, content: text };
+    }
+    return { role, content: blocks };
+  }
+  function convertContentPart(part) {
+    if (part.type === "text")
+      return { type: "text", text: part.text };
+    if (part.type === "image" && part.source?.type === "base64") {
+      return {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: part.source.mediaType,
+          data: part.source.data
+        }
+      };
+    }
+    return { type: "text", text: "[unsupported content]" };
+  }
+  function formatMultipartContent(msg, role) {
+    const content = msg.content;
+    const blocks = content.map(convertContentPart);
+    return { role, content: blocks };
+  }
+  function formatMessages(messages) {
+    let system;
+    const formatted = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        system = extractSystemText(msg);
+        continue;
+      }
+      if (msg.role === "tool") {
+        formatted.push(formatToolResultMessage(msg));
+        continue;
+      }
+      const role = msg.role === "assistant" ? "assistant" : "user";
+      if (typeof msg.content === "string") {
+        formatted.push(formatStringContent(msg, role));
+      } else {
+        formatted.push(formatMultipartContent(msg, role));
+      }
+    }
+    return { system, messages: formatted };
+  }
+  function buildSeedMetadata(req) {
+    if (req.seed === undefined)
+      return {};
+    return { metadata: { ...req.metadata ?? {}, seed: req.seed } };
+  }
+  function formatTools(tools) {
+    if (!tools?.length)
+      return;
+    return tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputSchema
+    }));
+  }
+  function extractContentBlocks(content) {
+    const toolCalls = [];
+    const textParts = [];
+    for (const block of content) {
+      if (block.type === "text" && block.text) {
+        textParts.push(block.text);
+      } else if (block.type === "tool_use" && block.id && block.name) {
+        toolCalls.push({
+          id: block.id,
+          name: block.name,
+          arguments: block.input ?? {}
+        });
+      }
+    }
+    return { textParts, toolCalls };
+  }
+  function parseResponse(raw, latencyMs) {
+    const traceId = generateTraceId();
+    const { textParts, toolCalls } = extractContentBlocks(raw.content);
+    const usage = {
+      inputTokens: raw.usage.input_tokens,
+      outputTokens: raw.usage.output_tokens,
+      totalTokens: raw.usage.input_tokens + raw.usage.output_tokens,
+      cacheReadTokens: raw.usage.cache_read_input_tokens,
+      cacheWriteTokens: raw.usage.cache_creation_input_tokens
+    };
+    return {
+      id: raw.id,
+      message: {
+        role: "assistant",
+        content: textParts.join(""),
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined
+      },
+      usage,
+      cost: calculateCost(raw.model, usage),
+      model: raw.model,
+      provider: "anthropic",
+      stopReason: mapAnthropicStopReason(raw.stop_reason),
+      latencyMs,
+      traceId
+    };
+  }
+  return {
+    name: "anthropic",
+    defaultModel: "claude-sonnet-4-6",
+    metadata: {
+      baseUrl: "https://api.anthropic.com/v1/messages",
+      capabilities: ["tools", "vision", "streaming", "system"],
+      authStyle: "x-api-key"
+    },
+    async complete(req) {
+      const { system, messages } = formatMessages(req.messages);
+      const model = req.model ?? "claude-sonnet-4-6";
+      const body = {
+        model,
+        messages,
+        max_tokens: req.maxTokens ?? DEFAULT_MAX_TOKENS,
+        ...system || req.system ? { system: req.system ?? system } : {},
+        ...req.temperature !== undefined ? { temperature: req.temperature } : {},
+        ...req.topP !== undefined ? { top_p: req.topP } : {},
+        ...req.stopSequences?.length ? { stop_sequences: req.stopSequences } : {},
+        ...buildSeedMetadata(req)
+      };
+      const tools = formatTools(req.tools);
+      if (tools)
+        body.tools = tools;
+      const startTime = performance.now();
+      const raw = await retry(async () => {
+        const controller = new AbortController;
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+          const signals = [controller.signal, req.signal].filter(Boolean);
+          const mergedSignal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+          const resp = await request("/messages", body, mergedSignal);
+          return await resp.json();
+        } finally {
+          clearTimeout(timer);
+        }
+      }, {
+        maxRetries,
+        baseDelayMs: 1000,
+        shouldRetry: (e) => e instanceof ElsiumError && e.retryable
+      });
+      const latencyMs = Math.round(performance.now() - startTime);
+      return parseResponse(raw, latencyMs);
+    },
+    stream(req) {
+      const { system, messages } = formatMessages(req.messages);
+      const model = req.model ?? "claude-sonnet-4-6";
+      const body = {
+        model,
+        messages,
+        max_tokens: req.maxTokens ?? DEFAULT_MAX_TOKENS,
+        stream: true,
+        ...system || req.system ? { system: req.system ?? system } : {},
+        ...req.temperature !== undefined ? { temperature: req.temperature } : {},
+        ...req.topP !== undefined ? { top_p: req.topP } : {},
+        ...req.stopSequences?.length ? { stop_sequences: req.stopSequences } : {},
+        ...buildSeedMetadata(req)
+      };
+      const tools = formatTools(req.tools);
+      if (tools)
+        body.tools = tools;
+      return createStream(async (emit) => {
+        const controller = new AbortController;
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+          const signals = [controller.signal, req.signal].filter(Boolean);
+          const mergedSignal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+          const resp = await request("/messages", body, mergedSignal);
+          if (!resp.body)
+            throw new ElsiumError({
+              code: "STREAM_ERROR",
+              message: "Response body is null",
+              provider: "anthropic",
+              retryable: false
+            });
+          await processAnthropicSSEStream(resp.body, model, emit);
+        } finally {
+          clearTimeout(timer);
+        }
+      });
+    },
+    async listModels() {
+      return ["claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5-20251001"];
+    }
+  };
+}
+function mapAnthropicStopReason(reason) {
+  if (reason === "end_turn")
+    return "end_turn";
+  if (reason === "max_tokens")
+    return "max_tokens";
+  if (reason === "tool_use")
+    return "tool_use";
+  return "end_turn";
+}
+function processSSELine(line, model, emit) {
+  if (!line.startsWith("data: "))
+    return;
+  const data = line.slice(6).trim();
+  if (data === "[DONE]")
+    return;
+  try {
+    const event = JSON.parse(data);
+    const mapped = mapSSEEvent(event, model);
+    if (mapped)
+      emit(mapped);
+  } catch (err2) {
+    emit({ type: "error", error: err2 instanceof Error ? err2 : new Error(String(err2)) });
+  }
+}
+async function processAnthropicSSEStream(body, model, emit) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split(`
+`);
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      processSSELine(line, model, emit);
+    }
+  }
+}
+function mapSSEEventMessageStart(event, model) {
+  const msg = event.message;
+  return {
+    type: "message_start",
+    id: msg?.id ?? generateId("msg"),
+    model
+  };
+}
+function mapSSEEventContentBlockStart(event) {
+  const block = event.content_block;
+  if (block?.type === "tool_use") {
+    return {
+      type: "tool_call_start",
+      toolCall: { id: block.id ?? "", name: block.name ?? "" }
+    };
+  }
+  return null;
+}
+function mapSSEEventContentBlockDelta(event) {
+  const delta = event.delta;
+  if (delta?.type === "text_delta" && delta.text) {
+    return { type: "text_delta", text: delta.text };
+  }
+  if (delta?.type === "input_json_delta" && delta.partial_json) {
+    return {
+      type: "tool_call_delta",
+      toolCallId: "",
+      arguments: delta.partial_json
+    };
+  }
+  return null;
+}
+function mapSSEEventMessageDelta(event) {
+  const delta = event.delta;
+  const usage = event.usage;
+  if (!delta?.stop_reason)
+    return null;
+  const inputTokens = usage?.input_tokens ?? 0;
+  const outputTokens = usage?.output_tokens ?? 0;
+  return {
+    type: "message_end",
+    usage: {
+      inputTokens,
+      outputTokens,
+      totalTokens: inputTokens + outputTokens
+    },
+    stopReason: mapAnthropicStopReason(delta.stop_reason)
+  };
+}
+function mapSSEEvent(event, model) {
+  switch (event.type) {
+    case "message_start":
+      return mapSSEEventMessageStart(event, model);
+    case "content_block_start":
+      return mapSSEEventContentBlockStart(event);
+    case "content_block_delta":
+      return mapSSEEventContentBlockDelta(event);
+    case "content_block_stop":
+      return null;
+    case "message_delta":
+      return mapSSEEventMessageDelta(event);
+    default:
+      return null;
+  }
+}
+
+// src/providers/google.ts
+var DEFAULT_BASE_URL2 = "https://generativelanguage.googleapis.com";
+function createGoogleProvider(config) {
+  const { apiKey, baseUrl = DEFAULT_BASE_URL2, timeout = 60000, maxRetries = 2 } = config;
+  function extractGeminiSystemText(msg) {
+    if (typeof msg.content === "string")
+      return msg.content;
+    return msg.content.filter((p) => p.type === "text").map((p) => p.text).join(`
+`);
+  }
+  function formatToolResultContents(msg) {
+    const results = [];
+    for (const tr of msg.toolResults ?? []) {
+      const name = tr.toolName ?? tr.toolCallId;
+      results.push({
+        role: "user",
+        parts: [
+          {
+            functionResponse: {
+              name,
+              response: { content: tr.content }
+            }
+          }
+        ]
+      });
+    }
+    return results;
+  }
+  function formatGeminiStringContent(msg, role) {
+    const parts = [{ text: msg.content }];
+    if (msg.toolCalls?.length) {
+      for (const tc of msg.toolCalls) {
+        parts.push({
+          functionCall: { name: tc.name, args: tc.arguments }
+        });
+      }
+    }
+    return { role, parts };
+  }
+  function formatGeminiMultipartContent(msg, role) {
+    const parts = msg.content.filter((p) => p.type === "text").map((p) => ({ text: p.text }));
+    return { role, parts };
+  }
+  function formatMessages(messages) {
+    let systemInstruction;
+    const contents = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        systemInstruction = { parts: [{ text: extractGeminiSystemText(msg) }] };
+        continue;
+      }
+      if (msg.role === "tool") {
+        contents.push(...formatToolResultContents(msg));
+        continue;
+      }
+      const role = msg.role === "assistant" ? "model" : "user";
+      if (typeof msg.content === "string") {
+        contents.push(formatGeminiStringContent(msg, role));
+      } else {
+        contents.push(formatGeminiMultipartContent(msg, role));
+      }
+    }
+    return { systemInstruction, contents };
+  }
+  function formatTools(tools) {
+    if (!tools?.length)
+      return;
+    return [
+      {
+        functionDeclarations: tools.map((t) => ({
+          name: t.name,
+          description: t.description,
+          parameters: t.inputSchema
+        }))
+      }
+    ];
+  }
+  function extractGeminiParts(parts) {
+    const toolCalls = [];
+    const textParts = [];
+    for (const part of parts) {
+      if (part.text) {
+        textParts.push(part.text);
+      }
+      if (part.functionCall) {
+        toolCalls.push({
+          id: generateId("tc"),
+          name: part.functionCall.name,
+          arguments: part.functionCall.args ?? {}
+        });
+      }
+    }
+    return { textParts, toolCalls };
+  }
+  function parseResponse(raw, model, latencyMs) {
+    const traceId = generateTraceId();
+    const candidate = raw.candidates?.[0];
+    const parts = candidate?.content?.parts ?? [];
+    const { textParts, toolCalls } = extractGeminiParts(parts);
+    const usage = {
+      inputTokens: raw.usageMetadata?.promptTokenCount ?? 0,
+      outputTokens: raw.usageMetadata?.candidatesTokenCount ?? 0,
+      totalTokens: raw.usageMetadata?.totalTokenCount ?? 0
+    };
+    return {
+      id: generateId("msg"),
+      message: {
+        role: "assistant",
+        content: textParts.join(""),
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined
+      },
+      usage,
+      cost: calculateCost(model, usage),
+      model,
+      provider: "google",
+      stopReason: mapGeminiStopReason(candidate?.finishReason, toolCalls.length > 0),
+      latencyMs,
+      traceId
+    };
+  }
+  function resolveSystemInstruction(reqSystem, parsed) {
+    if (reqSystem)
+      return { parts: [{ text: reqSystem }] };
+    return parsed;
+  }
+  function buildGenerationConfig(req) {
+    const config2 = {
+      maxOutputTokens: req.maxTokens ?? 4096
+    };
+    if (req.temperature !== undefined)
+      config2.temperature = req.temperature;
+    if (req.seed !== undefined)
+      config2.seed = req.seed;
+    if (req.topP !== undefined)
+      config2.topP = req.topP;
+    if (req.stopSequences?.length)
+      config2.stopSequences = req.stopSequences;
+    return config2;
+  }
+  function buildRequestBody(req) {
+    const { systemInstruction, contents } = formatMessages(req.messages);
+    const resolved = resolveSystemInstruction(req.system, systemInstruction);
+    const body = {
+      contents,
+      generationConfig: buildGenerationConfig(req)
+    };
+    if (resolved)
+      body.systemInstruction = resolved;
+    const tools = formatTools(req.tools);
+    if (tools)
+      body.tools = tools;
+    return body;
+  }
+  return {
+    name: "google",
+    defaultModel: "gemini-2.0-flash",
+    metadata: {
+      baseUrl: "https://generativelanguage.googleapis.com/v1beta/models",
+      capabilities: ["tools", "vision", "streaming", "system"],
+      authStyle: "bearer"
+    },
+    async complete(req) {
+      const model = req.model ?? "gemini-2.0-flash";
+      const body = buildRequestBody(req);
+      const startTime = performance.now();
+      const raw = await retry(() => googleRequest(baseUrl, model, apiKey, body, timeout, req.signal), {
+        maxRetries,
+        baseDelayMs: 1000,
+        shouldRetry: (e) => e instanceof ElsiumError && e.retryable
+      });
+      const latencyMs = Math.round(performance.now() - startTime);
+      return parseResponse(raw, model, latencyMs);
+    },
+    stream(req) {
+      const model = req.model ?? "gemini-2.0-flash";
+      const body = buildRequestBody(req);
+      return createStream(async (emit) => {
+        const controller = new AbortController;
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+          const signals = [controller.signal, req.signal].filter(Boolean);
+          const mergedSignal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+          const response = await fetchGoogleStream(baseUrl, model, apiKey, body, mergedSignal);
+          emit({ type: "message_start", id: generateId("msg"), model });
+          await processGeminiSSEStream(response.body, emit);
+        } finally {
+          clearTimeout(timer);
+        }
+      });
+    },
+    async listModels() {
+      return [
+        "gemini-2.0-flash",
+        "gemini-2.0-flash-lite",
+        "gemini-2.5-pro-preview-05-06",
+        "gemini-2.5-flash-preview-04-17"
+      ];
+    }
+  };
+}
+function mapGeminiStopReason(finishReason, hasToolCalls = false) {
+  if (finishReason === "STOP")
+    return "end_turn";
+  if (finishReason === "MAX_TOKENS")
+    return "max_tokens";
+  if (finishReason === "TOOL_CALLS" || hasToolCalls)
+    return "tool_use";
+  return "end_turn";
+}
+async function handleGoogleErrorResponse(response) {
+  const errorBody = await response.text().catch(() => "Unknown error");
+  if (response.status === 401 || response.status === 403) {
+    throw ElsiumError.authError("google");
+  }
+  if (response.status === 429) {
+    throw ElsiumError.rateLimit("google");
+  }
+  throw ElsiumError.providerError(`Google API error ${response.status}: ${errorBody}`, {
+    provider: "google",
+    statusCode: response.status,
+    retryable: response.status >= 500
+  });
+}
+async function googleRequest(baseUrl, model, apiKey, body, timeout, reqSignal) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const signals = [controller.signal, reqSignal].filter(Boolean);
+    const mergedSignal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+    const url = `${baseUrl}/v1beta/models/${model}:generateContent`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "x-goog-api-key": apiKey },
+      body: JSON.stringify(body),
+      signal: mergedSignal
+    });
+    if (!response.ok) {
+      await handleGoogleErrorResponse(response);
+    }
+    return await response.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchGoogleStream(baseUrl, model, apiKey, body, signal) {
+  const url = `${baseUrl}/v1beta/models/${model}:streamGenerateContent?alt=sse`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "x-goog-api-key": apiKey },
+    body: JSON.stringify(body),
+    signal
+  });
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => "Unknown error");
+    throw ElsiumError.providerError(`Google API error ${response.status}: ${errorBody}`, {
+      provider: "google",
+      retryable: response.status >= 500
+    });
+  }
+  if (!response.body) {
+    throw new ElsiumError({
+      code: "STREAM_ERROR",
+      message: "Response body is null",
+      provider: "google",
+      retryable: false
+    });
+  }
+  return response;
+}
+function emitGeminiPartEvents(part, emit) {
+  if (part.text) {
+    emit({ type: "text_delta", text: part.text });
+  }
+  if (part.functionCall) {
+    const toolCallId = generateId("tc");
+    emit({
+      type: "tool_call_start",
+      toolCall: { id: toolCallId, name: part.functionCall.name }
+    });
+    emit({
+      type: "tool_call_delta",
+      toolCallId,
+      arguments: JSON.stringify(part.functionCall.args)
+    });
+    emit({ type: "tool_call_end", toolCallId });
+  }
+}
+function emitGeminiFinishEvent(event, emit) {
+  const finishReason = event.candidates?.[0]?.finishReason;
+  if (!finishReason)
+    return;
+  const usage = {
+    inputTokens: event.usageMetadata?.promptTokenCount ?? 0,
+    outputTokens: event.usageMetadata?.candidatesTokenCount ?? 0,
+    totalTokens: event.usageMetadata?.totalTokenCount ?? 0
+  };
+  emit({
+    type: "message_end",
+    usage,
+    stopReason: mapGeminiStopReason(finishReason, false)
+  });
+}
+function processGeminiSSEEvent(event, emit) {
+  const parts = event.candidates?.[0]?.content?.parts ?? [];
+  for (const part of parts) {
+    emitGeminiPartEvents(part, emit);
+  }
+  emitGeminiFinishEvent(event, emit);
+}
+function processGeminiSSELine(line, emit) {
+  if (!line.startsWith("data: "))
+    return;
+  const data = line.slice(6).trim();
+  try {
+    const event = JSON.parse(data);
+    processGeminiSSEEvent(event, emit);
+  } catch (err2) {
+    emit({ type: "error", error: err2 instanceof Error ? err2 : new Error(String(err2)) });
+  }
+}
+async function processGeminiSSEStream(body, emit) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split(`
+`);
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      processGeminiSSELine(line, emit);
+    }
+  }
+}
+
+// src/providers/openai.ts
+var DEFAULT_BASE_URL3 = "https://api.openai.com";
+var DEFAULT_MAX_TOKENS2 = 4096;
+function createOpenAIProvider(config) {
+  const { apiKey, baseUrl = DEFAULT_BASE_URL3, timeout = 60000, maxRetries = 2 } = config;
+  async function request(path, body, signal) {
+    const url = `${baseUrl}/v1${path}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "Unknown error");
+      if (response.status === 401)
+        throw ElsiumError.authError("openai");
+      if (response.status === 429) {
+        const retryAfter = response.headers.get("retry-after");
+        throw ElsiumError.rateLimit("openai", retryAfter ? Number.parseInt(retryAfter) * 1000 : undefined);
+      }
+      throw ElsiumError.providerError(`OpenAI API error ${response.status}: ${errorBody}`, {
+        provider: "openai",
+        statusCode: response.status,
+        retryable: response.status >= 500
+      });
+    }
+    return response;
+  }
+  function extractTextContent(msg) {
+    if (typeof msg.content === "string")
+      return msg.content;
+    return msg.content.filter((p) => p.type === "text").map((p) => p.text).join(`
+`);
+  }
+  function formatSystemMessage(msg) {
+    return { role: "system", content: extractTextContent(msg) };
+  }
+  function formatToolMessages(msg) {
+    return (msg.toolResults ?? []).map((tr) => ({
+      role: "tool",
+      content: tr.content,
+      tool_call_id: tr.toolCallId
+    }));
+  }
+  function formatAssistantMessage(msg) {
+    const content = extractTextContent(msg);
+    const openaiMsg = { role: "assistant", content: content || null };
+    if (msg.toolCalls?.length) {
+      openaiMsg.tool_calls = msg.toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: {
+          name: tc.name,
+          arguments: JSON.stringify(tc.arguments)
+        }
+      }));
+    }
+    return openaiMsg;
+  }
+  function formatMessages(messages) {
+    const formatted = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        formatted.push(formatSystemMessage(msg));
+        continue;
+      }
+      if (msg.role === "tool") {
+        formatted.push(...formatToolMessages(msg));
+        continue;
+      }
+      if (msg.role === "assistant") {
+        formatted.push(formatAssistantMessage(msg));
+        continue;
+      }
+      formatted.push({ role: "user", content: extractTextContent(msg) });
+    }
+    return formatted;
+  }
+  function formatTools(tools) {
+    if (!tools?.length)
+      return;
+    return tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.inputSchema
+      }
+    }));
+  }
+  function parseResponse(raw, latencyMs) {
+    const traceId = generateTraceId();
+    const choice = raw.choices[0];
+    const toolCalls = (choice?.message.tool_calls ?? []).map((tc) => {
+      let args = {};
+      try {
+        args = JSON.parse(tc.function.arguments);
+      } catch {
+        args = { _raw: tc.function.arguments };
+      }
+      return { id: tc.id, name: tc.function.name, arguments: args };
+    });
+    const usage = {
+      inputTokens: raw.usage.prompt_tokens,
+      outputTokens: raw.usage.completion_tokens,
+      totalTokens: raw.usage.total_tokens
+    };
+    const finishReason = choice?.finish_reason;
+    const stopReason = finishReason === "stop" ? "end_turn" : finishReason === "length" ? "max_tokens" : finishReason === "tool_calls" ? "tool_use" : "end_turn";
+    return {
+      id: raw.id,
+      message: {
+        role: "assistant",
+        content: choice?.message.content ?? "",
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined
+      },
+      usage,
+      cost: calculateCost(raw.model, usage),
+      model: raw.model,
+      provider: "openai",
+      stopReason,
+      latencyMs,
+      traceId
+    };
+  }
+  return {
+    name: "openai",
+    defaultModel: "gpt-4o",
+    metadata: {
+      baseUrl: "https://api.openai.com/v1/chat/completions",
+      capabilities: ["tools", "vision", "streaming", "system", "json_mode"],
+      authStyle: "bearer"
+    },
+    async complete(req) {
+      const messages = formatMessages(req.messages);
+      const model = req.model ?? "gpt-4o";
+      if (req.system) {
+        messages.unshift({ role: "system", content: req.system });
+      }
+      const body = {
+        model,
+        messages,
+        max_tokens: req.maxTokens ?? DEFAULT_MAX_TOKENS2,
+        ...req.temperature !== undefined ? { temperature: req.temperature } : {},
+        ...req.seed !== undefined ? { seed: req.seed } : {},
+        ...req.topP !== undefined ? { top_p: req.topP } : {},
+        ...req.stopSequences?.length ? { stop: req.stopSequences } : {}
+      };
+      const tools = formatTools(req.tools);
+      if (tools)
+        body.tools = tools;
+      const startTime = performance.now();
+      const raw = await retry(async () => {
+        const controller = new AbortController;
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+          const signals = [controller.signal, req.signal].filter(Boolean);
+          const mergedSignal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+          const resp = await request("/chat/completions", body, mergedSignal);
+          return await resp.json();
+        } finally {
+          clearTimeout(timer);
+        }
+      }, {
+        maxRetries,
+        baseDelayMs: 1000,
+        shouldRetry: (e) => e instanceof ElsiumError && e.retryable
+      });
+      const latencyMs = Math.round(performance.now() - startTime);
+      return parseResponse(raw, latencyMs);
+    },
+    stream(req) {
+      const messages = formatMessages(req.messages);
+      const model = req.model ?? "gpt-4o";
+      if (req.system) {
+        messages.unshift({ role: "system", content: req.system });
+      }
+      const body = {
+        model,
+        messages,
+        max_tokens: req.maxTokens ?? DEFAULT_MAX_TOKENS2,
+        stream: true,
+        stream_options: { include_usage: true },
+        ...req.temperature !== undefined ? { temperature: req.temperature } : {},
+        ...req.seed !== undefined ? { seed: req.seed } : {},
+        ...req.topP !== undefined ? { top_p: req.topP } : {},
+        ...req.stopSequences?.length ? { stop: req.stopSequences } : {}
+      };
+      const tools = formatTools(req.tools);
+      if (tools)
+        body.tools = tools;
+      return createStream(async (emit) => {
+        const controller = new AbortController;
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+          const signals = [controller.signal, req.signal].filter(Boolean);
+          const mergedSignal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+          const resp = await request("/chat/completions", body, mergedSignal);
+          if (!resp.body)
+            throw new ElsiumError({
+              code: "STREAM_ERROR",
+              message: "Response body is null",
+              provider: "openai",
+              retryable: false
+            });
+          emit({ type: "message_start", id: generateId("msg"), model });
+          await processOpenAISSEStream(resp.body, emit);
+        } finally {
+          clearTimeout(timer);
+        }
+      });
+    },
+    async listModels() {
+      return ["gpt-4o", "gpt-4o-mini", "o1", "o1-mini", "o3-mini"];
+    }
+  };
+}
+function emitOpenAIToolCallEvents(toolCalls, emit) {
+  for (const tc of toolCalls) {
+    if (tc.function?.name) {
+      emit({
+        type: "tool_call_start",
+        toolCall: { id: tc.id ?? "", name: tc.function.name }
+      });
+    }
+    if (tc.function?.arguments) {
+      emit({
+        type: "tool_call_delta",
+        toolCallId: tc.id ?? "",
+        arguments: tc.function.arguments
+      });
+    }
+  }
+}
+function processOpenAISSEChunk(event, emit, state) {
+  const eventUsage = event.usage;
+  if (eventUsage) {
+    state.usage = {
+      inputTokens: eventUsage.prompt_tokens ?? 0,
+      outputTokens: eventUsage.completion_tokens ?? 0,
+      totalTokens: eventUsage.total_tokens ?? 0
+    };
+  }
+  const delta = event.choices?.[0]?.delta;
+  if (delta?.content) {
+    emit({ type: "text_delta", text: delta.content });
+  }
+  if (delta?.tool_calls) {
+    emitOpenAIToolCallEvents(delta.tool_calls, emit);
+  }
+  const finishReason = event.choices?.[0]?.finish_reason;
+  if (finishReason === "tool_calls" && !state.endEmitted) {
+    state.endEmitted = true;
+    emit({
+      type: "message_end",
+      usage: state.usage,
+      stopReason: "tool_use"
+    });
+  }
+}
+function processOpenAISSELine(line, emit, state) {
+  if (!line.startsWith("data: "))
+    return;
+  const data = line.slice(6).trim();
+  if (data === "[DONE]") {
+    if (!state.endEmitted) {
+      state.endEmitted = true;
+      emit({
+        type: "message_end",
+        usage: state.usage,
+        stopReason: "end_turn"
+      });
+    }
+    return;
+  }
+  try {
+    const event = JSON.parse(data);
+    processOpenAISSEChunk(event, emit, state);
+  } catch (err2) {
+    emit({ type: "error", error: err2 instanceof Error ? err2 : new Error(String(err2)) });
+  }
+}
+async function processOpenAISSEStream(body, emit) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  const state = {
+    endEmitted: false,
+    usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 }
+  };
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split(`
+`);
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      processOpenAISSELine(line, emit, state);
+    }
+  }
+}
+
+// src/gateway.ts
+var PROVIDER_FACTORIES = {
+  anthropic: createAnthropicProvider,
+  openai: createOpenAIProvider,
+  google: createGoogleProvider
+};
+function registerProviderFactory(name, factory) {
+  PROVIDER_FACTORIES[name] = factory;
+}
+function gateway(config) {
+  const factory = PROVIDER_FACTORIES[config.provider];
+  if (!factory) {
+    throw new ElsiumError({
+      code: "CONFIG_ERROR",
+      message: `Unknown provider: ${config.provider}. Available: ${Object.keys(PROVIDER_FACTORIES).join(", ")}`,
+      retryable: false
+    });
+  }
+  const provider = factory({
+    apiKey: config.apiKey,
+    baseUrl: config.baseUrl,
+    timeout: config.timeout,
+    maxRetries: config.maxRetries
+  });
+  if (provider.metadata) {
+    registerProviderMetadata(provider.name, provider.metadata);
+    if (provider.metadata.pricing) {
+      for (const [model, pricing] of Object.entries(provider.metadata.pricing)) {
+        registerPricing(model, pricing);
+      }
+    }
+  }
+  const defaultModel = config.model ?? provider.defaultModel;
+  let xrayStore = null;
+  const allMiddleware = [...config.middleware ?? []];
+  if (config.xray) {
+    const xrayOpts = typeof config.xray === "object" ? config.xray : {};
+    const xm = xrayMiddleware(xrayOpts);
+    xrayStore = xm;
+    allMiddleware.push(xm);
+  }
+  const composedMiddleware = allMiddleware.length ? composeMiddleware(allMiddleware) : null;
+  async function executeWithMiddleware(request) {
+    const req = { ...request, model: request.model ?? defaultModel };
+    if (!composedMiddleware) {
+      return provider.complete(req);
+    }
+    const ctx = {
+      request: req,
+      provider: provider.name,
+      model: req.model ?? defaultModel,
+      traceId: generateTraceId(),
+      startTime: performance.now(),
+      metadata: request.metadata ?? {}
+    };
+    return composedMiddleware(ctx, async (c) => provider.complete(c.request));
+  }
+  return {
+    provider,
+    lastCall() {
+      return xrayStore?.lastCall() ?? null;
+    },
+    callHistory(limit) {
+      return xrayStore?.callHistory(limit) ?? [];
+    },
+    async complete(request) {
+      return executeWithMiddleware(request);
+    },
+    stream(request) {
+      const req = { ...request, model: request.model ?? defaultModel };
+      if (composedMiddleware) {
+        const ctx = {
+          request: req,
+          provider: provider.name,
+          model: req.model ?? defaultModel,
+          traceId: generateTraceId(),
+          startTime: performance.now(),
+          metadata: request.metadata ?? {}
+        };
+        return createStream(async (emit) => {
+          await composedMiddleware(ctx, async (c) => {
+            const stream = provider.stream(c.request);
+            for await (const event of stream) {
+              emit(event);
+            }
+            return {
+              id: "",
+              message: { role: "assistant", content: "" },
+              usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+              cost: { inputCost: 0, outputCost: 0, totalCost: 0, currency: "USD" },
+              model: c.model,
+              provider: provider.name,
+              stopReason: "end_turn",
+              latencyMs: 0,
+              traceId: ctx.traceId
+            };
+          });
+        });
+      }
+      return provider.stream(req);
+    },
+    async generate(request) {
+      const { schema, ...rest } = request;
+      const jsonSchema = schemaToJsonSchema(schema);
+      const systemPrompt = [
+        rest.system ?? "",
+        "You MUST respond with valid JSON matching this schema:",
+        JSON.stringify(jsonSchema, null, 2),
+        "Respond ONLY with the JSON object, no markdown or explanation."
+      ].filter(Boolean).join(`
+
+`);
+      const response = await executeWithMiddleware({
+        ...rest,
+        system: systemPrompt
+      });
+      const text = typeof response.message.content === "string" ? response.message.content : "";
+      const jsonMatch = text.match(/\{[\s\S]*\}/);
+      if (!jsonMatch) {
+        throw ElsiumError.validation("LLM response did not contain valid JSON", {
+          response: text
+        });
+      }
+      const parsed = JSON.parse(jsonMatch[0]);
+      const result = schema.safeParse(parsed);
+      if (!result.success) {
+        throw ElsiumError.validation("LLM response did not match schema", {
+          errors: result.error.issues,
+          response: text
+        });
+      }
+      return { data: result.data, response };
+    }
+  };
+}
+function schemaToJsonSchema(schema) {
+  try {
+    if ("_def" in schema) {
+      const def = schema._def;
+      const result = convertZodDef(def);
+      if (result)
+        return result;
+    }
+  } catch {}
+  return { type: "string" };
+}
+function zodDefKind(def) {
+  return typeof def.type === "string" ? def.type : def.typeName;
+}
+function convertZodDef(def) {
+  const kind = zodDefKind(def);
+  switch (kind) {
+    case "object":
+    case "ZodObject":
+      return convertZodObject(def);
+    case "string":
+    case "ZodString":
+      return { type: "string" };
+    case "number":
+    case "ZodNumber":
+      return { type: "number" };
+    case "boolean":
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "array":
+    case "ZodArray":
+      return convertZodArray(def);
+    case "enum":
+    case "ZodEnum": {
+      const values = def.values ?? (def.entries ? Object.values(def.entries) : []);
+      return { type: "string", enum: values };
+    }
+    case "optional":
+    case "ZodOptional":
+      return convertZodOptional(def);
+    default:
+      return null;
+  }
+}
+function convertZodObject(def) {
+  if (!def.shape)
+    return null;
+  const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+  const properties = {};
+  const required = [];
+  for (const [key, value] of Object.entries(shape)) {
+    properties[key] = schemaToJsonSchema(value);
+    const valDef = value._def;
+    const valKind = zodDefKind(valDef);
+    if (valKind !== "optional" && valKind !== "ZodOptional") {
+      required.push(key);
+    }
+  }
+  return { type: "object", properties, required };
+}
+function convertZodArray(def) {
+  return {
+    type: "array",
+    items: schemaToJsonSchema(def.element ?? def.type)
+  };
+}
+function convertZodOptional(def) {
+  return schemaToJsonSchema(def.innerType ?? def.innerType);
+}
+// src/security.ts
+var INJECTION_PATTERNS = [
+  {
+    pattern: /ignore\s+(?:all\s+)?previous\s+instructions/i,
+    detail: "Attempt to override previous instructions"
+  },
+  { pattern: /ignore\s+all\s+prior/i, detail: "Attempt to ignore prior context" },
+  { pattern: /disregard\s+(?:the\s+)?above/i, detail: "Attempt to disregard above context" },
+  { pattern: /^system\s*:/im, detail: "Attempt to inject system-level instruction" },
+  { pattern: /<\|system\|>/i, detail: "Attempt to inject system token" },
+  { pattern: /\[INST\]/i, detail: "Attempt to inject instruction token" },
+  { pattern: /<<SYS>>/i, detail: "Attempt to inject system block" },
+  { pattern: /<system>/i, detail: "Attempt to inject system tag" },
+  {
+    pattern: /you\s+are\s+now\b.*(?:override|ignore|forget|disregard|new\s+instructions)/i,
+    detail: "Attempt to override agent identity"
+  }
+];
+var JAILBREAK_PATTERNS = [
+  {
+    pattern: /\bDAN\b.*(?:mode|prompt|jailbreak|do\s+anything|no\s+(?:restrictions|rules|limits))/i,
+    detail: "DAN jailbreak attempt"
+  },
+  { pattern: /\bdo\s+anything\s+now\b/i, detail: "DAN (Do Anything Now) jailbreak attempt" },
+  { pattern: /you\s+are\s+(?:now\s+)?DAN\b/i, detail: "DAN role assignment jailbreak attempt" },
+  {
+    pattern: /(?:pretend|act\s+as\s+if)\s+(?:you\s+)?(?:have\s+no|don'?t\s+have\s+any?)\s+(?:restrictions|limitations|rules|guidelines)/i,
+    detail: "Attempt to remove restrictions"
+  },
+  {
+    pattern: /(?:bypass|circumvent|ignore|disable)\s+(?:your\s+)?(?:safety|content|ethical)\s+(?:filters?|guidelines?|restrictions?|rules?)/i,
+    detail: "Attempt to bypass safety filters"
+  },
+  {
+    pattern: /developer\s+mode\s+(?:enabled|activated|on)/i,
+    detail: "Developer mode jailbreak attempt"
+  },
+  {
+    pattern: /(?:unlock|enable)\s+(?:all|unrestricted|unfiltered)\s+(?:mode|access|capabilities)/i,
+    detail: "Attempt to unlock unrestricted mode"
+  },
+  {
+    pattern: /opposite\s+(?:mode|day)|do\s+(?:the\s+)?opposite/i,
+    detail: "Opposite mode jailbreak attempt"
+  }
+];
+var SECRET_PATTERNS = [
+  {
+    pattern: /\bsk-[a-zA-Z0-9_-]{20,}\b/g,
+    detail: "API secret key detected",
+    replacement: "[REDACTED_API_KEY]"
+  },
+  {
+    pattern: /\bpk-[a-zA-Z0-9_-]{20,}\b/g,
+    detail: "API public key detected",
+    replacement: "[REDACTED_API_KEY]"
+  },
+  {
+    pattern: /\bapi_key[=:]\s*["']?[a-zA-Z0-9_-]{16,}["']?/gi,
+    detail: "API key assignment detected",
+    replacement: "[REDACTED_API_KEY]"
+  },
+  {
+    pattern: /\bAKIA[A-Z0-9]{16}\b/g,
+    detail: "AWS access key detected",
+    replacement: "[REDACTED_AWS_KEY]"
+  },
+  {
+    pattern: /\bpassword\s*[=:]\s*["']?[^\s"']{4,}["']?/gi,
+    detail: "Password assignment detected",
+    replacement: "[REDACTED_PASSWORD]"
+  },
+  {
+    pattern: /\b\d{3}-\d{2}-\d{4}\b/g,
+    detail: "SSN pattern detected",
+    replacement: "[REDACTED_SSN]"
+  },
+  {
+    pattern: /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g,
+    detail: "Credit card number detected",
+    replacement: "[REDACTED_CC]"
+  },
+  {
+    pattern: /\bBearer\s+[a-zA-Z0-9_.-]{20,}\b/g,
+    detail: "Bearer token detected",
+    replacement: "[REDACTED_TOKEN]"
+  }
+];
+var PII_PATTERNS = {
+  email: [
+    {
+      pattern: /\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b/g,
+      detail: "Email address detected",
+      replacement: "[REDACTED_EMAIL]"
+    }
+  ],
+  phone: [
+    {
+      pattern: /\b(?:\+?1[-.\s]?)?(?:\([2-9]\d{2}\)|[2-9]\d{2})[-.\s]?\d{3}[-.\s]?\d{4}\b/g,
+      detail: "US phone number detected",
+      replacement: "[REDACTED_PHONE]"
+    }
+  ],
+  address: [
+    {
+      pattern: /\b\d{1,5}\s+[A-Z][a-zA-Z]*(?:\s+[A-Z][a-zA-Z]*){0,5}\s+(?:St|Street|Ave|Avenue|Blvd|Boulevard|Dr|Drive|Ln|Lane|Rd|Road|Ct|Court|Way|Pl|Place)\.?\b/g,
+      detail: "Street address detected",
+      replacement: "[REDACTED_ADDRESS]"
+    }
+  ],
+  passport: [
+    {
+      pattern: /\b[A-Z]\d{8}\b/g,
+      detail: "Passport number detected",
+      replacement: "[REDACTED_PASSPORT]"
+    }
+  ]
+};
+function classifyContent(text) {
+  const detectedTypes = [];
+  for (const { pattern, detail } of SECRET_PATTERNS) {
+    if (new RegExp(pattern.source, pattern.flags).test(text)) {
+      detectedTypes.push(detail);
+    }
+  }
+  if (detectedTypes.length > 0) {
+    return { level: "restricted", detectedTypes };
+  }
+  for (const [, patterns] of Object.entries(PII_PATTERNS)) {
+    for (const { pattern, detail } of patterns) {
+      if (new RegExp(pattern.source, pattern.flags).test(text)) {
+        detectedTypes.push(detail);
+      }
+    }
+  }
+  if (detectedTypes.length > 0) {
+    return { level: "confidential", detectedTypes };
+  }
+  return { level: "public", detectedTypes: [] };
+}
+function normalizeText(text) {
+  return text.normalize("NFKC");
+}
+function detectPromptInjection(text) {
+  const violations = [];
+  const normalized = normalizeText(text);
+  for (const { pattern, detail } of INJECTION_PATTERNS) {
+    if (pattern.test(normalized)) {
+      violations.push({ type: "prompt_injection", detail, severity: "high" });
+    }
+  }
+  return violations;
+}
+function detectJailbreak(text) {
+  const violations = [];
+  const normalized = normalizeText(text);
+  for (const { pattern, detail } of JAILBREAK_PATTERNS) {
+    if (pattern.test(normalized)) {
+      violations.push({ type: "jailbreak", detail, severity: "high" });
+    }
+  }
+  return violations;
+}
+function redactPatterns(text, patterns) {
+  const found = [];
+  let redacted = text;
+  for (const { pattern, detail, replacement } of patterns) {
+    const regex = new RegExp(pattern.source, pattern.flags);
+    const result = redacted.replace(regex, replacement);
+    if (result !== redacted) {
+      found.push({ type: "secret_detected", detail, severity: "medium" });
+      redacted = result;
+    }
+  }
+  return { redacted, found };
+}
+function resolvePiiPatterns(piiTypes) {
+  const typesToCheck = piiTypes.includes("all") ? Object.keys(PII_PATTERNS) : piiTypes.filter((t) => t !== "all");
+  const patterns = [];
+  for (const type of typesToCheck) {
+    const typePatterns = PII_PATTERNS[type];
+    if (typePatterns)
+      patterns.push(...typePatterns);
+  }
+  return patterns;
+}
+function redactSecrets(text, piiTypes) {
+  const secretResult = redactPatterns(text, SECRET_PATTERNS);
+  let { redacted } = secretResult;
+  const found = [...secretResult.found];
+  if (piiTypes?.length) {
+    const piiResult = redactPatterns(redacted, resolvePiiPatterns(piiTypes));
+    redacted = piiResult.redacted;
+    found.push(...piiResult.found);
+  }
+  return { redacted, found };
+}
+function checkBlockedPatterns(text, patterns) {
+  const violations = [];
+  for (const pattern of patterns) {
+    pattern.lastIndex = 0;
+    if (pattern.test(text)) {
+      violations.push({
+        type: "blocked_pattern",
+        detail: `Blocked pattern matched: ${pattern.source}`,
+        severity: "medium"
+      });
+    }
+  }
+  return violations;
+}
+function scanMessageForViolations(text, config) {
+  const violations = [];
+  if (config.promptInjection !== false) {
+    violations.push(...detectPromptInjection(text));
+  }
+  if (config.jailbreakDetection) {
+    violations.push(...detectJailbreak(text));
+  }
+  if (config.blockedPatterns?.length) {
+    violations.push(...checkBlockedPatterns(text, config.blockedPatterns));
+  }
+  return violations;
+}
+function reportAndThrow(violations, config) {
+  for (const v of violations) {
+    config.onViolation?.(v);
+  }
+  throw ElsiumError.validation(`Security violation detected: ${violations.map((v) => v.detail).join("; ")}`);
+}
+function redactResponseSecrets(response, config) {
+  const responseText = extractText(response.message.content);
+  if (!responseText)
+    return response;
+  const { redacted, found } = redactSecrets(responseText, config.piiTypes);
+  if (found.length === 0)
+    return response;
+  for (const v of found) {
+    config.onViolation?.(v);
+  }
+  return {
+    ...response,
+    message: {
+      ...response.message,
+      content: redacted
+    }
+  };
+}
+function securityMiddleware(config) {
+  return async (ctx, next) => {
+    for (const message of ctx.request.messages) {
+      const text = extractText(message.content);
+      if (!text)
+        continue;
+      const violations = scanMessageForViolations(text, config);
+      if (violations.length > 0) {
+        reportAndThrow(violations, config);
+      }
+    }
+    const response = await next(ctx);
+    if (config.secretRedaction !== false) {
+      return redactResponseSecrets(response, config);
+    }
+    return response;
+  };
+}
+// src/bulkhead.ts
+function createBulkhead(config) {
+  const maxConcurrent = config?.maxConcurrent ?? 10;
+  const maxQueued = config?.maxQueued ?? 50;
+  const queueTimeoutMs = config?.queueTimeoutMs ?? 30000;
+  if (maxConcurrent < 1 || !Number.isFinite(maxConcurrent)) {
+    throw new ElsiumError({
+      code: "CONFIG_ERROR",
+      message: "maxConcurrent must be >= 1",
+      retryable: false
+    });
+  }
+  if (maxQueued < 0 || !Number.isFinite(maxQueued)) {
+    throw new ElsiumError({
+      code: "CONFIG_ERROR",
+      message: "maxQueued must be >= 0 and finite",
+      retryable: false
+    });
+  }
+  if (queueTimeoutMs < 0 || !Number.isFinite(queueTimeoutMs)) {
+    throw new ElsiumError({
+      code: "CONFIG_ERROR",
+      message: "queueTimeoutMs must be >= 0 and finite",
+      retryable: false
+    });
+  }
+  let activeCount = 0;
+  const queue = [];
+  function tryDequeue() {
+    const toResolve = [];
+    while (activeCount < maxConcurrent && queue.length > 0) {
+      const next = queue.shift();
+      if (next) {
+        activeCount++;
+        toResolve.push(next);
+      }
+    }
+    for (const entry of toResolve) {
+      entry.resolve();
+    }
+  }
+  return {
+    get active() {
+      return activeCount;
+    },
+    get queued() {
+      return queue.length;
+    },
+    async execute(fn) {
+      if (activeCount < maxConcurrent) {
+        activeCount++;
+      } else if (queue.length >= maxQueued) {
+        throw ElsiumError.rateLimit("bulkhead");
+      } else {
+        await new Promise((resolve, reject) => {
+          const entry = { resolve, reject };
+          queue.push(entry);
+          const timer = setTimeout(() => {
+            const idx = queue.indexOf(entry);
+            if (idx !== -1) {
+              queue.splice(idx, 1);
+              reject(new ElsiumError({
+                code: "TIMEOUT",
+                message: `Bulkhead queue timeout after ${queueTimeoutMs}ms`,
+                retryable: true
+              }));
+            }
+          }, queueTimeoutMs);
+          const origResolve = entry.resolve;
+          entry.resolve = () => {
+            clearTimeout(timer);
+            origResolve();
+          };
+        });
+      }
+      try {
+        return await fn();
+      } finally {
+        activeCount--;
+        tryDequeue();
+      }
+    }
+  };
+}
+function bulkheadMiddleware(config) {
+  const bulkhead = createBulkhead(config);
+  return async (ctx, next) => {
+    return bulkhead.execute(() => next(ctx));
+  };
+}
+// src/router.ts
+var REASONING_KEYWORDS = /\b(prove|explain why|analyze|compare|contrast|evaluate|critique|debate|reason|deduce|infer|justify|argue|synthesize|hypothesize|derive)\b/i;
+var CODE_KEYWORDS = /\b(implement|refactor|debug|optimize|architect|design pattern|algorithm|data structure|write code|code review|fix the bug|type system)\b/i;
+var CREATIVE_KEYWORDS = /\b(write a (story|essay|poem|article|report|paper)|compose|draft|create a (plan|proposal|strategy))\b/i;
+var MATH_KEYWORDS = /\b(calculate|compute|solve|equation|integral|derivative|matrix|probability|statistical|proof|theorem|formula)\b/i;
+function extractTextContent(request) {
+  const parts = [];
+  for (const m of request.messages) {
+    if (typeof m.content === "string") {
+      parts.push(m.content);
+    } else if (Array.isArray(m.content)) {
+      for (const p of m.content) {
+        if (p.type === "text")
+          parts.push(p.text);
+      }
+    }
+  }
+  if (request.system)
+    parts.push(request.system);
+  return parts.join(" ");
+}
+function estimateComplexity(request) {
+  let score = 0;
+  const totalChars = request.messages.reduce((sum, m) => {
+    const len = typeof m.content === "string" ? m.content.length : JSON.stringify(m.content).length;
+    return sum + len;
+  }, 0);
+  if (totalChars > 2000)
+    score += 0.3;
+  if (totalChars > 5000)
+    score += 0.2;
+  if (request.tools?.length)
+    score += 0.2;
+  if ((request.tools?.length ?? 0) > 3)
+    score += 0.1;
+  if (request.system && request.system.length > 500)
+    score += 0.1;
+  if (request.messages.length > 10)
+    score += 0.1;
+  const text = extractTextContent(request);
+  if (REASONING_KEYWORDS.test(text))
+    score += 0.5;
+  if (CODE_KEYWORDS.test(text))
+    score += 0.5;
+  if (CREATIVE_KEYWORDS.test(text))
+    score += 0.2;
+  if (MATH_KEYWORDS.test(text))
+    score += 0.5;
+  return Math.min(score, 1);
+}
+function createProviderMesh(config) {
+  if (config.providers.length === 0) {
+    throw new ElsiumError({
+      code: "CONFIG_ERROR",
+      message: "Provider mesh requires at least one provider",
+      retryable: false
+    });
+  }
+  const sortedProviders = [...config.providers].sort((a, b) => (a.priority ?? 99) - (b.priority ?? 99));
+  const gateways = new Map;
+  const circuitBreakers = new Map;
+  for (const entry of sortedProviders) {
+    const gw = gateway({
+      provider: entry.name,
+      apiKey: entry.config.apiKey,
+      baseUrl: entry.config.baseUrl,
+      model: entry.model
+    });
+    gateways.set(entry.name, gw);
+    if (config.circuitBreaker) {
+      const cbConfig = typeof config.circuitBreaker === "boolean" ? {} : config.circuitBreaker;
+      circuitBreakers.set(entry.name, createCircuitBreaker(cbConfig));
+    }
+  }
+  function callWithCircuitBreaker(providerName, fn) {
+    const cb = circuitBreakers.get(providerName);
+    return cb ? cb.execute(fn) : fn();
+  }
+  function isProviderAvailable(providerName) {
+    const cb = circuitBreakers.get(providerName);
+    return !cb || cb.state !== "open";
+  }
+  function getGateway(providerName) {
+    const gw = gateways.get(providerName);
+    if (!gw) {
+      throw new ElsiumError({
+        code: "CONFIG_ERROR",
+        message: `Provider "${providerName}" not found in mesh`,
+        retryable: false
+      });
+    }
+    return gw;
+  }
+  async function fallbackComplete(request) {
+    let lastError = null;
+    for (const entry of sortedProviders) {
+      if (!isProviderAvailable(entry.name))
+        continue;
+      try {
+        const gw = getGateway(entry.name);
+        return await callWithCircuitBreaker(entry.name, () => gw.complete({ ...request, model: request.model ?? entry.model }));
+      } catch (err2) {
+        lastError = err2 instanceof Error ? err2 : new Error(String(err2));
+      }
+    }
+    throw lastError ?? new ElsiumError({
+      code: "PROVIDER_ERROR",
+      message: "All providers failed",
+      retryable: false
+    });
+  }
+  async function costOptimizedComplete(request) {
+    const optimizer = config.costOptimizer;
+    if (!optimizer) {
+      return fallbackComplete(request);
+    }
+    const complexity = estimateComplexity(request);
+    const threshold = optimizer.complexityThreshold ?? 0.5;
+    const target = complexity < threshold ? optimizer.simpleModel : optimizer.complexModel;
+    const gw = getGateway(target.provider);
+    try {
+      return await gw.complete({ ...request, model: target.model });
+    } catch {
+      return fallbackComplete(request);
+    }
+  }
+  async function latencyOptimizedComplete(request) {
+    const controller = new AbortController;
+    const availableProviders = sortedProviders.filter((e) => isProviderAvailable(e.name));
+    const promises = availableProviders.map(async (entry) => {
+      const gw = getGateway(entry.name);
+      return callWithCircuitBreaker(entry.name, () => gw.complete({
+        ...request,
+        model: request.model ?? entry.model,
+        signal: controller.signal
+      }));
+    });
+    try {
+      const result = await Promise.any(promises);
+      controller.abort();
+      return result;
+    } catch {
+      throw new ElsiumError({
+        code: "PROVIDER_ERROR",
+        message: "All providers failed",
+        retryable: false
+      });
+    }
+  }
+  function detectRequiredCapabilities(request) {
+    const capabilities = [];
+    if ((request.tools?.length ?? 0) > 0)
+      capabilities.push("tools");
+    const needsVision = request.messages.some((m) => Array.isArray(m.content) && m.content.some((p) => p.type === "image"));
+    if (needsVision)
+      capabilities.push("vision");
+    return capabilities;
+  }
+  function filterCapableProviders(capabilities) {
+    return sortedProviders.filter((entry) => {
+      if (capabilities.length === 0)
+        return true;
+      const providerCaps = entry.capabilities ?? defaultCapabilities(entry.name);
+      return capabilities.every((c) => providerCaps.includes(c));
+    });
+  }
+  async function tryProviders(providers, request) {
+    let lastError = null;
+    for (const entry of providers) {
+      if (!isProviderAvailable(entry.name))
+        continue;
+      try {
+        const gw = getGateway(entry.name);
+        return await callWithCircuitBreaker(entry.name, () => gw.complete({ ...request, model: request.model ?? entry.model }));
+      } catch (err2) {
+        lastError = err2 instanceof Error ? err2 : new Error(String(err2));
+      }
+    }
+    throw lastError ?? new ElsiumError({
+      code: "PROVIDER_ERROR",
+      message: "No capable provider succeeded",
+      retryable: false
+    });
+  }
+  async function capabilityAwareComplete(request) {
+    const capabilities = detectRequiredCapabilities(request);
+    const capable = filterCapableProviders(capabilities);
+    if (capable.length === 0) {
+      return fallbackComplete(request);
+    }
+    return tryProviders(capable, request);
+  }
+  function defaultCapabilities(provider) {
+    const meta = getProviderMetadata(provider);
+    if (meta?.capabilities)
+      return meta.capabilities;
+    switch (provider) {
+      case "anthropic":
+        return ["tools", "vision", "streaming", "system"];
+      case "openai":
+        return ["tools", "vision", "streaming", "system", "json_mode"];
+      case "google":
+        return ["tools", "vision", "streaming", "system"];
+      default:
+        return ["streaming"];
+    }
+  }
+  return {
+    providers: sortedProviders.map((p) => p.name),
+    strategy: config.strategy,
+    async complete(request) {
+      switch (config.strategy) {
+        case "fallback":
+          return fallbackComplete(request);
+        case "cost-optimized":
+          return costOptimizedComplete(request);
+        case "latency-optimized":
+          return latencyOptimizedComplete(request);
+        case "capability-aware":
+          return capabilityAwareComplete(request);
+        default:
+          return fallbackComplete(request);
+      }
+    },
+    stream(request) {
+      const available = sortedProviders.find((e) => isProviderAvailable(e.name));
+      const entry = available ?? sortedProviders[0];
+      const gw = getGateway(entry.name);
+      return gw.stream({ ...request, model: request.model ?? entry.model });
+    }
+  };
+}
+export {
+  xrayMiddleware,
+  securityMiddleware,
+  registerProviderMetadata,
+  registerProviderFactory,
+  registerProvider,
+  registerPricing,
+  redactSecrets,
+  loggingMiddleware,
+  listProviders,
+  getProviderMetadata,
+  getProviderFactory,
+  gateway,
+  detectPromptInjection,
+  detectJailbreak,
+  createProviderMesh,
+  createOpenAIProvider,
+  createGoogleProvider,
+  createBulkhead,
+  createAnthropicProvider,
+  costTrackingMiddleware,
+  composeMiddleware,
+  classifyContent,
+  checkBlockedPatterns,
+  calculateCost,
+  bulkheadMiddleware
+};