@elsium-ai/core 0.1.6

package/dist/index.js

@@ -0,0 +1,987 @@
+// @bun
+// 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 }
+    });
+  }
+}
+// src/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok;
+}
+function isErr(result) {
+  return !result.ok;
+}
+function unwrap(result) {
+  if (result.ok)
+    return result.value;
+  throw result.error instanceof Error ? result.error : new Error(String(result.error));
+}
+function unwrapOr(result, fallback) {
+  return result.ok ? result.value : fallback;
+}
+async function tryCatch(fn) {
+  try {
+    return ok(await fn());
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+function tryCatchSync(fn) {
+  try {
+    return ok(fn());
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+}
+// 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;
+  })();
+}
+
+// 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(err2) {
+  return err2 instanceof Error ? err2 : new Error(String(err2));
+}
+function* emitErrorEvent(err2, textAccumulator, onPartialRecovery) {
+  const error = toError(err2);
+  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 (err2) {
+      if (parts.length === 0)
+        throw err2;
+    } 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 (err2) {
+          yield* emitErrorEvent(err2, 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);
+}
+// 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 }
+      });
+    }
+  };
+}
+// src/config.ts
+function getEnvVar(name) {
+  const value = process.env[name];
+  if (value === undefined || value === "undefined")
+    return;
+  return value;
+}
+function env(name, fallback) {
+  const value = getEnvVar(name);
+  if (value !== undefined)
+    return value;
+  if (fallback !== undefined)
+    return fallback;
+  throw new ElsiumError({
+    code: "CONFIG_ERROR",
+    message: `Missing required environment variable: ${name}`,
+    retryable: false,
+    metadata: { variable: name }
+  });
+}
+function envNumber(name, fallback) {
+  const raw = getEnvVar(name);
+  if (raw !== undefined) {
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed)) {
+      throw new ElsiumError({
+        code: "CONFIG_ERROR",
+        message: `Environment variable ${name} is not a valid finite number: ${raw}`,
+        retryable: false,
+        metadata: { variable: name, value: raw }
+      });
+    }
+    return parsed;
+  }
+  if (fallback !== undefined)
+    return fallback;
+  throw new ElsiumError({
+    code: "CONFIG_ERROR",
+    message: `Missing required environment variable: ${name}`,
+    retryable: false,
+    metadata: { variable: name }
+  });
+}
+function envBool(name, fallback) {
+  const raw = getEnvVar(name);
+  if (raw !== undefined) {
+    const normalized = raw.toLowerCase();
+    return normalized === "true" || normalized === "1" || normalized === "yes";
+  }
+  if (fallback !== undefined)
+    return fallback;
+  throw new ElsiumError({
+    code: "CONFIG_ERROR",
+    message: `Missing required environment variable: ${name}`,
+    retryable: false,
+    metadata: { variable: name }
+  });
+}
+// 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/dedup.ts
+import { createHash } from "crypto";
+function createDedup(config) {
+  const ttlMs = config?.ttlMs ?? 5000;
+  const maxEntries = config?.maxEntries ?? 1000;
+  if (ttlMs < 0 || !Number.isFinite(ttlMs)) {
+    throw new ElsiumError({
+      code: "CONFIG_ERROR",
+      message: "ttlMs must be >= 0 and finite",
+      retryable: false
+    });
+  }
+  if (maxEntries < 1 || !Number.isFinite(maxEntries)) {
+    throw new ElsiumError({
+      code: "CONFIG_ERROR",
+      message: "maxEntries must be >= 1",
+      retryable: false
+    });
+  }
+  const inFlight = new Map;
+  const cache = new Map;
+  function evictExpired() {
+    const now = Date.now();
+    for (const [key, entry] of cache) {
+      if (now >= entry.expiresAt) {
+        cache.delete(key);
+      }
+    }
+  }
+  function enforceSizeLimit() {
+    if (cache.size <= maxEntries)
+      return;
+    const oldest = cache.keys().next().value;
+    if (oldest !== undefined)
+      cache.delete(oldest);
+  }
+  return {
+    async deduplicate(key, fn) {
+      const cached = cache.get(key);
+      if (cached && Date.now() < cached.expiresAt) {
+        return cached.value;
+      }
+      const existing = inFlight.get(key);
+      if (existing) {
+        return existing;
+      }
+      const promise = fn().then((result) => {
+        inFlight.delete(key);
+        cache.set(key, { value: result, expiresAt: Date.now() + ttlMs });
+        enforceSizeLimit();
+        return result;
+      }, (error) => {
+        inFlight.delete(key);
+        throw error;
+      });
+      inFlight.set(key, promise);
+      return promise;
+    },
+    hashRequest(request) {
+      const sorted = JSON.stringify(request, (_key, value) => value && typeof value === "object" && !Array.isArray(value) ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b))) : value);
+      return createHash("sha256").update(sorted).digest("hex").slice(0, 16);
+    },
+    get size() {
+      evictExpired();
+      return cache.size + inFlight.size;
+    },
+    clear() {
+      inFlight.clear();
+      cache.clear();
+    }
+  };
+}
+function dedupMiddleware(config) {
+  const dedup = createDedup(config);
+  return async (ctx, next) => {
+    const key = dedup.hashRequest({
+      messages: ctx.request.messages,
+      model: ctx.model,
+      provider: ctx.provider,
+      system: ctx.request.system,
+      temperature: ctx.request.temperature,
+      seed: ctx.request.seed,
+      maxTokens: ctx.request.maxTokens,
+      topP: ctx.request.topP,
+      stopSequences: ctx.request.stopSequences,
+      tools: ctx.request.tools
+    });
+    return dedup.deduplicate(key, () => next(ctx));
+  };
+}
+// src/policy.ts
+function createPolicySet(policies) {
+  const policyList = [...policies];
+  return {
+    evaluate(ctx) {
+      const denials = [];
+      for (const policy of policyList) {
+        const mode = policy.mode ?? "all-must-pass";
+        const results = policy.rules.map((rule) => rule(ctx));
+        if (mode === "all-must-pass") {
+          const denied = results.filter((r) => r.decision === "deny");
+          denials.push(...denied);
+        } else {
+          const anyAllowed = results.some((r) => r.decision === "allow");
+          if (!anyAllowed && results.length > 0) {
+            denials.push(results[0]);
+          }
+        }
+      }
+      return denials;
+    },
+    addPolicy(policy) {
+      policyList.push(policy);
+    },
+    removePolicy(name) {
+      const idx = policyList.findIndex((p) => p.name === name);
+      if (idx !== -1)
+        policyList.splice(idx, 1);
+    },
+    get policies() {
+      return policyList.map((p) => p.name);
+    }
+  };
+}
+function policyMiddleware(policySet) {
+  return async (ctx, next) => {
+    const requestContent = ctx.request.messages.map((m) => extractText(m.content)).join(`
+`);
+    const tokenCount = Math.ceil(requestContent.length / 4);
+    const policyCtx = {
+      model: ctx.model,
+      provider: ctx.provider,
+      metadata: ctx.metadata,
+      requestContent,
+      tokenCount
+    };
+    const denials = policySet.evaluate(policyCtx);
+    if (denials.length > 0) {
+      throw ElsiumError.validation(`Policy denied: ${denials.map((d) => `[${d.policyName}] ${d.reason}`).join("; ")}`);
+    }
+    return next(ctx);
+  };
+}
+function modelAccessPolicy(allowedModels) {
+  return {
+    name: "model-access",
+    description: "Restricts access to specific models",
+    rules: [
+      (ctx) => {
+        if (!ctx.model)
+          return { decision: "allow", reason: "No model specified", policyName: "model-access" };
+        const model = ctx.model;
+        const allowed = allowedModels.some((m) => {
+          if (m.endsWith("*"))
+            return model.startsWith(m.slice(0, -1));
+          return model === m;
+        });
+        return {
+          decision: allowed ? "allow" : "deny",
+          reason: allowed ? "Model is allowed" : `Model "${ctx.model}" is not in allowed list`,
+          policyName: "model-access"
+        };
+      }
+    ]
+  };
+}
+function tokenLimitPolicy(maxTokens) {
+  if (!Number.isFinite(maxTokens) || maxTokens < 0) {
+    throw ElsiumError.validation("tokenLimitPolicy: maxTokens must be >= 0 and finite");
+  }
+  return {
+    name: "token-limit",
+    description: `Limits requests to ${maxTokens} tokens`,
+    rules: [
+      (ctx) => {
+        if (ctx.tokenCount === undefined) {
+          return {
+            decision: "allow",
+            reason: "No token count available",
+            policyName: "token-limit"
+          };
+        }
+        const allowed = ctx.tokenCount <= maxTokens;
+        return {
+          decision: allowed ? "allow" : "deny",
+          reason: allowed ? "Within token limit" : `Token count ${ctx.tokenCount} exceeds limit ${maxTokens}`,
+          policyName: "token-limit"
+        };
+      }
+    ]
+  };
+}
+function costLimitPolicy(maxCost) {
+  if (!Number.isFinite(maxCost) || maxCost < 0) {
+    throw ElsiumError.validation("costLimitPolicy: maxCost must be >= 0 and finite");
+  }
+  return {
+    name: "cost-limit",
+    description: `Limits requests to $${maxCost}`,
+    rules: [
+      (ctx) => {
+        if (ctx.costEstimate === undefined) {
+          return {
+            decision: "allow",
+            reason: "No cost estimate available",
+            policyName: "cost-limit"
+          };
+        }
+        const allowed = ctx.costEstimate <= maxCost;
+        return {
+          decision: allowed ? "allow" : "deny",
+          reason: allowed ? "Within cost limit" : `Cost $${ctx.costEstimate} exceeds limit $${maxCost}`,
+          policyName: "cost-limit"
+        };
+      }
+    ]
+  };
+}
+function contentPolicy(blockedPatterns) {
+  return {
+    name: "content-policy",
+    description: "Blocks requests matching content patterns",
+    rules: [
+      (ctx) => {
+        if (!ctx.requestContent) {
+          return { decision: "allow", reason: "No content to check", policyName: "content-policy" };
+        }
+        for (const pattern of blockedPatterns) {
+          pattern.lastIndex = 0;
+          if (pattern.test(ctx.requestContent)) {
+            return {
+              decision: "deny",
+              reason: `Content matches blocked pattern: ${pattern.source}`,
+              policyName: "content-policy"
+            };
+          }
+        }
+        return { decision: "allow", reason: "Content is clean", policyName: "content-policy" };
+      }
+    ]
+  };
+}
+// src/shutdown.ts
+function createShutdownManager(config) {
+  const drainTimeoutMs = config?.drainTimeoutMs ?? 30000;
+  const signals = config?.signals ?? ["SIGTERM", "SIGINT"];
+  if (drainTimeoutMs < 0 || !Number.isFinite(drainTimeoutMs)) {
+    throw new ElsiumError({
+      code: "CONFIG_ERROR",
+      message: "drainTimeoutMs must be >= 0 and finite",
+      retryable: false
+    });
+  }
+  let shuttingDown = false;
+  let inFlightCount = 0;
+  let drainResolve = null;
+  let shutdownPromise = null;
+  const signalHandlers = [];
+  function checkDrained() {
+    if (inFlightCount === 0 && drainResolve) {
+      drainResolve();
+      drainResolve = null;
+    }
+  }
+  async function shutdown() {
+    if (shutdownPromise)
+      return shutdownPromise;
+    shuttingDown = true;
+    shutdownPromise = (async () => {
+      config?.onDrainStart?.();
+      if (inFlightCount === 0) {
+        config?.onDrainComplete?.();
+        return;
+      }
+      const drainPromise = new Promise((resolve) => {
+        drainResolve = resolve;
+      });
+      let drainTimer;
+      const timeoutPromise = new Promise((resolve) => {
+        drainTimer = setTimeout(() => resolve("timeout"), drainTimeoutMs);
+      });
+      const result = await Promise.race([
+        drainPromise.then(() => "drained"),
+        timeoutPromise
+      ]);
+      if (drainTimer !== undefined)
+        clearTimeout(drainTimer);
+      if (result === "timeout") {
+        config?.onForceShutdown?.();
+      } else {
+        config?.onDrainComplete?.();
+      }
+    })();
+    return shutdownPromise;
+  }
+  const manager = {
+    get inFlight() {
+      return inFlightCount;
+    },
+    get isShuttingDown() {
+      return shuttingDown;
+    },
+    async trackOperation(fn) {
+      if (shuttingDown) {
+        throw new ElsiumError({
+          code: "VALIDATION_ERROR",
+          message: "Server is shutting down, not accepting new operations",
+          retryable: true
+        });
+      }
+      inFlightCount++;
+      try {
+        return await fn();
+      } finally {
+        inFlightCount--;
+        checkDrained();
+      }
+    },
+    shutdown,
+    dispose() {
+      for (const { signal, handler } of signalHandlers) {
+        process.removeListener(signal, handler);
+      }
+      signalHandlers.length = 0;
+    }
+  };
+  if (typeof process !== "undefined" && process.on) {
+    for (const signal of signals) {
+      const handler = () => {
+        manager.shutdown();
+      };
+      signalHandlers.push({ signal, handler });
+      process.on(signal, handler);
+    }
+  }
+  return manager;
+}
+export {
+  unwrapOr,
+  unwrap,
+  tryCatchSync,
+  tryCatch,
+  tokenLimitPolicy,
+  sleep,
+  retry,
+  policyMiddleware,
+  ok,
+  modelAccessPolicy,
+  isOk,
+  isErr,
+  generateTraceId,
+  generateId,
+  extractText,
+  err,
+  envNumber,
+  envBool,
+  env,
+  dedupMiddleware,
+  createStream,
+  createShutdownManager,
+  createPolicySet,
+  createLogger,
+  createDedup,
+  createCircuitBreaker,
+  costLimitPolicy,
+  contentPolicy,
+  ElsiumStream,
+  ElsiumError
+};