@elsium-ai/app 0.1.6

package/dist/index.js

@@ -0,0 +1,3890 @@
+// @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}`;
+}
+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 }
+      });
+    }
+  };
+}
+// ../gateway/src/provider.ts
+var providerRegistry = new Map;
+var metadataRegistry = new Map;
+function registerProviderMetadata(name, metadata) {
+  metadataRegistry.set(name, metadata);
+}
+function getProviderMetadata(name) {
+  return metadataRegistry.get(name);
+}
+
+// ../gateway/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);
+  };
+}
+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;
+}
+
+// ../gateway/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;
+}
+
+// ../gateway/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;
+  }
+}
+
+// ../gateway/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);
+    }
+  }
+}
+
+// ../gateway/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);
+    }
+  }
+}
+
+// ../gateway/src/gateway.ts
+var PROVIDER_FACTORIES = {
+  anthropic: createAnthropicProvider,
+  openai: createOpenAIProvider,
+  google: createGoogleProvider
+};
+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);
+}
+// ../observe/src/span.ts
+function createSpan(name, options = {}) {
+  const id = generateId("spn");
+  const traceId = options.traceId ?? generateId("trc");
+  const kind = options.kind ?? "custom";
+  const startTime = Date.now();
+  const metadata = {};
+  const events = [];
+  let status = "running";
+  let endTime;
+  const span = {
+    id,
+    traceId,
+    name,
+    kind,
+    addEvent(eventName, data) {
+      events.push({
+        name: eventName,
+        timestamp: Date.now(),
+        data
+      });
+    },
+    setMetadata(key, value) {
+      if (key === "__proto__" || key === "constructor" || key === "prototype")
+        return;
+      metadata[key] = value;
+    },
+    end(result) {
+      if (endTime !== undefined)
+        return;
+      endTime = Date.now();
+      status = result?.status ?? "ok";
+      if (result?.metadata) {
+        for (const [key, value] of Object.entries(result.metadata)) {
+          if (key === "__proto__" || key === "constructor" || key === "prototype")
+            continue;
+          metadata[key] = value;
+        }
+      }
+      options.onEnd?.(span.toJSON());
+    },
+    child(childName, childKind) {
+      return createSpan(childName, {
+        traceId,
+        parentId: id,
+        kind: childKind ?? kind,
+        onEnd: options.onEnd
+      });
+    },
+    toJSON() {
+      const duration = endTime !== undefined ? endTime - startTime : undefined;
+      return {
+        id,
+        traceId,
+        parentId: options.parentId,
+        name,
+        kind,
+        status,
+        startTime,
+        endTime,
+        durationMs: duration !== undefined ? Math.round(duration) : undefined,
+        metadata,
+        events
+      };
+    }
+  };
+  return span;
+}
+// ../observe/src/tracer.ts
+var log2 = createLogger();
+function observe(config = {}) {
+  const {
+    output = ["console"],
+    costTracking = true,
+    samplingRate = 1,
+    maxSpans = 1e4
+  } = config;
+  const spans = [];
+  const llmCalls = [];
+  const exporters = [];
+  const handlers = [];
+  for (const out of output) {
+    if (out === "console") {
+      handlers.push(consoleHandler);
+    } else if (out === "json-file") {} else {
+      exporters.push(out);
+    }
+  }
+  function shouldSample() {
+    if (samplingRate >= 1)
+      return true;
+    return Math.random() < samplingRate;
+  }
+  function onSpanEnd(span) {
+    if (spans.length >= maxSpans) {
+      spans.shift();
+    }
+    spans.push(span);
+    for (const handler of handlers) {
+      handler(span);
+    }
+  }
+  return {
+    startSpan(name, kind) {
+      if (!shouldSample()) {
+        return createNoopSpan(name, kind);
+      }
+      return createSpan(name, { kind, onEnd: onSpanEnd });
+    },
+    getSpans() {
+      return [...spans];
+    },
+    getCostReport() {
+      const byModel = {};
+      for (const call of llmCalls) {
+        if (!byModel[call.model]) {
+          byModel[call.model] = { cost: 0, tokens: 0, calls: 0 };
+        }
+        byModel[call.model].cost += call.cost;
+        byModel[call.model].tokens += call.inputTokens + call.outputTokens;
+        byModel[call.model].calls++;
+      }
+      return {
+        totalCost: llmCalls.reduce((sum, c) => sum + c.cost, 0),
+        totalTokens: llmCalls.reduce((sum, c) => sum + c.inputTokens + c.outputTokens, 0),
+        totalInputTokens: llmCalls.reduce((sum, c) => sum + c.inputTokens, 0),
+        totalOutputTokens: llmCalls.reduce((sum, c) => sum + c.outputTokens, 0),
+        callCount: llmCalls.length,
+        byModel
+      };
+    },
+    trackLLMCall(data) {
+      if (!costTracking)
+        return;
+      llmCalls.push(data);
+      if (llmCalls.length > maxSpans) {
+        llmCalls.shift();
+      }
+    },
+    reset() {
+      spans.length = 0;
+      llmCalls.length = 0;
+    },
+    async flush() {
+      for (const exporter of exporters) {
+        await exporter.export([...spans]);
+      }
+    }
+  };
+}
+function consoleHandler(span) {
+  const duration = span.durationMs !== undefined ? `${span.durationMs}ms` : "running";
+  const status = span.status === "error" ? "[ERROR]" : span.status === "ok" ? "[OK]" : "[...]";
+  log2.info("span", {
+    trace: span.traceId,
+    span: span.name,
+    kind: span.kind,
+    status,
+    duration,
+    ...Object.keys(span.metadata).length > 0 ? { metadata: span.metadata } : {}
+  });
+}
+function createNoopSpan(name, kind) {
+  const id = generateId("spn");
+  const traceId = generateId("trc");
+  return {
+    id,
+    traceId,
+    name,
+    kind: kind ?? "custom",
+    addEvent() {},
+    setMetadata() {},
+    end() {},
+    child(childName, childKind) {
+      return createNoopSpan(childName, childKind);
+    },
+    toJSON() {
+      return {
+        id,
+        traceId,
+        name,
+        kind: kind ?? "custom",
+        status: "ok",
+        startTime: 0,
+        metadata: {},
+        events: []
+      };
+    }
+  };
+}
+// ../observe/src/otel.ts
+var log3 = createLogger();
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/compose.js
+var compose = (middleware, onError, onNotFound) => {
+  return (context, next) => {
+    let index = -1;
+    return dispatch(0);
+    async function dispatch(i) {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      let res;
+      let isError = false;
+      let handler;
+      if (middleware[i]) {
+        handler = middleware[i][0][0];
+        context.req.routeIndex = i;
+      } else {
+        handler = i === middleware.length && next || undefined;
+      }
+      if (handler) {
+        try {
+          res = await handler(context, () => dispatch(i + 1));
+        } catch (err2) {
+          if (err2 instanceof Error && onError) {
+            context.error = err2;
+            res = await onError(err2, context);
+            isError = true;
+          } else {
+            throw err2;
+          }
+        }
+      } else {
+        if (context.finalized === false && onNotFound) {
+          res = await onNotFound(context);
+        }
+      }
+      if (res && (context.finalized === false || isError)) {
+        context.res = res;
+      }
+      return context;
+    }
+  };
+};
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/request/constants.js
+var GET_MATCH_RESULT = /* @__PURE__ */ Symbol();
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/utils/body.js
+var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
+  const { all = false, dot = false } = options;
+  const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
+  const contentType = headers.get("Content-Type");
+  if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) {
+    return parseFormData(request, { all, dot });
+  }
+  return {};
+};
+async function parseFormData(request, options) {
+  const formData = await request.formData();
+  if (formData) {
+    return convertFormDataToBodyData(formData, options);
+  }
+  return {};
+}
+function convertFormDataToBodyData(formData, options) {
+  const form = /* @__PURE__ */ Object.create(null);
+  formData.forEach((value, key) => {
+    const shouldParseAllValues = options.all || key.endsWith("[]");
+    if (!shouldParseAllValues) {
+      form[key] = value;
+    } else {
+      handleParsingAllValues(form, key, value);
+    }
+  });
+  if (options.dot) {
+    Object.entries(form).forEach(([key, value]) => {
+      const shouldParseDotValues = key.includes(".");
+      if (shouldParseDotValues) {
+        handleParsingNestedValues(form, key, value);
+        delete form[key];
+      }
+    });
+  }
+  return form;
+}
+var handleParsingAllValues = (form, key, value) => {
+  if (form[key] !== undefined) {
+    if (Array.isArray(form[key])) {
+      form[key].push(value);
+    } else {
+      form[key] = [form[key], value];
+    }
+  } else {
+    if (!key.endsWith("[]")) {
+      form[key] = value;
+    } else {
+      form[key] = [value];
+    }
+  }
+};
+var handleParsingNestedValues = (form, key, value) => {
+  let nestedForm = form;
+  const keys = key.split(".");
+  keys.forEach((key2, index) => {
+    if (index === keys.length - 1) {
+      nestedForm[key2] = value;
+    } else {
+      if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
+        nestedForm[key2] = /* @__PURE__ */ Object.create(null);
+      }
+      nestedForm = nestedForm[key2];
+    }
+  });
+};
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/utils/url.js
+var splitPath = (path) => {
+  const paths = path.split("/");
+  if (paths[0] === "") {
+    paths.shift();
+  }
+  return paths;
+};
+var splitRoutingPath = (routePath) => {
+  const { groups, path } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path);
+  return replaceGroupMarks(paths, groups);
+};
+var extractGroupsFromPath = (path) => {
+  const groups = [];
+  path = path.replace(/\{[^}]+\}/g, (match, index) => {
+    const mark = `@${index}`;
+    groups.push([mark, match]);
+    return mark;
+  });
+  return { groups, path };
+};
+var replaceGroupMarks = (paths, groups) => {
+  for (let i = groups.length - 1;i >= 0; i--) {
+    const [mark] = groups[i];
+    for (let j = paths.length - 1;j >= 0; j--) {
+      if (paths[j].includes(mark)) {
+        paths[j] = paths[j].replace(mark, groups[i][1]);
+        break;
+      }
+    }
+  }
+  return paths;
+};
+var patternCache = {};
+var getPattern = (label, next) => {
+  if (label === "*") {
+    return "*";
+  }
+  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+  if (match) {
+    const cacheKey = `${label}#${next}`;
+    if (!patternCache[cacheKey]) {
+      if (match[2]) {
+        patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
+      } else {
+        patternCache[cacheKey] = [label, match[1], true];
+      }
+    }
+    return patternCache[cacheKey];
+  }
+  return null;
+};
+var tryDecode = (str, decoder) => {
+  try {
+    return decoder(str);
+  } catch {
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+      try {
+        return decoder(match);
+      } catch {
+        return match;
+      }
+    });
+  }
+};
+var tryDecodeURI = (str) => tryDecode(str, decodeURI);
+var getPath = (request) => {
+  const url = request.url;
+  const start = url.indexOf("/", url.indexOf(":") + 4);
+  let i = start;
+  for (;i < url.length; i++) {
+    const charCode = url.charCodeAt(i);
+    if (charCode === 37) {
+      const queryIndex = url.indexOf("?", i);
+      const hashIndex = url.indexOf("#", i);
+      const end = queryIndex === -1 ? hashIndex === -1 ? undefined : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
+      const path = url.slice(start, end);
+      return tryDecodeURI(path.includes("%25") ? path.replace(/%25/g, "%2525") : path);
+    } else if (charCode === 63 || charCode === 35) {
+      break;
+    }
+  }
+  return url.slice(start, i);
+};
+var getPathNoStrict = (request) => {
+  const result = getPath(request);
+  return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
+};
+var mergePath = (base, sub, ...rest) => {
+  if (rest.length) {
+    sub = mergePath(sub, ...rest);
+  }
+  return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
+};
+var checkOptionalParameter = (path) => {
+  if (path.charCodeAt(path.length - 1) !== 63 || !path.includes(":")) {
+    return null;
+  }
+  const segments = path.split("/");
+  const results = [];
+  let basePath = "";
+  segments.forEach((segment) => {
+    if (segment !== "" && !/\:/.test(segment)) {
+      basePath += "/" + segment;
+    } else if (/\:/.test(segment)) {
+      if (/\?/.test(segment)) {
+        if (results.length === 0 && basePath === "") {
+          results.push("/");
+        } else {
+          results.push(basePath);
+        }
+        const optionalSegment = segment.replace("?", "");
+        basePath += "/" + optionalSegment;
+        results.push(basePath);
+      } else {
+        basePath += "/" + segment;
+      }
+    }
+  });
+  return results.filter((v, i, a) => a.indexOf(v) === i);
+};
+var _decodeURI = (value) => {
+  if (!/[%+]/.test(value)) {
+    return value;
+  }
+  if (value.indexOf("+") !== -1) {
+    value = value.replace(/\+/g, " ");
+  }
+  return value.indexOf("%") !== -1 ? tryDecode(value, decodeURIComponent_) : value;
+};
+var _getQueryParam = (url, key, multiple) => {
+  let encoded;
+  if (!multiple && key && !/[%+]/.test(key)) {
+    let keyIndex2 = url.indexOf("?", 8);
+    if (keyIndex2 === -1) {
+      return;
+    }
+    if (!url.startsWith(key, keyIndex2 + 1)) {
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    while (keyIndex2 !== -1) {
+      const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
+      if (trailingKeyCode === 61) {
+        const valueIndex = keyIndex2 + key.length + 2;
+        const endIndex = url.indexOf("&", valueIndex);
+        return _decodeURI(url.slice(valueIndex, endIndex === -1 ? undefined : endIndex));
+      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
+        return "";
+      }
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    encoded = /[%+]/.test(url);
+    if (!encoded) {
+      return;
+    }
+  }
+  const results = {};
+  encoded ??= /[%+]/.test(url);
+  let keyIndex = url.indexOf("?", 8);
+  while (keyIndex !== -1) {
+    const nextKeyIndex = url.indexOf("&", keyIndex + 1);
+    let valueIndex = url.indexOf("=", keyIndex);
+    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
+      valueIndex = -1;
+    }
+    let name = url.slice(keyIndex + 1, valueIndex === -1 ? nextKeyIndex === -1 ? undefined : nextKeyIndex : valueIndex);
+    if (encoded) {
+      name = _decodeURI(name);
+    }
+    keyIndex = nextKeyIndex;
+    if (name === "") {
+      continue;
+    }
+    let value;
+    if (valueIndex === -1) {
+      value = "";
+    } else {
+      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? undefined : nextKeyIndex);
+      if (encoded) {
+        value = _decodeURI(value);
+      }
+    }
+    if (multiple) {
+      if (!(results[name] && Array.isArray(results[name]))) {
+        results[name] = [];
+      }
+      results[name].push(value);
+    } else {
+      results[name] ??= value;
+    }
+  }
+  return key ? results[key] : results;
+};
+var getQueryParam = _getQueryParam;
+var getQueryParams = (url, key) => {
+  return _getQueryParam(url, key, true);
+};
+var decodeURIComponent_ = decodeURIComponent;
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/request.js
+var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
+var HonoRequest = class {
+  raw;
+  #validatedData;
+  #matchResult;
+  routeIndex = 0;
+  path;
+  bodyCache = {};
+  constructor(request, path = "/", matchResult = [[]]) {
+    this.raw = request;
+    this.path = path;
+    this.#matchResult = matchResult;
+    this.#validatedData = {};
+  }
+  param(key) {
+    return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
+  }
+  #getDecodedParam(key) {
+    const paramKey = this.#matchResult[0][this.routeIndex][1][key];
+    const param = this.#getParamValue(paramKey);
+    return param && /\%/.test(param) ? tryDecodeURIComponent(param) : param;
+  }
+  #getAllDecodedParams() {
+    const decoded = {};
+    const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
+    for (const key of keys) {
+      const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+      if (value !== undefined) {
+        decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
+      }
+    }
+    return decoded;
+  }
+  #getParamValue(paramKey) {
+    return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
+  }
+  query(key) {
+    return getQueryParam(this.url, key);
+  }
+  queries(key) {
+    return getQueryParams(this.url, key);
+  }
+  header(name) {
+    if (name) {
+      return this.raw.headers.get(name) ?? undefined;
+    }
+    const headerData = {};
+    this.raw.headers.forEach((value, key) => {
+      headerData[key] = value;
+    });
+    return headerData;
+  }
+  async parseBody(options) {
+    return this.bodyCache.parsedBody ??= await parseBody(this, options);
+  }
+  #cachedBody = (key) => {
+    const { bodyCache, raw } = this;
+    const cachedBody = bodyCache[key];
+    if (cachedBody) {
+      return cachedBody;
+    }
+    const anyCachedKey = Object.keys(bodyCache)[0];
+    if (anyCachedKey) {
+      return bodyCache[anyCachedKey].then((body) => {
+        if (anyCachedKey === "json") {
+          body = JSON.stringify(body);
+        }
+        return new Response(body)[key]();
+      });
+    }
+    return bodyCache[key] = raw[key]();
+  };
+  json() {
+    return this.#cachedBody("text").then((text) => JSON.parse(text));
+  }
+  text() {
+    return this.#cachedBody("text");
+  }
+  arrayBuffer() {
+    return this.#cachedBody("arrayBuffer");
+  }
+  blob() {
+    return this.#cachedBody("blob");
+  }
+  formData() {
+    return this.#cachedBody("formData");
+  }
+  addValidatedData(target, data) {
+    this.#validatedData[target] = data;
+  }
+  valid(target) {
+    return this.#validatedData[target];
+  }
+  get url() {
+    return this.raw.url;
+  }
+  get method() {
+    return this.raw.method;
+  }
+  get [GET_MATCH_RESULT]() {
+    return this.#matchResult;
+  }
+  get matchedRoutes() {
+    return this.#matchResult[0].map(([[, route]]) => route);
+  }
+  get routePath() {
+    return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+  }
+};
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/utils/html.js
+var HtmlEscapedCallbackPhase = {
+  Stringify: 1,
+  BeforeStream: 2,
+  Stream: 3
+};
+var raw = (value, callbacks) => {
+  const escapedString = new String(value);
+  escapedString.isEscaped = true;
+  escapedString.callbacks = callbacks;
+  return escapedString;
+};
+var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+  if (typeof str === "object" && !(str instanceof String)) {
+    if (!(str instanceof Promise)) {
+      str = str.toString();
+    }
+    if (str instanceof Promise) {
+      str = await str;
+    }
+  }
+  const callbacks = str.callbacks;
+  if (!callbacks?.length) {
+    return Promise.resolve(str);
+  }
+  if (buffer) {
+    buffer[0] += str;
+  } else {
+    buffer = [str];
+  }
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))).then(() => buffer[0]));
+  if (preserveCallbacks) {
+    return raw(await resStr, callbacks);
+  } else {
+    return resStr;
+  }
+};
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/context.js
+var TEXT_PLAIN = "text/plain; charset=UTF-8";
+var setDefaultContentType = (contentType, headers) => {
+  return {
+    "Content-Type": contentType,
+    ...headers
+  };
+};
+var createResponseInstance = (body, init) => new Response(body, init);
+var Context = class {
+  #rawRequest;
+  #req;
+  env = {};
+  #var;
+  finalized = false;
+  error;
+  #status;
+  #executionCtx;
+  #res;
+  #layout;
+  #renderer;
+  #notFoundHandler;
+  #preparedHeaders;
+  #matchResult;
+  #path;
+  constructor(req, options) {
+    this.#rawRequest = req;
+    if (options) {
+      this.#executionCtx = options.executionCtx;
+      this.env = options.env;
+      this.#notFoundHandler = options.notFoundHandler;
+      this.#path = options.path;
+      this.#matchResult = options.matchResult;
+    }
+  }
+  get req() {
+    this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
+    return this.#req;
+  }
+  get event() {
+    if (this.#executionCtx && "respondWith" in this.#executionCtx) {
+      return this.#executionCtx;
+    } else {
+      throw Error("This context has no FetchEvent");
+    }
+  }
+  get executionCtx() {
+    if (this.#executionCtx) {
+      return this.#executionCtx;
+    } else {
+      throw Error("This context has no ExecutionContext");
+    }
+  }
+  get res() {
+    return this.#res ||= createResponseInstance(null, {
+      headers: this.#preparedHeaders ??= new Headers
+    });
+  }
+  set res(_res) {
+    if (this.#res && _res) {
+      _res = createResponseInstance(_res.body, _res);
+      for (const [k, v] of this.#res.headers.entries()) {
+        if (k === "content-type") {
+          continue;
+        }
+        if (k === "set-cookie") {
+          const cookies = this.#res.headers.getSetCookie();
+          _res.headers.delete("set-cookie");
+          for (const cookie of cookies) {
+            _res.headers.append("set-cookie", cookie);
+          }
+        } else {
+          _res.headers.set(k, v);
+        }
+      }
+    }
+    this.#res = _res;
+    this.finalized = true;
+  }
+  render = (...args) => {
+    this.#renderer ??= (content) => this.html(content);
+    return this.#renderer(...args);
+  };
+  setLayout = (layout) => this.#layout = layout;
+  getLayout = () => this.#layout;
+  setRenderer = (renderer) => {
+    this.#renderer = renderer;
+  };
+  header = (name, value, options) => {
+    if (this.finalized) {
+      this.#res = createResponseInstance(this.#res.body, this.#res);
+    }
+    const headers = this.#res ? this.#res.headers : this.#preparedHeaders ??= new Headers;
+    if (value === undefined) {
+      headers.delete(name);
+    } else if (options?.append) {
+      headers.append(name, value);
+    } else {
+      headers.set(name, value);
+    }
+  };
+  status = (status) => {
+    this.#status = status;
+  };
+  set = (key, value) => {
+    this.#var ??= /* @__PURE__ */ new Map;
+    this.#var.set(key, value);
+  };
+  get = (key) => {
+    return this.#var ? this.#var.get(key) : undefined;
+  };
+  get var() {
+    if (!this.#var) {
+      return {};
+    }
+    return Object.fromEntries(this.#var);
+  }
+  #newResponse(data, arg, headers) {
+    const responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders ?? new Headers;
+    if (typeof arg === "object" && "headers" in arg) {
+      const argHeaders = arg.headers instanceof Headers ? arg.headers : new Headers(arg.headers);
+      for (const [key, value] of argHeaders) {
+        if (key.toLowerCase() === "set-cookie") {
+          responseHeaders.append(key, value);
+        } else {
+          responseHeaders.set(key, value);
+        }
+      }
+    }
+    if (headers) {
+      for (const [k, v] of Object.entries(headers)) {
+        if (typeof v === "string") {
+          responseHeaders.set(k, v);
+        } else {
+          responseHeaders.delete(k);
+          for (const v2 of v) {
+            responseHeaders.append(k, v2);
+          }
+        }
+      }
+    }
+    const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
+    return createResponseInstance(data, { status, headers: responseHeaders });
+  }
+  newResponse = (...args) => this.#newResponse(...args);
+  body = (data, arg, headers) => this.#newResponse(data, arg, headers);
+  text = (text, arg, headers) => {
+    return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(text, arg, setDefaultContentType(TEXT_PLAIN, headers));
+  };
+  json = (object, arg, headers) => {
+    return this.#newResponse(JSON.stringify(object), arg, setDefaultContentType("application/json", headers));
+  };
+  html = (html, arg, headers) => {
+    const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
+    return typeof html === "object" ? resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
+  };
+  redirect = (location, status) => {
+    const locationString = String(location);
+    this.header("Location", !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString));
+    return this.newResponse(null, status ?? 302);
+  };
+  notFound = () => {
+    this.#notFoundHandler ??= () => createResponseInstance();
+    return this.#notFoundHandler(this);
+  };
+};
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/router.js
+var METHOD_NAME_ALL = "ALL";
+var METHOD_NAME_ALL_LOWERCASE = "all";
+var METHODS = ["get", "post", "put", "delete", "options", "patch"];
+var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+var UnsupportedPathError = class extends Error {
+};
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/utils/constants.js
+var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/hono-base.js
+var notFoundHandler = (c) => {
+  return c.text("404 Not Found", 404);
+};
+var errorHandler = (err2, c) => {
+  if ("getResponse" in err2) {
+    const res = err2.getResponse();
+    return c.newResponse(res.body, res);
+  }
+  console.error(err2);
+  return c.text("Internal Server Error", 500);
+};
+var Hono = class _Hono {
+  get;
+  post;
+  put;
+  delete;
+  options;
+  patch;
+  all;
+  on;
+  use;
+  router;
+  getPath;
+  _basePath = "/";
+  #path = "/";
+  routes = [];
+  constructor(options = {}) {
+    const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
+    allMethods.forEach((method) => {
+      this[method] = (args1, ...args) => {
+        if (typeof args1 === "string") {
+          this.#path = args1;
+        } else {
+          this.#addRoute(method, this.#path, args1);
+        }
+        args.forEach((handler) => {
+          this.#addRoute(method, this.#path, handler);
+        });
+        return this;
+      };
+    });
+    this.on = (method, path, ...handlers) => {
+      for (const p of [path].flat()) {
+        this.#path = p;
+        for (const m of [method].flat()) {
+          handlers.map((handler) => {
+            this.#addRoute(m.toUpperCase(), this.#path, handler);
+          });
+        }
+      }
+      return this;
+    };
+    this.use = (arg1, ...handlers) => {
+      if (typeof arg1 === "string") {
+        this.#path = arg1;
+      } else {
+        this.#path = "*";
+        handlers.unshift(arg1);
+      }
+      handlers.forEach((handler) => {
+        this.#addRoute(METHOD_NAME_ALL, this.#path, handler);
+      });
+      return this;
+    };
+    const { strict, ...optionsWithoutStrict } = options;
+    Object.assign(this, optionsWithoutStrict);
+    this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
+  }
+  #clone() {
+    const clone = new _Hono({
+      router: this.router,
+      getPath: this.getPath
+    });
+    clone.errorHandler = this.errorHandler;
+    clone.#notFoundHandler = this.#notFoundHandler;
+    clone.routes = this.routes;
+    return clone;
+  }
+  #notFoundHandler = notFoundHandler;
+  errorHandler = errorHandler;
+  route(path, app) {
+    const subApp = this.basePath(path);
+    app.routes.map((r) => {
+      let handler;
+      if (app.errorHandler === errorHandler) {
+        handler = r.handler;
+      } else {
+        handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
+        handler[COMPOSED_HANDLER] = r.handler;
+      }
+      subApp.#addRoute(r.method, r.path, handler);
+    });
+    return this;
+  }
+  basePath(path) {
+    const subApp = this.#clone();
+    subApp._basePath = mergePath(this._basePath, path);
+    return subApp;
+  }
+  onError = (handler) => {
+    this.errorHandler = handler;
+    return this;
+  };
+  notFound = (handler) => {
+    this.#notFoundHandler = handler;
+    return this;
+  };
+  mount(path, applicationHandler, options) {
+    let replaceRequest;
+    let optionHandler;
+    if (options) {
+      if (typeof options === "function") {
+        optionHandler = options;
+      } else {
+        optionHandler = options.optionHandler;
+        if (options.replaceRequest === false) {
+          replaceRequest = (request) => request;
+        } else {
+          replaceRequest = options.replaceRequest;
+        }
+      }
+    }
+    const getOptions = optionHandler ? (c) => {
+      const options2 = optionHandler(c);
+      return Array.isArray(options2) ? options2 : [options2];
+    } : (c) => {
+      let executionContext = undefined;
+      try {
+        executionContext = c.executionCtx;
+      } catch {}
+      return [c.env, executionContext];
+    };
+    replaceRequest ||= (() => {
+      const mergedPath = mergePath(this._basePath, path);
+      const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
+      return (request) => {
+        const url = new URL(request.url);
+        url.pathname = url.pathname.slice(pathPrefixLength) || "/";
+        return new Request(url, request);
+      };
+    })();
+    const handler = async (c, next) => {
+      const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
+      if (res) {
+        return res;
+      }
+      await next();
+    };
+    this.#addRoute(METHOD_NAME_ALL, mergePath(path, "*"), handler);
+    return this;
+  }
+  #addRoute(method, path, handler) {
+    method = method.toUpperCase();
+    path = mergePath(this._basePath, path);
+    const r = { basePath: this._basePath, path, method, handler };
+    this.router.add(method, path, [handler, r]);
+    this.routes.push(r);
+  }
+  #handleError(err2, c) {
+    if (err2 instanceof Error) {
+      return this.errorHandler(err2, c);
+    }
+    throw err2;
+  }
+  #dispatch(request, executionCtx, env2, method) {
+    if (method === "HEAD") {
+      return (async () => new Response(null, await this.#dispatch(request, executionCtx, env2, "GET")))();
+    }
+    const path = this.getPath(request, { env: env2 });
+    const matchResult = this.router.match(method, path);
+    const c = new Context(request, {
+      path,
+      matchResult,
+      env: env2,
+      executionCtx,
+      notFoundHandler: this.#notFoundHandler
+    });
+    if (matchResult[0].length === 1) {
+      let res;
+      try {
+        res = matchResult[0][0][0][0](c, async () => {
+          c.res = await this.#notFoundHandler(c);
+        });
+      } catch (err2) {
+        return this.#handleError(err2, c);
+      }
+      return res instanceof Promise ? res.then((resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))).catch((err2) => this.#handleError(err2, c)) : res ?? this.#notFoundHandler(c);
+    }
+    const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
+    return (async () => {
+      try {
+        const context = await composed(c);
+        if (!context.finalized) {
+          throw new Error("Context is not finalized. Did you forget to return a Response object or `await next()`?");
+        }
+        return context.res;
+      } catch (err2) {
+        return this.#handleError(err2, c);
+      }
+    })();
+  }
+  fetch = (request, ...rest) => {
+    return this.#dispatch(request, rest[1], rest[0], request.method);
+  };
+  request = (input, requestInit, Env, executionCtx) => {
+    if (input instanceof Request) {
+      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
+    }
+    input = input.toString();
+    return this.fetch(new Request(/^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`, requestInit), Env, executionCtx);
+  };
+  fire = () => {
+    addEventListener("fetch", (event) => {
+      event.respondWith(this.#dispatch(event.request, event, undefined, event.request.method));
+    });
+  };
+};
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/router/reg-exp-router/matcher.js
+var emptyParam = [];
+function match(method, path) {
+  const matchers = this.buildAllMatchers();
+  const match2 = (method2, path2) => {
+    const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
+    const staticMatch = matcher[2][path2];
+    if (staticMatch) {
+      return staticMatch;
+    }
+    const match3 = path2.match(matcher[0]);
+    if (!match3) {
+      return [[], emptyParam];
+    }
+    const index = match3.indexOf("", 1);
+    return [matcher[1][index], match3];
+  };
+  this.match = match2;
+  return match2(method, path);
+}
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/router/reg-exp-router/node.js
+var LABEL_REG_EXP_STR = "[^/]+";
+var ONLY_WILDCARD_REG_EXP_STR = ".*";
+var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+var PATH_ERROR = /* @__PURE__ */ Symbol();
+var regExpMetaChars = new Set(".\\+*[^]$()");
+function compareKey(a, b) {
+  if (a.length === 1) {
+    return b.length === 1 ? a < b ? -1 : 1 : -1;
+  }
+  if (b.length === 1) {
+    return 1;
+  }
+  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
+    return 1;
+  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
+    return -1;
+  }
+  if (a === LABEL_REG_EXP_STR) {
+    return 1;
+  } else if (b === LABEL_REG_EXP_STR) {
+    return -1;
+  }
+  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+}
+var Node = class _Node {
+  #index;
+  #varIndex;
+  #children = /* @__PURE__ */ Object.create(null);
+  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
+    if (tokens.length === 0) {
+      if (this.#index !== undefined) {
+        throw PATH_ERROR;
+      }
+      if (pathErrorCheckOnly) {
+        return;
+      }
+      this.#index = index;
+      return;
+    }
+    const [token, ...restTokens] = tokens;
+    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+    let node;
+    if (pattern) {
+      const name = pattern[1];
+      let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+      if (name && pattern[2]) {
+        if (regexpStr === ".*") {
+          throw PATH_ERROR;
+        }
+        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+        if (/\((?!\?:)/.test(regexpStr)) {
+          throw PATH_ERROR;
+        }
+      }
+      node = this.#children[regexpStr];
+      if (!node) {
+        if (Object.keys(this.#children).some((k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) {
+          throw PATH_ERROR;
+        }
+        if (pathErrorCheckOnly) {
+          return;
+        }
+        node = this.#children[regexpStr] = new _Node;
+        if (name !== "") {
+          node.#varIndex = context.varIndex++;
+        }
+      }
+      if (!pathErrorCheckOnly && name !== "") {
+        paramMap.push([name, node.#varIndex]);
+      }
+    } else {
+      node = this.#children[token];
+      if (!node) {
+        if (Object.keys(this.#children).some((k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) {
+          throw PATH_ERROR;
+        }
+        if (pathErrorCheckOnly) {
+          return;
+        }
+        node = this.#children[token] = new _Node;
+      }
+    }
+    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
+  }
+  buildRegExpStr() {
+    const childKeys = Object.keys(this.#children).sort(compareKey);
+    const strList = childKeys.map((k) => {
+      const c = this.#children[k];
+      return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
+    });
+    if (typeof this.#index === "number") {
+      strList.unshift(`#${this.#index}`);
+    }
+    if (strList.length === 0) {
+      return "";
+    }
+    if (strList.length === 1) {
+      return strList[0];
+    }
+    return "(?:" + strList.join("|") + ")";
+  }
+};
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/router/reg-exp-router/trie.js
+var Trie = class {
+  #context = { varIndex: 0 };
+  #root = new Node;
+  insert(path, index, pathErrorCheckOnly) {
+    const paramAssoc = [];
+    const groups = [];
+    for (let i = 0;; ) {
+      let replaced = false;
+      path = path.replace(/\{[^}]+\}/g, (m) => {
+        const mark = `@\\${i}`;
+        groups[i] = [mark, m];
+        i++;
+        replaced = true;
+        return mark;
+      });
+      if (!replaced) {
+        break;
+      }
+    }
+    const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    for (let i = groups.length - 1;i >= 0; i--) {
+      const [mark] = groups[i];
+      for (let j = tokens.length - 1;j >= 0; j--) {
+        if (tokens[j].indexOf(mark) !== -1) {
+          tokens[j] = tokens[j].replace(mark, groups[i][1]);
+          break;
+        }
+      }
+    }
+    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
+    return paramAssoc;
+  }
+  buildRegExp() {
+    let regexp = this.#root.buildRegExpStr();
+    if (regexp === "") {
+      return [/^$/, [], []];
+    }
+    let captureIndex = 0;
+    const indexReplacementMap = [];
+    const paramReplacementMap = [];
+    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+      if (handlerIndex !== undefined) {
+        indexReplacementMap[++captureIndex] = Number(handlerIndex);
+        return "$()";
+      }
+      if (paramIndex !== undefined) {
+        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+        return "";
+      }
+      return "";
+    });
+    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
+  }
+};
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/router/reg-exp-router/router.js
+var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
+var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+function buildWildcardRegExp(path) {
+  return wildcardRegExpCache[path] ??= new RegExp(path === "*" ? "" : `^${path.replace(/\/\*$|([.\\+*[^\]$()])/g, (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)")}$`);
+}
+function clearWildcardRegExpCache() {
+  wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+}
+function buildMatcherFromPreprocessedRoutes(routes) {
+  const trie = new Trie;
+  const handlerData = [];
+  if (routes.length === 0) {
+    return nullMatcher;
+  }
+  const routesWithStaticPathFlag = routes.map((route) => [!/\*|\/:/.test(route[0]), ...route]).sort(([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length);
+  const staticMap = /* @__PURE__ */ Object.create(null);
+  for (let i = 0, j = -1, len = routesWithStaticPathFlag.length;i < len; i++) {
+    const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i];
+    if (pathErrorCheckOnly) {
+      staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+    } else {
+      j++;
+    }
+    let paramAssoc;
+    try {
+      paramAssoc = trie.insert(path, j, pathErrorCheckOnly);
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
+    }
+    if (pathErrorCheckOnly) {
+      continue;
+    }
+    handlerData[j] = handlers.map(([h, paramCount]) => {
+      const paramIndexMap = /* @__PURE__ */ Object.create(null);
+      paramCount -= 1;
+      for (;paramCount >= 0; paramCount--) {
+        const [key, value] = paramAssoc[paramCount];
+        paramIndexMap[key] = value;
+      }
+      return [h, paramIndexMap];
+    });
+  }
+  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+  for (let i = 0, len = handlerData.length;i < len; i++) {
+    for (let j = 0, len2 = handlerData[i].length;j < len2; j++) {
+      const map = handlerData[i][j]?.[1];
+      if (!map) {
+        continue;
+      }
+      const keys = Object.keys(map);
+      for (let k = 0, len3 = keys.length;k < len3; k++) {
+        map[keys[k]] = paramReplacementMap[map[keys[k]]];
+      }
+    }
+  }
+  const handlerMap = [];
+  for (const i in indexReplacementMap) {
+    handlerMap[i] = handlerData[indexReplacementMap[i]];
+  }
+  return [regexp, handlerMap, staticMap];
+}
+function findMiddleware(middleware, path) {
+  if (!middleware) {
+    return;
+  }
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+    if (buildWildcardRegExp(k).test(path)) {
+      return [...middleware[k]];
+    }
+  }
+  return;
+}
+var RegExpRouter = class {
+  name = "RegExpRouter";
+  #middleware;
+  #routes;
+  constructor() {
+    this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+  }
+  add(method, path, handler) {
+    const middleware = this.#middleware;
+    const routes = this.#routes;
+    if (!middleware || !routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    }
+    if (!middleware[method]) {
+      [middleware, routes].forEach((handlerMap) => {
+        handlerMap[method] = /* @__PURE__ */ Object.create(null);
+        Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
+          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
+        });
+      });
+    }
+    if (path === "/*") {
+      path = "*";
+    }
+    const paramCount = (path.match(/\/:/g) || []).length;
+    if (/\*$/.test(path)) {
+      const re = buildWildcardRegExp(path);
+      if (method === METHOD_NAME_ALL) {
+        Object.keys(middleware).forEach((m) => {
+          middleware[m][path] ||= findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
+        });
+      } else {
+        middleware[method][path] ||= findMiddleware(middleware[method], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
+      }
+      Object.keys(middleware).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(middleware[m]).forEach((p) => {
+            re.test(p) && middleware[m][p].push([handler, paramCount]);
+          });
+        }
+      });
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(routes[m]).forEach((p) => re.test(p) && routes[m][p].push([handler, paramCount]));
+        }
+      });
+      return;
+    }
+    const paths = checkOptionalParameter(path) || [path];
+    for (let i = 0, len = paths.length;i < len; i++) {
+      const path2 = paths[i];
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          routes[m][path2] ||= [
+            ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
+          ];
+          routes[m][path2].push([handler, paramCount - len + i + 1]);
+        }
+      });
+    }
+  }
+  match = match;
+  buildAllMatchers() {
+    const matchers = /* @__PURE__ */ Object.create(null);
+    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
+      matchers[method] ||= this.#buildMatcher(method);
+    });
+    this.#middleware = this.#routes = undefined;
+    clearWildcardRegExpCache();
+    return matchers;
+  }
+  #buildMatcher(method) {
+    const routes = [];
+    let hasOwnRoute = method === METHOD_NAME_ALL;
+    [this.#middleware, this.#routes].forEach((r) => {
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
+      if (ownRoute.length !== 0) {
+        hasOwnRoute ||= true;
+        routes.push(...ownRoute);
+      } else if (method !== METHOD_NAME_ALL) {
+        routes.push(...Object.keys(r[METHOD_NAME_ALL]).map((path) => [path, r[METHOD_NAME_ALL][path]]));
+      }
+    });
+    if (!hasOwnRoute) {
+      return null;
+    } else {
+      return buildMatcherFromPreprocessedRoutes(routes);
+    }
+  }
+};
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/router/reg-exp-router/prepared-router.js
+var PreparedRegExpRouter = class {
+  name = "PreparedRegExpRouter";
+  #matchers;
+  #relocateMap;
+  constructor(matchers, relocateMap) {
+    this.#matchers = matchers;
+    this.#relocateMap = relocateMap;
+  }
+  #addWildcard(method, handlerData) {
+    const matcher = this.#matchers[method];
+    matcher[1].forEach((list) => list && list.push(handlerData));
+    Object.values(matcher[2]).forEach((list) => list[0].push(handlerData));
+  }
+  #addPath(method, path, handler, indexes, map) {
+    const matcher = this.#matchers[method];
+    if (!map) {
+      matcher[2][path][0].push([handler, {}]);
+    } else {
+      indexes.forEach((index) => {
+        if (typeof index === "number") {
+          matcher[1][index].push([handler, map]);
+        } else {
+          matcher[2][index || path][0].push([handler, map]);
+        }
+      });
+    }
+  }
+  add(method, path, handler) {
+    if (!this.#matchers[method]) {
+      const all = this.#matchers[METHOD_NAME_ALL];
+      const staticMap = {};
+      for (const key in all[2]) {
+        staticMap[key] = [all[2][key][0].slice(), emptyParam];
+      }
+      this.#matchers[method] = [
+        all[0],
+        all[1].map((list) => Array.isArray(list) ? list.slice() : 0),
+        staticMap
+      ];
+    }
+    if (path === "/*" || path === "*") {
+      const handlerData = [handler, {}];
+      if (method === METHOD_NAME_ALL) {
+        for (const m in this.#matchers) {
+          this.#addWildcard(m, handlerData);
+        }
+      } else {
+        this.#addWildcard(method, handlerData);
+      }
+      return;
+    }
+    const data = this.#relocateMap[path];
+    if (!data) {
+      throw new Error(`Path ${path} is not registered`);
+    }
+    for (const [indexes, map] of data) {
+      if (method === METHOD_NAME_ALL) {
+        for (const m in this.#matchers) {
+          this.#addPath(m, path, handler, indexes, map);
+        }
+      } else {
+        this.#addPath(method, path, handler, indexes, map);
+      }
+    }
+  }
+  buildAllMatchers() {
+    return this.#matchers;
+  }
+  match = match;
+};
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/router/smart-router/router.js
+var SmartRouter = class {
+  name = "SmartRouter";
+  #routers = [];
+  #routes = [];
+  constructor(init) {
+    this.#routers = init.routers;
+  }
+  add(method, path, handler) {
+    if (!this.#routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    }
+    this.#routes.push([method, path, handler]);
+  }
+  match(method, path) {
+    if (!this.#routes) {
+      throw new Error("Fatal error");
+    }
+    const routers = this.#routers;
+    const routes = this.#routes;
+    const len = routers.length;
+    let i = 0;
+    let res;
+    for (;i < len; i++) {
+      const router = routers[i];
+      try {
+        for (let i2 = 0, len2 = routes.length;i2 < len2; i2++) {
+          router.add(...routes[i2]);
+        }
+        res = router.match(method, path);
+      } catch (e) {
+        if (e instanceof UnsupportedPathError) {
+          continue;
+        }
+        throw e;
+      }
+      this.match = router.match.bind(router);
+      this.#routers = [router];
+      this.#routes = undefined;
+      break;
+    }
+    if (i === len) {
+      throw new Error("Fatal error");
+    }
+    this.name = `SmartRouter + ${this.activeRouter.name}`;
+    return res;
+  }
+  get activeRouter() {
+    if (this.#routes || this.#routers.length !== 1) {
+      throw new Error("No active router has been determined yet.");
+    }
+    return this.#routers[0];
+  }
+};
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/router/trie-router/node.js
+var emptyParams = /* @__PURE__ */ Object.create(null);
+var hasChildren = (children) => {
+  for (const _ in children) {
+    return true;
+  }
+  return false;
+};
+var Node2 = class _Node2 {
+  #methods;
+  #children;
+  #patterns;
+  #order = 0;
+  #params = emptyParams;
+  constructor(method, handler, children) {
+    this.#children = children || /* @__PURE__ */ Object.create(null);
+    this.#methods = [];
+    if (method && handler) {
+      const m = /* @__PURE__ */ Object.create(null);
+      m[method] = { handler, possibleKeys: [], score: 0 };
+      this.#methods = [m];
+    }
+    this.#patterns = [];
+  }
+  insert(method, path, handler) {
+    this.#order = ++this.#order;
+    let curNode = this;
+    const parts = splitRoutingPath(path);
+    const possibleKeys = [];
+    for (let i = 0, len = parts.length;i < len; i++) {
+      const p = parts[i];
+      const nextP = parts[i + 1];
+      const pattern = getPattern(p, nextP);
+      const key = Array.isArray(pattern) ? pattern[0] : p;
+      if (key in curNode.#children) {
+        curNode = curNode.#children[key];
+        if (pattern) {
+          possibleKeys.push(pattern[1]);
+        }
+        continue;
+      }
+      curNode.#children[key] = new _Node2;
+      if (pattern) {
+        curNode.#patterns.push(pattern);
+        possibleKeys.push(pattern[1]);
+      }
+      curNode = curNode.#children[key];
+    }
+    curNode.#methods.push({
+      [method]: {
+        handler,
+        possibleKeys: possibleKeys.filter((v, i, a) => a.indexOf(v) === i),
+        score: this.#order
+      }
+    });
+    return curNode;
+  }
+  #pushHandlerSets(handlerSets, node, method, nodeParams, params) {
+    for (let i = 0, len = node.#methods.length;i < len; i++) {
+      const m = node.#methods[i];
+      const handlerSet = m[method] || m[METHOD_NAME_ALL];
+      const processedSet = {};
+      if (handlerSet !== undefined) {
+        handlerSet.params = /* @__PURE__ */ Object.create(null);
+        handlerSets.push(handlerSet);
+        if (nodeParams !== emptyParams || params && params !== emptyParams) {
+          for (let i2 = 0, len2 = handlerSet.possibleKeys.length;i2 < len2; i2++) {
+            const key = handlerSet.possibleKeys[i2];
+            const processed = processedSet[handlerSet.score];
+            handlerSet.params[key] = params?.[key] && !processed ? params[key] : nodeParams[key] ?? params?.[key];
+            processedSet[handlerSet.score] = true;
+          }
+        }
+      }
+    }
+  }
+  search(method, path) {
+    const handlerSets = [];
+    this.#params = emptyParams;
+    const curNode = this;
+    let curNodes = [curNode];
+    const parts = splitPath(path);
+    const curNodesQueue = [];
+    const len = parts.length;
+    let partOffsets = null;
+    for (let i = 0;i < len; i++) {
+      const part = parts[i];
+      const isLast = i === len - 1;
+      const tempNodes = [];
+      for (let j = 0, len2 = curNodes.length;j < len2; j++) {
+        const node = curNodes[j];
+        const nextNode = node.#children[part];
+        if (nextNode) {
+          nextNode.#params = node.#params;
+          if (isLast) {
+            if (nextNode.#children["*"]) {
+              this.#pushHandlerSets(handlerSets, nextNode.#children["*"], method, node.#params);
+            }
+            this.#pushHandlerSets(handlerSets, nextNode, method, node.#params);
+          } else {
+            tempNodes.push(nextNode);
+          }
+        }
+        for (let k = 0, len3 = node.#patterns.length;k < len3; k++) {
+          const pattern = node.#patterns[k];
+          const params = node.#params === emptyParams ? {} : { ...node.#params };
+          if (pattern === "*") {
+            const astNode = node.#children["*"];
+            if (astNode) {
+              this.#pushHandlerSets(handlerSets, astNode, method, node.#params);
+              astNode.#params = params;
+              tempNodes.push(astNode);
+            }
+            continue;
+          }
+          const [key, name, matcher] = pattern;
+          if (!part && !(matcher instanceof RegExp)) {
+            continue;
+          }
+          const child = node.#children[key];
+          if (matcher instanceof RegExp) {
+            if (partOffsets === null) {
+              partOffsets = new Array(len);
+              let offset = path[0] === "/" ? 1 : 0;
+              for (let p = 0;p < len; p++) {
+                partOffsets[p] = offset;
+                offset += parts[p].length + 1;
+              }
+            }
+            const restPathString = path.substring(partOffsets[i]);
+            const m = matcher.exec(restPathString);
+            if (m) {
+              params[name] = m[0];
+              this.#pushHandlerSets(handlerSets, child, method, node.#params, params);
+              if (hasChildren(child.#children)) {
+                child.#params = params;
+                const componentCount = m[0].match(/\//)?.length ?? 0;
+                const targetCurNodes = curNodesQueue[componentCount] ||= [];
+                targetCurNodes.push(child);
+              }
+              continue;
+            }
+          }
+          if (matcher === true || matcher.test(part)) {
+            params[name] = part;
+            if (isLast) {
+              this.#pushHandlerSets(handlerSets, child, method, params, node.#params);
+              if (child.#children["*"]) {
+                this.#pushHandlerSets(handlerSets, child.#children["*"], method, params, node.#params);
+              }
+            } else {
+              child.#params = params;
+              tempNodes.push(child);
+            }
+          }
+        }
+      }
+      const shifted = curNodesQueue.shift();
+      curNodes = shifted ? tempNodes.concat(shifted) : tempNodes;
+    }
+    if (handlerSets.length > 1) {
+      handlerSets.sort((a, b) => {
+        return a.score - b.score;
+      });
+    }
+    return [handlerSets.map(({ handler, params }) => [handler, params])];
+  }
+};
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/router/trie-router/router.js
+var TrieRouter = class {
+  name = "TrieRouter";
+  #node;
+  constructor() {
+    this.#node = new Node2;
+  }
+  add(method, path, handler) {
+    const results = checkOptionalParameter(path);
+    if (results) {
+      for (let i = 0, len = results.length;i < len; i++) {
+        this.#node.insert(method, results[i], handler);
+      }
+      return;
+    }
+    this.#node.insert(method, path, handler);
+  }
+  match(method, path) {
+    return this.#node.search(method, path);
+  }
+};
+
+// ../../node_modules/.bun/hono@4.12.3/node_modules/hono/dist/hono.js
+var Hono2 = class extends Hono {
+  constructor(options = {}) {
+    super(options);
+    this.router = options.router ?? new SmartRouter({
+      routers: [new RegExpRouter, new TrieRouter]
+    });
+  }
+};
+
+// src/middleware.ts
+import { timingSafeEqual } from "crypto";
+function corsMiddleware(config = true) {
+  const opts = typeof config === "boolean" ? { origin: [], methods: ["GET", "POST", "OPTIONS"] } : config;
+  return async (c, next) => {
+    const requestOrigin = c.req.header("Origin") ?? "";
+    let allowedOrigin;
+    if (Array.isArray(opts.origin)) {
+      allowedOrigin = opts.origin.includes(requestOrigin) ? requestOrigin : "";
+    } else {
+      allowedOrigin = opts.origin ?? "";
+    }
+    if (allowedOrigin) {
+      c.res.headers.set("Access-Control-Allow-Origin", allowedOrigin);
+      c.res.headers.set("Vary", "Origin");
+    }
+    c.res.headers.set("Access-Control-Allow-Methods", (opts.methods ?? ["GET", "POST", "OPTIONS"]).join(", "));
+    c.res.headers.set("Access-Control-Allow-Headers", (opts.headers ?? ["Content-Type", "Authorization"]).join(", "));
+    if (opts.credentials) {
+      c.res.headers.set("Access-Control-Allow-Credentials", "true");
+    }
+    if (c.req.method === "OPTIONS") {
+      return c.body(null, 200);
+    }
+    await next();
+  };
+}
+function authMiddleware(config) {
+  return async (c, next) => {
+    if (c.req.path === "/health") {
+      return next();
+    }
+    const authorization = c.req.header("Authorization");
+    if (!authorization) {
+      return c.json({ error: "Missing Authorization header" }, 401);
+    }
+    if (config.type === "bearer") {
+      const token = authorization.replace(/^Bearer\s+/, "");
+      const expected = config.token;
+      const tokenBuf = Buffer.from(token);
+      const expectedBuf = Buffer.from(expected);
+      if (tokenBuf.length !== expectedBuf.length || !timingSafeEqual(tokenBuf, expectedBuf)) {
+        return c.json({ error: "Invalid token" }, 401);
+      }
+    }
+    await next();
+  };
+}
+function cleanupExpiredEntries(requests, now) {
+  for (const [key, entry] of requests) {
+    if (now > entry.resetTime)
+      requests.delete(key);
+  }
+}
+function rateLimitMiddleware(config) {
+  const requests = new Map;
+  return async (c, next) => {
+    const clientId = c.req.header("CF-Connecting-IP") ?? c.req.header("X-Real-IP") ?? "anonymous";
+    const now = Date.now();
+    if (requests.size > 1e4) {
+      cleanupExpiredEntries(requests, now);
+    }
+    if (requests.size > 1e5) {
+      return c.json({ error: "Too many requests", retryAfterMs: config.windowMs }, 429);
+    }
+    let record = requests.get(clientId);
+    if (!record || now > record.resetTime) {
+      record = { count: 0, resetTime: now + config.windowMs };
+      requests.set(clientId, record);
+    }
+    record.count++;
+    c.res.headers.set("X-RateLimit-Limit", String(config.maxRequests));
+    c.res.headers.set("X-RateLimit-Remaining", String(Math.max(0, config.maxRequests - record.count)));
+    c.res.headers.set("X-RateLimit-Reset", String(Math.ceil(record.resetTime / 1000)));
+    if (record.count > config.maxRequests) {
+      return c.json({ error: "Too many requests", retryAfterMs: record.resetTime - now }, 429);
+    }
+    await next();
+  };
+}
+
+// src/routes.ts
+function createRoutes(deps) {
+  const app = new Hono2;
+  let totalRequests = 0;
+  app.get("/health", (c) => {
+    const response = {
+      status: "ok",
+      version: deps.version,
+      uptime: Math.round((Date.now() - deps.startTime) / 1000),
+      providers: deps.providers
+    };
+    return c.json(response);
+  });
+  app.get("/metrics", (c) => {
+    const costReport = deps.tracer?.getCostReport();
+    const byModel = {};
+    if (costReport?.byModel) {
+      for (const [model, data] of Object.entries(costReport.byModel)) {
+        byModel[model] = {
+          requests: data.calls,
+          tokens: data.tokens,
+          cost: data.cost
+        };
+      }
+    }
+    const response = {
+      uptime: Math.round((Date.now() - deps.startTime) / 1000),
+      totalRequests,
+      totalTokens: costReport?.totalTokens ?? 0,
+      totalCost: costReport?.totalCost ?? 0,
+      byModel
+    };
+    return c.json(response);
+  });
+  app.post("/chat", async (c) => {
+    totalRequests++;
+    const MAX_BODY_SIZE = 1048576;
+    const rawText = await c.req.text();
+    if (rawText.length > MAX_BODY_SIZE) {
+      return c.json({ error: "Request body too large (max 1MB)" }, 413);
+    }
+    const body = JSON.parse(rawText);
+    if (!body.message) {
+      return c.json({ error: "message is required" }, 400);
+    }
+    const agent = body.agent ? deps.agents.get(body.agent) : deps.defaultAgent;
+    if (!agent) {
+      return c.json({
+        error: body.agent ? `Agent "${body.agent}" not found` : "No default agent configured"
+      }, 404);
+    }
+    const result = await agent.run(body.message);
+    deps.tracer?.trackLLMCall({
+      model: "unknown",
+      inputTokens: result.usage.totalInputTokens,
+      outputTokens: result.usage.totalOutputTokens,
+      cost: result.usage.totalCost,
+      latencyMs: 0
+    });
+    const content = typeof result.message.content === "string" ? result.message.content : "";
+    const response = {
+      message: content,
+      usage: {
+        inputTokens: result.usage.totalInputTokens,
+        outputTokens: result.usage.totalOutputTokens,
+        totalTokens: result.usage.totalTokens,
+        cost: result.usage.totalCost
+      },
+      model: agent.config.model ?? "default",
+      traceId: result.traceId
+    };
+    return c.json(response);
+  });
+  app.post("/complete", async (c) => {
+    totalRequests++;
+    const MAX_BODY_SIZE = 1048576;
+    const rawText = await c.req.text();
+    if (rawText.length > MAX_BODY_SIZE) {
+      return c.json({ error: "Request body too large (max 1MB)" }, 413);
+    }
+    const body = JSON.parse(rawText);
+    if (!body.messages?.length) {
+      return c.json({ error: "messages array is required" }, 400);
+    }
+    const messages = body.messages.map((m) => ({
+      role: m.role,
+      content: m.content
+    }));
+    const response = await deps.gateway.complete({
+      messages,
+      model: body.model,
+      system: body.system,
+      maxTokens: body.maxTokens,
+      temperature: body.temperature
+    });
+    deps.tracer?.trackLLMCall({
+      model: response.model,
+      inputTokens: response.usage.inputTokens,
+      outputTokens: response.usage.outputTokens,
+      cost: response.cost.totalCost,
+      latencyMs: response.latencyMs
+    });
+    return c.json({
+      id: response.id,
+      message: response.message.content,
+      model: response.model,
+      usage: response.usage,
+      cost: response.cost,
+      traceId: response.traceId
+    });
+  });
+  app.get("/agents", (c) => {
+    const agents = Array.from(deps.agents.entries()).map(([name, agent]) => ({
+      name,
+      model: agent.config.model ?? "default",
+      tools: agent.config.tools?.map((t) => t.name) ?? []
+    }));
+    return c.json({ agents });
+  });
+  return app;
+}
+
+// src/app.ts
+var log4 = createLogger();
+function createApp(config) {
+  const app = new Hono2;
+  const providerNames = Object.keys(config.gateway.providers);
+  const primaryProvider = providerNames[0];
+  const primaryConfig = config.gateway.providers[primaryProvider];
+  const gw = gateway({
+    provider: primaryProvider,
+    model: config.gateway.defaultModel,
+    apiKey: primaryConfig.apiKey,
+    baseUrl: primaryConfig.baseUrl
+  });
+  const tracer = observe({
+    output: config.observe?.tracing ? ["console"] : [],
+    costTracking: config.observe?.costTracking ?? true
+  });
+  const serverConfig = config.server ?? {};
+  if (serverConfig.cors) {
+    app.use("*", corsMiddleware(serverConfig.cors));
+  }
+  if (serverConfig.auth) {
+    app.use("*", authMiddleware(serverConfig.auth));
+  }
+  if (serverConfig.rateLimit) {
+    app.use("*", rateLimitMiddleware(serverConfig.rateLimit));
+  }
+  const agentMap = new Map;
+  if (config.agents) {
+    for (const agent of config.agents) {
+      agentMap.set(agent.name, agent);
+    }
+  }
+  const defaultAgent = config.agents?.[0];
+  const routes = createRoutes({
+    gateway: gw,
+    agents: agentMap,
+    defaultAgent,
+    tracer,
+    startTime: Date.now(),
+    version: "0.1.0",
+    providers: providerNames
+  });
+  app.route("/", routes);
+  return {
+    hono: app,
+    gateway: gw,
+    tracer,
+    listen(port) {
+      const listenPort = port ?? serverConfig.port ?? 3000;
+      const hostname = serverConfig.hostname ?? "0.0.0.0";
+      const server = Bun.serve({
+        port: listenPort,
+        hostname,
+        fetch: app.fetch
+      });
+      log4.info("ElsiumAI server started", {
+        url: `http://${hostname}:${listenPort}`,
+        routes: ["POST /chat", "POST /complete", "GET /health", "GET /metrics", "GET /agents"]
+      });
+      return {
+        port: server.port,
+        stop: () => {
+          server.stop();
+        }
+      };
+    }
+  };
+}
+// src/rbac.ts
+var log5 = createLogger();
+var BUILT_IN_ROLES = [
+  {
+    name: "admin",
+    permissions: [
+      "model:use:*",
+      "agent:execute:*",
+      "tool:call:*",
+      "config:read",
+      "config:write",
+      "audit:read",
+      "audit:write"
+    ]
+  },
+  {
+    name: "operator",
+    permissions: ["model:use:*", "agent:execute:*", "tool:call:*", "config:read", "audit:read"]
+  },
+  {
+    name: "user",
+    permissions: ["model:use", "agent:execute", "tool:call"]
+  },
+  {
+    name: "viewer",
+    permissions: ["config:read", "audit:read"]
+  }
+];
+function matchPermission(granted, required) {
+  if (granted === required)
+    return true;
+  if (granted.endsWith(":*")) {
+    const prefix = granted.slice(0, -1);
+    return required.startsWith(prefix) || required === granted.slice(0, -2);
+  }
+  return false;
+}
+function createRBAC(config) {
+  if (config.trustRoleHeader === true) {
+    log5.warn("RBAC: trustRoleHeader is enabled \u2014 any client can self-assign roles via the X-Role header. Only use this in development or behind a trusted reverse proxy.");
+  }
+  const roleMap = new Map;
+  for (const role of BUILT_IN_ROLES) {
+    roleMap.set(role.name, role);
+  }
+  for (const role of config.roles) {
+    roleMap.set(role.name, role);
+  }
+  function flattenPermissions(roleName, visited = new Set) {
+    if (visited.has(roleName))
+      return [];
+    visited.add(roleName);
+    const role = roleMap.get(roleName);
+    if (!role)
+      return [];
+    const permissions = [...role.permissions];
+    if (role.inherits) {
+      for (const parent of role.inherits) {
+        permissions.push(...flattenPermissions(parent, visited));
+      }
+    }
+    return permissions;
+  }
+  return {
+    hasPermission(roleName, permission) {
+      const permissions = flattenPermissions(roleName);
+      return permissions.some((p) => matchPermission(p, permission));
+    },
+    getRolePermissions(roleName) {
+      return [...new Set(flattenPermissions(roleName))];
+    },
+    middleware(required) {
+      return async (c, next) => {
+        const extractor = config.roleExtractor ?? ((ctx) => {
+          if (config.trustRoleHeader) {
+            return ctx.req.header("X-Role") ?? config.defaultRole ?? "viewer";
+          }
+          return config.defaultRole ?? "viewer";
+        });
+        const roleName = extractor(c);
+        if (!roleName) {
+          return c.json({ error: "No role assigned" }, 403);
+        }
+        if (!roleMap.has(roleName)) {
+          return c.json({ error: `Unknown role: ${roleName}` }, 403);
+        }
+        const hasAccess = flattenPermissions(roleName).some((p) => matchPermission(p, required));
+        if (!hasAccess) {
+          return c.json({ error: `Insufficient permissions. Required: ${required}` }, 403);
+        }
+        await next();
+      };
+    }
+  };
+}
+export {
+  rateLimitMiddleware,
+  createRoutes,
+  createRBAC,
+  createApp,
+  corsMiddleware,
+  authMiddleware
+};