@diegoaltoworks/chatter 0.47.0 → 0.49.0

package/dist/server.js

@@ -41,12 +41,25 @@ var import_openai = __toESM(require("openai"));
 // src/auth/apikeys.ts
 var import_node_crypto = require("node:crypto");
 var import_jose = require("jose");
+
+// src/auth/secretStrength.ts
+var MIN_SECRET_LENGTH = 16;
+function assertStrongSecret(secret, label) {
+  if (!secret) {
+    throw new Error(`${label} is required and cannot be empty.`);
+  }
+  if (secret.length < MIN_SECRET_LENGTH) {
+    throw new Error(
+      `${label} is too weak: must be at least ${MIN_SECRET_LENGTH} characters (got ${secret.length}). Generate one with \`openssl rand -base64 32\`.`
+    );
+  }
+}
+
+// src/auth/apikeys.ts
 var ApiKeyManager = class {
   secretBytes;
   constructor(secret) {
-    if (!secret) {
-      throw new Error("API key secret is required");
-    }
+    assertStrongSecret(secret, "API key secret (CHATTER_SECRET / config.auth.secret)");
     this.secretBytes = new TextEncoder().encode(secret);
   }
   /**
@@ -149,13 +162,256 @@ var ApiKeyManager = class {
   }
 };
 
+// src/core/guardrails.ts
+function detectLeakage(text) {
+  const flags = [
+    /system prompt/i,
+    /hidden instruction/i,
+    /here (are|is) (my|the) rules/i,
+    /BEGIN SYSTEM PROMPT/i,
+    /tool instructions/i
+  ];
+  return flags.some((rx) => rx.test(text));
+}
+function scrubOutput(text) {
+  return text.replace(/sk-[A-Za-z0-9]{15,}/g, "[REDACTED]").replace(/AIza[0-9A-Za-z_-]{30,}/g, "[REDACTED]");
+}
+function guardOutput(text) {
+  if (detectLeakage(text)) {
+    return "Sorry, I can't share internal instructions. How else can I help?";
+  }
+  return scrubOutput(text);
+}
+
+// src/core/llm.ts
+var DEFAULT_MODEL = "gpt-4o";
+async function completeOnce({
+  client,
+  system,
+  messages,
+  temperature = 0.2,
+  model = DEFAULT_MODEL
+}) {
+  const res = await client.chat.completions.create({
+    model,
+    temperature,
+    messages: [{ role: "system", content: system }, ...messages]
+  });
+  const text = res.choices[0]?.message?.content ?? "";
+  return {
+    content: guardOutput(text),
+    usage: res.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+  };
+}
+async function* completeStream({
+  client,
+  system,
+  messages,
+  temperature = 0.2,
+  model = DEFAULT_MODEL
+}) {
+  const stream5 = await client.chat.completions.create({
+    model,
+    temperature,
+    stream: true,
+    messages: [{ role: "system", content: system }, ...messages]
+  });
+  for await (const chunk2 of stream5) {
+    const delta = chunk2.choices[0]?.delta?.content ?? "";
+    if (delta) yield scrubOutput(delta);
+  }
+}
+
+// src/core/answer.ts
+var noUsage = () => ({ prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 });
+async function runAnswerFn(answerFn, { system, messages, mode, sender, conversationId }) {
+  const result = await answerFn({ system, messages, mode, sender, conversationId });
+  const raw = typeof result === "string" ? result : result?.content;
+  const usage = typeof result === "string" ? void 0 : result?.usage;
+  return {
+    content: guardOutput(typeof raw === "string" ? raw : ""),
+    usage: usage ?? noUsage()
+  };
+}
+async function answerOnce({
+  answerFn,
+  client,
+  system,
+  messages,
+  mode,
+  sender,
+  conversationId,
+  temperature,
+  model
+}) {
+  if (answerFn) {
+    return runAnswerFn(answerFn, { system, messages, mode, sender, conversationId });
+  }
+  return completeOnce({ client, system, messages, temperature, model });
+}
+async function* answerStream({
+  answerFn,
+  client,
+  system,
+  messages,
+  mode,
+  sender,
+  conversationId,
+  temperature,
+  model
+}) {
+  if (answerFn) {
+    const { content } = await runAnswerFn(answerFn, {
+      system,
+      messages,
+      mode,
+      sender,
+      conversationId
+    });
+    if (content) yield content;
+    return;
+  }
+  yield* completeStream({ client, system, messages, temperature, model });
+}
+
+// src/core/buckets.ts
+function defaultBuckets(mode) {
+  return ["base", mode];
+}
+function isIdentified(sender) {
+  return typeof sender === "string" && sender.trim().length > 0;
+}
+function normalize(buckets) {
+  const out = [];
+  for (const raw of buckets) {
+    if (typeof raw !== "string") continue;
+    const bucket = raw.trim();
+    if (bucket && !out.includes(bucket)) out.push(bucket);
+  }
+  return out;
+}
+async function resolveBuckets({
+  mode,
+  sender,
+  bucketsFor
+}) {
+  if (!bucketsFor) return void 0;
+  const identified = isIdentified(sender);
+  const requested = await bucketsFor(identified ? { mode, sender } : { mode });
+  if (!Array.isArray(requested)) return void 0;
+  const cleaned = normalize(requested);
+  if (identified) return cleaned;
+  const ceiling = new Set(defaultBuckets(mode));
+  return cleaned.filter((bucket) => ceiling.has(bucket));
+}
+
+// src/core/messages.ts
+function isClientRole(role) {
+  return role === "user" || role === "assistant";
+}
+function lastUserMessage(messages) {
+  return [...messages].reverse().find((m) => m.role === "user");
+}
+function normalizeMessages(raw) {
+  if (!Array.isArray(raw) || raw.length === 0) return null;
+  const messages = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") return null;
+    const { role, content } = entry;
+    if (!isClientRole(role)) continue;
+    let text = null;
+    if (typeof content === "string") {
+      text = content;
+    } else if (Array.isArray(content)) {
+      text = content.filter(
+        (part) => !!part && typeof part === "object" && part.type === "text" && typeof part.text === "string"
+      ).map((part) => part.text).join("");
+    }
+    if (text === null) continue;
+    messages.push({ role, content: text });
+  }
+  return messages.length > 0 ? messages : null;
+}
+function normalizeChatBody(body) {
+  const source = body && typeof body === "object" ? body : {};
+  if (Array.isArray(source.messages)) {
+    if (source.messages.length === 0) {
+      return { ok: false, error: "messages array cannot be empty" };
+    }
+    const messages = normalizeMessages(source.messages);
+    if (!messages) {
+      return {
+        ok: false,
+        error: "messages must contain user/assistant messages with text content"
+      };
+    }
+    return { ok: true, messages };
+  }
+  const { message } = source;
+  if (message && typeof message !== "object") {
+    return { ok: true, messages: [{ role: "user", content: String(message) }] };
+  }
+  return { ok: false, error: "either 'message' or 'messages' required" };
+}
+
+// src/core/pipeline.ts
+var MODE_SETTINGS = {
+  public: { topK: 6, label: "Context" },
+  private: { topK: 8, label: "Internal Context" }
+};
+async function prepareChat({
+  store,
+  prompts,
+  mode,
+  messages,
+  personaLayer,
+  channelHint,
+  buckets
+}) {
+  const lastUserMsg = lastUserMessage(messages);
+  if (!lastUserMsg) {
+    throw new Error("no user message found in conversation");
+  }
+  const { topK, label } = MODE_SETTINGS[mode];
+  const ctx = await store.query(lastUserMsg.content, topK, buckets ?? defaultBuckets(mode));
+  const persona = personaLayer?.trim() || (mode === "private" ? prompts.privatePersona : prompts.publicPersona);
+  const hint = channelHint?.trim();
+  const system = [
+    prompts.baseSystemRules,
+    persona,
+    ...hint ? [hint] : [],
+    `${label}:
+${ctx.join("\n\n")}`
+  ].join("\n\n");
+  return { system, messages, context: ctx };
+}
+
+// src/core/logger.ts
+var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+function createConsoleLogger(level = "info") {
+  const threshold = LEVEL_ORDER[level];
+  const write = (at) => (...args) => {
+    if (LEVEL_ORDER[at] < threshold) return;
+    console.error(`[${at}]`, ...args);
+  };
+  return {
+    debug: write("debug"),
+    info: write("info"),
+    warn: write("warn"),
+    error: write("error")
+  };
+}
+function resolveLogger(logger, level) {
+  return logger ?? createConsoleLogger(level);
+}
+
 // src/channels/senders.ts
-function createSenderRegistry() {
+function createSenderRegistry(logger = createConsoleLogger()) {
   const senders = /* @__PURE__ */ new Map();
   return {
     register(name, sender) {
       if (senders.has(name)) {
-        console.warn(`Channel sender "${name}" is already registered; overwriting.`);
+        logger.warn(`Channel sender "${name}" is already registered; overwriting.`);
       }
       senders.set(name, sender);
     },
@@ -172,7 +428,7 @@ function createSenderRegistry() {
         await sender.sendText(chatId, text);
         return true;
       } catch (error) {
-        console.warn(`Channel sender "${name}" sendText failed:`, error);
+        logger.warn(`Channel sender "${name}" sendText failed:`, error);
         return false;
       }
     },
@@ -183,7 +439,7 @@ function createSenderRegistry() {
         await sender.sendVoice(chatId, payload);
         return true;
       } catch (error) {
-        console.warn(`Channel sender "${name}" sendVoice failed:`, error);
+        logger.warn(`Channel sender "${name}" sendVoice failed:`, error);
         return false;
       }
     },
@@ -194,7 +450,7 @@ function createSenderRegistry() {
         await sender.sendMedia(chatId, payload);
         return true;
       } catch (error) {
-        console.warn(`Channel sender "${name}" sendMedia failed:`, error);
+        logger.warn(`Channel sender "${name}" sendMedia failed:`, error);
         return false;
       }
     }
@@ -293,6 +549,7 @@ var VectorStore = class _VectorStore {
       authToken: options.databaseAuthToken
     });
     this.knowledgeDir = options.knowledgeDir || "./config/knowledge";
+    this.logger = options.logger ?? createConsoleLogger();
   }
   client;
   /**
@@ -302,9 +559,10 @@ var VectorStore = class _VectorStore {
    */
   db;
   knowledgeDir;
+  logger;
   // On boot: ingest new chunks and embed only missing ones.
   async build() {
-    console.log("\u{1F504} Building knowledge base...");
+    this.logger.info("\u{1F504} Building knowledge base...");
     await this.db.execute(`
       CREATE TABLE IF NOT EXISTS chunks (id TEXT PRIMARY KEY, bucket TEXT NOT NULL, source TEXT NOT NULL, text TEXT NOT NULL);
     `);
@@ -313,7 +571,7 @@ var VectorStore = class _VectorStore {
     `);
     await this.db.execute("CREATE INDEX IF NOT EXISTS idx_chunks_bucket ON chunks(bucket);");
     const docs = loadKnowledge(this.knowledgeDir);
-    console.log(`\u{1F4DA} Loaded ${docs.length} knowledge documents`);
+    this.logger.info(`\u{1F4DA} Loaded ${docs.length} knowledge documents`);
     const rows = [];
     for (const d of docs) {
       for (const part of chunk(d.text)) {
@@ -321,21 +579,19 @@ var VectorStore = class _VectorStore {
         rows.push({ id, bucket: d.bucket, source: d.source, text: part });
       }
     }
-    console.log(`\u{1F4E6} Created ${rows.length} chunks from knowledge documents`);
+    this.logger.info(`\u{1F4E6} Created ${rows.length} chunks from knowledge documents`);
     await this.cleanupStaleChunks(rows.map((r) => r.id));
-    const tx = await this.db.transaction("write");
-    try {
-      for (const r of rows) {
-        await tx.execute({
+    const UPSERT_BATCH = 500;
+    for (let i = 0; i < rows.length; i += UPSERT_BATCH) {
+      const batch = rows.slice(i, i + UPSERT_BATCH);
+      await this.db.batch(
+        batch.map((r) => ({
           sql: `INSERT INTO chunks(id,bucket,source,text) VALUES(?,?,?,?)
                 ON CONFLICT(id) DO NOTHING`,
           args: [r.id, r.bucket, r.source, r.text]
-        });
-      }
-      await tx.commit();
-    } catch (e) {
-      await tx.rollback();
-      throw e;
+        })),
+        "write"
+      );
     }
     const ids = rows.map((r) => r.id);
     const missing = [];
@@ -350,32 +606,25 @@ var VectorStore = class _VectorStore {
       for (const row of res.rows) missing.push(String(row.id));
     }
     if (missing.length === 0) {
-      console.log("\u2705 No new chunks to embed - knowledge base is up to date");
+      this.logger.info("\u2705 No new chunks to embed - knowledge base is up to date");
       return;
     }
-    console.log(`\u{1F52E} Embedding ${missing.length} new/updated chunks with ${EMB_MODEL}...`);
+    this.logger.info(`\u{1F52E} Embedding ${missing.length} new/updated chunks with ${EMB_MODEL}...`);
     const textById = new Map(rows.map((r) => [r.id, r.text]));
     const BATCH = 96;
     for (let i = 0; i < missing.length; i += BATCH) {
       const batchIds = missing.slice(i, i + BATCH);
       const inputs = batchIds.map((id) => textById.get(id) || "");
       const emb = await this.client.embeddings.create({ model: EMB_MODEL, input: inputs });
-      const tx2 = await this.db.transaction("write");
-      try {
-        emb.data.forEach((d, idx) => {
-          const id = batchIds[idx];
-          tx2.execute({
-            sql: "INSERT INTO embeddings(id,model,embedding) VALUES(?,?,?)",
-            args: [id, EMB_MODEL, JSON.stringify(d.embedding)]
-          });
-        });
-        await tx2.commit();
-      } catch (e) {
-        await tx2.rollback();
-        throw e;
-      }
+      await this.db.batch(
+        emb.data.map((d, idx) => ({
+          sql: "INSERT INTO embeddings(id,model,embedding) VALUES(?,?,?)",
+          args: [batchIds[idx], EMB_MODEL, JSON.stringify(d.embedding)]
+        })),
+        "write"
+      );
     }
-    console.log(`\u2705 Successfully embedded ${missing.length} new chunks`);
+    this.logger.info(`\u2705 Successfully embedded ${missing.length} new chunks`);
   }
   // Remove chunks from database that no longer exist in markdown files
   async cleanupStaleChunks(currentIds) {
@@ -386,7 +635,7 @@ var VectorStore = class _VectorStore {
     if (staleIds.length === 0) {
       return;
     }
-    console.log(`\u{1F9F9} Cleaning up ${staleIds.length} stale chunks...`);
+    this.logger.info(`\u{1F9F9} Cleaning up ${staleIds.length} stale chunks...`);
     const BATCH_SIZE = 500;
     for (let i = 0; i < staleIds.length; i += BATCH_SIZE) {
       const batch = staleIds.slice(i, i + BATCH_SIZE);
@@ -396,7 +645,7 @@ var VectorStore = class _VectorStore {
         args: batch
       });
     }
-    console.log(`\u2713 Cleaned up ${staleIds.length} stale chunks and their embeddings`);
+    this.logger.info(`\u2713 Cleaned up ${staleIds.length} stale chunks and their embeddings`);
   }
   static cosine(a, b) {
     let dot = 0;
@@ -446,278 +695,122 @@ var VectorStore = class _VectorStore {
 var STATIC_ADAPTERS = {
   bun: "hono/bun",
   node: "@hono/node-server/serve-static"
-};
-function detectRuntime() {
-  return typeof globalThis.Bun === "undefined" ? "node" : "bun";
-}
-function wrapMissingAdapterError(runtime, cause) {
-  const specifier = STATIC_ADAPTERS[runtime];
-  return new Error(
-    `Serving static files under ${runtime} requires '${specifier}', which could not be loaded. ` + (runtime === "node" ? "Install the optional peer dependency with `npm install @hono/node-server` (or bun/pnpm/yarn), or run Chatter headless (`features.headless: true`) if it should serve no static assets." : "Upgrade 'hono' to a version that ships the Bun adapter."),
-    { cause }
-  );
-}
-var cache = /* @__PURE__ */ new Map();
-function loadServeStatic(runtime = detectRuntime()) {
-  const cached = cache.get(runtime);
-  if (cached) return cached;
-  const loading = (runtime === "bun" ? import("hono/bun") : import("@hono/node-server/serve-static")).then(
-    (module2) => module2.serveStatic,
-    (error) => {
-      cache.delete(runtime);
-      throw wrapMissingAdapterError(runtime, error);
-    }
-  );
-  cache.set(runtime, loading);
-  return loading;
-}
-
-// src/core/widgets.ts
-var import_node_fs3 = require("node:fs");
-var import_node_path3 = require("node:path");
-var import_node_url = require("node:url");
-var import_meta = {};
-function resolveStatic(configStaticDir) {
-  if (configStaticDir && (0, import_node_fs3.existsSync)(configStaticDir)) {
-    return { staticDir: configStaticDir };
-  }
-  try {
-    if (import_meta.url) {
-      const moduleDir = (0, import_node_path3.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
-      const staticDir = (0, import_node_path3.join)(moduleDir, "static");
-      if ((0, import_node_fs3.existsSync)(staticDir)) return { staticDir };
-    }
-  } catch {
-  }
-  try {
-    if (typeof __dirname !== "undefined") {
-      const staticDir = (0, import_node_path3.join)(__dirname, "static");
-      if ((0, import_node_fs3.existsSync)(staticDir)) return { staticDir };
-    }
-  } catch {
-  }
-  return { staticDir: null };
-}
-
-// src/middleware/cors.ts
-var ALLOWED_HEADERS = "content-type, x-api-key, authorization";
-var ALLOWED_METHODS = "POST, GET, OPTIONS";
-var cors = (allowedOrigins) => async (c, next) => {
-  const requestOrigin = c.req.header("origin");
-  const allowAll = !allowedOrigins || allowedOrigins.length === 0 || allowedOrigins.includes("*");
-  const originHeader = resolveOrigin(requestOrigin, allowedOrigins, allowAll);
-  if (c.req.method === "OPTIONS") {
-    return new Response(null, {
-      status: 204,
-      headers: {
-        "access-control-allow-origin": originHeader,
-        "access-control-allow-headers": ALLOWED_HEADERS,
-        "access-control-allow-methods": ALLOWED_METHODS,
-        ...allowAll ? {} : { vary: "Origin" }
-      }
-    });
-  }
-  c.header("access-control-allow-origin", originHeader);
-  c.header("access-control-allow-headers", ALLOWED_HEADERS);
-  c.header("access-control-allow-methods", ALLOWED_METHODS);
-  if (!allowAll) {
-    c.header("vary", "Origin");
-  }
-  await next();
-};
-function resolveOrigin(requestOrigin, allowedOrigins, allowAll) {
-  if (allowAll) return "*";
-  if (requestOrigin && allowedOrigins.includes(requestOrigin)) {
-    return requestOrigin;
-  }
-  return allowedOrigins[0];
-}
-
-// src/routes/demo.ts
-var import_hono = require("hono");
-var import_streaming = require("hono/streaming");
-
-// src/core/guardrails.ts
-function detectLeakage(text) {
-  const flags = [
-    /system prompt/i,
-    /hidden instruction/i,
-    /here (are|is) (my|the) rules/i,
-    /BEGIN SYSTEM PROMPT/i,
-    /tool instructions/i
-  ];
-  return flags.some((rx) => rx.test(text));
-}
-function scrubOutput(text) {
-  return text.replace(/sk-[A-Za-z0-9]{15,}/g, "[REDACTED]").replace(/AIza[0-9A-Za-z_-]{30,}/g, "[REDACTED]");
-}
-function guardOutput(text) {
-  if (detectLeakage(text)) {
-    return "Sorry, I can't share internal instructions. How else can I help?";
-  }
-  return scrubOutput(text);
-}
-
-// src/core/llm.ts
-var DEFAULT_MODEL = "gpt-4o";
-async function completeOnce({
-  client,
-  system,
-  messages,
-  temperature = 0.2,
-  model = DEFAULT_MODEL
-}) {
-  const res = await client.chat.completions.create({
-    model,
-    temperature,
-    messages: [{ role: "system", content: system }, ...messages]
-  });
-  const text = res.choices[0]?.message?.content ?? "";
-  return {
-    content: guardOutput(text),
-    usage: res.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
-  };
-}
-async function* completeStream({
-  client,
-  system,
-  messages,
-  temperature = 0.2,
-  model = DEFAULT_MODEL
-}) {
-  const stream5 = await client.chat.completions.create({
-    model,
-    temperature,
-    stream: true,
-    messages: [{ role: "system", content: system }, ...messages]
-  });
-  for await (const chunk2 of stream5) {
-    const delta = chunk2.choices[0]?.delta?.content ?? "";
-    if (delta) yield scrubOutput(delta);
-  }
-}
-
-// src/core/answer.ts
-var noUsage = () => ({ prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 });
-async function runAnswerFn(answerFn, { system, messages, mode, sender }) {
-  const result = await answerFn({ system, messages, mode, sender });
-  const raw = typeof result === "string" ? result : result?.content;
-  const usage = typeof result === "string" ? void 0 : result?.usage;
-  return {
-    content: guardOutput(typeof raw === "string" ? raw : ""),
-    usage: usage ?? noUsage()
-  };
-}
-async function answerOnce({
-  answerFn,
-  client,
-  system,
-  messages,
-  mode,
-  sender,
-  temperature,
-  model
-}) {
-  if (answerFn) {
-    return runAnswerFn(answerFn, { system, messages, mode, sender });
-  }
-  return completeOnce({ client, system, messages, temperature, model });
-}
-async function* answerStream({
-  answerFn,
-  client,
-  system,
-  messages,
-  mode,
-  sender,
-  temperature,
-  model
-}) {
-  if (answerFn) {
-    const { content } = await runAnswerFn(answerFn, { system, messages, mode, sender });
-    if (content) yield content;
-    return;
-  }
-  yield* completeStream({ client, system, messages, temperature, model });
-}
-
-// src/core/buckets.ts
-function defaultBuckets(mode) {
-  return ["base", mode];
-}
-function isIdentified(sender) {
-  return typeof sender === "string" && sender.trim().length > 0;
-}
-function normalize(buckets) {
-  const out = [];
-  for (const raw of buckets) {
-    if (typeof raw !== "string") continue;
-    const bucket = raw.trim();
-    if (bucket && !out.includes(bucket)) out.push(bucket);
-  }
-  return out;
-}
-async function resolveBuckets({
-  mode,
-  sender,
-  bucketsFor
-}) {
-  if (!bucketsFor) return void 0;
-  const identified = isIdentified(sender);
-  const requested = await bucketsFor(identified ? { mode, sender } : { mode });
-  if (!Array.isArray(requested)) return void 0;
-  const cleaned = normalize(requested);
-  if (identified) return cleaned;
-  const ceiling = new Set(defaultBuckets(mode));
-  return cleaned.filter((bucket) => ceiling.has(bucket));
+};
+function detectRuntime() {
+  return typeof globalThis.Bun === "undefined" ? "node" : "bun";
 }
-
-// src/core/messages.ts
-function isClientRole(role) {
-  return role === "user" || role === "assistant";
+function wrapMissingAdapterError(runtime, cause) {
+  const specifier = STATIC_ADAPTERS[runtime];
+  return new Error(
+    `Serving static files under ${runtime} requires '${specifier}', which could not be loaded. ` + (runtime === "node" ? "Install the optional peer dependency with `npm install @hono/node-server` (or bun/pnpm/yarn), or run Chatter headless (`features.headless: true`) if it should serve no static assets." : "Upgrade 'hono' to a version that ships the Bun adapter."),
+    { cause }
+  );
 }
-function normalizeMessages(raw) {
-  if (!Array.isArray(raw) || raw.length === 0) return null;
-  const messages = [];
-  for (const entry of raw) {
-    if (!entry || typeof entry !== "object") return null;
-    const { role, content } = entry;
-    if (!isClientRole(role)) continue;
-    let text = null;
-    if (typeof content === "string") {
-      text = content;
-    } else if (Array.isArray(content)) {
-      text = content.filter(
-        (part) => !!part && typeof part === "object" && part.type === "text" && typeof part.text === "string"
-      ).map((part) => part.text).join("");
+var cache = /* @__PURE__ */ new Map();
+function loadServeStatic(runtime = detectRuntime()) {
+  const cached = cache.get(runtime);
+  if (cached) return cached;
+  const loading = (runtime === "bun" ? import("hono/bun") : import("@hono/node-server/serve-static")).then(
+    (module2) => module2.serveStatic,
+    (error) => {
+      cache.delete(runtime);
+      throw wrapMissingAdapterError(runtime, error);
     }
-    if (text === null) continue;
-    messages.push({ role, content: text });
-  }
-  return messages.length > 0 ? messages : null;
+  );
+  cache.set(runtime, loading);
+  return loading;
 }
-function normalizeChatBody(body) {
-  const source = body && typeof body === "object" ? body : {};
-  if (Array.isArray(source.messages)) {
-    if (source.messages.length === 0) {
-      return { ok: false, error: "messages array cannot be empty" };
+
+// src/core/widgets.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path3 = require("node:path");
+var import_node_url = require("node:url");
+var import_meta = {};
+function resolveStatic(configStaticDir) {
+  if (configStaticDir && (0, import_node_fs3.existsSync)(configStaticDir)) {
+    return { staticDir: configStaticDir };
+  }
+  try {
+    if (import_meta.url) {
+      const moduleDir = (0, import_node_path3.dirname)((0, import_node_url.fileURLToPath)(import_meta.url));
+      const staticDir = (0, import_node_path3.join)(moduleDir, "static");
+      if ((0, import_node_fs3.existsSync)(staticDir)) return { staticDir };
     }
-    const messages = normalizeMessages(source.messages);
-    if (!messages) {
-      return {
-        ok: false,
-        error: "messages must contain user/assistant messages with text content"
-      };
+  } catch {
+  }
+  try {
+    if (typeof __dirname !== "undefined") {
+      const staticDir = (0, import_node_path3.join)(__dirname, "static");
+      if ((0, import_node_fs3.existsSync)(staticDir)) return { staticDir };
     }
-    return { ok: true, messages };
+  } catch {
   }
-  const { message } = source;
-  if (message && typeof message !== "object") {
-    return { ok: true, messages: [{ role: "user", content: String(message) }] };
+  return { staticDir: null };
+}
+
+// src/middleware/cors.ts
+var ALLOWED_HEADERS = "content-type, x-api-key, authorization, x-conversation-id";
+var ALLOWED_METHODS = "POST, GET, OPTIONS";
+var EXPOSED_HEADERS = "x-conversation-id";
+var cors = (allowedOrigins) => async (c, next) => {
+  const requestOrigin = c.req.header("origin");
+  const allowAll = !allowedOrigins || allowedOrigins.length === 0 || allowedOrigins.includes("*");
+  const originHeader = resolveOrigin(requestOrigin, allowedOrigins, allowAll);
+  if (c.req.method === "OPTIONS") {
+    return new Response(null, {
+      status: 204,
+      headers: {
+        "access-control-allow-origin": originHeader,
+        "access-control-allow-headers": ALLOWED_HEADERS,
+        "access-control-allow-methods": ALLOWED_METHODS,
+        "access-control-expose-headers": EXPOSED_HEADERS,
+        ...allowAll ? {} : { vary: "Origin" }
+      }
+    });
   }
-  return { ok: false, error: "either 'message' or 'messages' required" };
+  c.header("access-control-allow-origin", originHeader);
+  c.header("access-control-allow-headers", ALLOWED_HEADERS);
+  c.header("access-control-allow-methods", ALLOWED_METHODS);
+  c.header("access-control-expose-headers", EXPOSED_HEADERS);
+  if (!allowAll) {
+    c.header("vary", "Origin");
+  }
+  await next();
+};
+function resolveOrigin(requestOrigin, allowedOrigins, allowAll) {
+  if (allowAll) return "*";
+  if (requestOrigin && allowedOrigins.includes(requestOrigin)) {
+    return requestOrigin;
+  }
+  return allowedOrigins[0];
+}
+
+// src/middleware/securityHeaders.ts
+var DEFAULT_CSP = "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; connect-src 'self' https:; frame-ancestors 'self'";
+var DEFAULT_HSTS = "max-age=15552000; includeSubDomains";
+function isHttps(c, trustProxy) {
+  if (new URL(c.req.url).protocol === "https:") return true;
+  if (!trustProxy) return false;
+  return c.req.header("x-forwarded-proto")?.toLowerCase() === "https";
+}
+function securityHeaders(config) {
+  const csp = config.server?.contentSecurityPolicy || DEFAULT_CSP;
+  const hsts = config.server?.strictTransportSecurity ?? DEFAULT_HSTS;
+  const trustProxy = config.rateLimit?.trustProxy ?? true;
+  return async (c, next) => {
+    await next();
+    c.header("content-security-policy", csp);
+    c.header("x-content-type-options", "nosniff");
+    if (hsts && (isHttps(c, trustProxy) || process.env.NODE_ENV === "production")) {
+      c.header("strict-transport-security", hsts);
+    }
+  };
 }
 
+// src/routes/demo.ts
+var import_hono = require("hono");
+var import_streaming = require("hono/streaming");
+
 // src/core/session.ts
 var import_node_crypto2 = require("node:crypto");
 var sessions = /* @__PURE__ */ new Map();
@@ -769,26 +862,94 @@ function getActiveSessions() {
   return sessions.size;
 }
 
+// src/middleware/bodyLimit.ts
+var import_body_limit = require("hono/body-limit");
+var DEFAULT_MAX_REQUEST_BYTES = 262144;
+function chatBodyLimit(maxSize = DEFAULT_MAX_REQUEST_BYTES, toError = (message) => ({ error: message })) {
+  return (0, import_body_limit.bodyLimit)({
+    maxSize,
+    onError: (c) => c.json(toError("Request body too large"), 413)
+  });
+}
+
+// src/middleware/clientKey.ts
+function clientRateLimitKey(c, trustProxy) {
+  if (!trustProxy) return "shared";
+  const header = c.req.header("x-forwarded-for");
+  if (!header) return "unknown-ip";
+  return header.split(",")[0].trim() || "unknown-ip";
+}
+
+// src/middleware/originMatch.ts
+function matchesAllowedOrigin(origin, referer, allowedOrigins) {
+  return allowedOrigins.some((allowed) => {
+    if (origin === allowed) return true;
+    if (referer) {
+      if (referer === allowed) return true;
+      if (referer.startsWith(`${allowed}/`)) return true;
+      if (referer.startsWith(`${allowed}?`)) return true;
+    }
+    return false;
+  });
+}
+function isLocalhost(value) {
+  if (!value) return false;
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+    return url.hostname === "localhost" || url.hostname === "127.0.0.1";
+  } catch {
+    return false;
+  }
+}
+function matchesAllowedOriginOrLocalhost(origin, referer, allowedOrigins) {
+  if (isLocalhost(origin) || isLocalhost(referer)) return true;
+  return matchesAllowedOrigin(origin, referer, allowedOrigins);
+}
+
+// src/middleware/windowBucket.ts
+function createWindowBucketLimiter(windowMs, now = Date.now) {
+  const buckets = /* @__PURE__ */ new Map();
+  let lastSweep = now();
+  function sweep(current) {
+    if (current - lastSweep < windowMs) return;
+    lastSweep = current;
+    for (const [key, bucket] of buckets) {
+      if (current - bucket.windowStart >= windowMs) buckets.delete(key);
+    }
+  }
+  return {
+    /** Records one hit for `key` and reports whether it's still within `limit`. */
+    hit(key, limit) {
+      const current = now();
+      sweep(current);
+      const bucket = buckets.get(key);
+      if (!bucket || current - bucket.windowStart >= windowMs) {
+        buckets.set(key, { count: 1, windowStart: current });
+        return 1 <= limit;
+      }
+      bucket.count += 1;
+      return bucket.count <= limit;
+    },
+    /** Current map size — for tests asserting eviction actually happened. */
+    size() {
+      return buckets.size;
+    }
+  };
+}
+
 // src/routes/demo.ts
-function checkDemoOrigin(allowedOrigins) {
+function checkDemoOrigin(allowedOrigins, allowLocalhost) {
   const allowAll = allowedOrigins.length === 0 || allowedOrigins.includes("*");
+  const matches = allowLocalhost ? matchesAllowedOriginOrLocalhost : matchesAllowedOrigin;
   return async (c, next) => {
-    const origin = c.req.header("origin");
-    const referer = c.req.header("referer");
-    const host = c.req.header("host") || "";
-    if (host.startsWith("localhost:") || host.startsWith("127.0.0.1:")) {
-      return next();
-    }
     if (allowAll) {
       return next();
     }
-    if (origin) {
-      const allowed = allowedOrigins.some((allowed2) => origin.startsWith(allowed2));
-      if (allowed) return next();
-    }
-    if (referer) {
-      const allowed = allowedOrigins.some((allowed2) => referer.startsWith(allowed2));
-      if (allowed) return next();
+    const origin = c.req.header("origin");
+    const referer = c.req.header("referer");
+    if (matches(origin, referer, allowedOrigins)) {
+      return next();
     }
     return c.json(
       {
@@ -798,22 +959,12 @@ function checkDemoOrigin(allowedOrigins) {
     );
   };
 }
-function limitSessionCreation() {
-  const buckets = /* @__PURE__ */ new Map();
-  const WINDOW_MS = 36e5;
+function limitSessionCreation(trustProxy) {
+  const limiter = createWindowBucketLimiter(36e5);
   const LIMIT = 10;
   return async (c, next) => {
-    const ip = c.req.header("x-forwarded-for")?.split(",")[0].trim() || "unknown-ip";
-    const key = `session:${ip}`;
-    const now = Date.now();
-    const b = buckets.get(key) ?? { count: 0, windowStart: now };
-    if (now - b.windowStart >= WINDOW_MS) {
-      b.count = 0;
-      b.windowStart = now;
-    }
-    b.count += 1;
-    buckets.set(key, b);
-    if (b.count > LIMIT) {
+    const key = `session:${clientRateLimitKey(c, trustProxy)}`;
+    if (!limiter.hit(key, LIMIT)) {
       return c.json(
         {
           error: "Session key limit exceeded (10 per hour). Please wait or use your own API key."
@@ -824,22 +975,12 @@ function limitSessionCreation() {
     await next();
   };
 }
-function limitDemo() {
-  const buckets = /* @__PURE__ */ new Map();
-  const WINDOW_MS = 6e4;
+function limitDemo(trustProxy) {
+  const limiter = createWindowBucketLimiter(6e4);
   const LIMIT = 10;
   return async (c, next) => {
-    const ip = c.req.header("x-forwarded-for")?.split(",")[0].trim() || "unknown-ip";
-    const key = `demo:${ip}`;
-    const now = Date.now();
-    const b = buckets.get(key) ?? { count: 0, windowStart: now };
-    if (now - b.windowStart >= WINDOW_MS) {
-      b.count = 0;
-      b.windowStart = now;
-    }
-    b.count += 1;
-    buckets.set(key, b);
-    if (b.count > LIMIT) {
+    const key = `demo:${clientRateLimitKey(c, trustProxy)}`;
+    if (!limiter.hit(key, LIMIT)) {
       return c.json(
         {
           error: "Demo rate limit exceeded (10 requests/minute). Please wait or use your own API key."
@@ -851,82 +992,91 @@ function limitDemo() {
   };
 }
 function demoRoutes(deps) {
-  const { client, store, config, prompts } = deps;
+  const { client, store, config, prompts, logger } = deps;
   const app = new import_hono.Hono();
   const demoOrigins = config.server?.allowedOrigins ?? [];
-  app.get("/api/demo/session", checkDemoOrigin(demoOrigins), limitSessionCreation(), (c) => {
-    const session = createSession({
-      maxRequests: 20,
-      ttl: 3600
-      // 1 hour
-    });
-    console.log(
-      `[Demo] Created session: ${session.key.slice(0, 20)}... (${session.maxRequests} requests, ${3600}s TTL)`
-    );
-    return c.json({
-      key: session.key,
-      expiresIn: 3600,
-      maxRequests: session.maxRequests,
-      message: "Use this temporary key in the x-api-key header"
-    });
-  });
+  const allowLocalhostDemo = config.server?.allowLocalhostDemo ?? false;
+  const trustProxy = config.rateLimit?.trustProxy ?? true;
+  app.get(
+    "/api/demo/session",
+    checkDemoOrigin(demoOrigins, allowLocalhostDemo),
+    limitSessionCreation(trustProxy),
+    (c) => {
+      const session = createSession({
+        maxRequests: 20,
+        ttl: 3600
+        // 1 hour
+      });
+      logger.debug(
+        `[Demo] Created session: ${session.key.slice(0, 20)}... (${session.maxRequests} requests, ${3600}s TTL)`
+      );
+      return c.json({
+        key: session.key,
+        expiresIn: 3600,
+        maxRequests: session.maxRequests,
+        message: "Use this temporary key in the x-api-key header"
+      });
+    }
+  );
   app.get("/api/demo/stats", (c) => {
     return c.json({
       activeSessions: getActiveSessions()
     });
   });
-  app.post("/api/demo/chat", limitDemo(), async (c) => {
-    try {
-      const body = await c.req.json().catch(() => ({}));
-      const normalized = normalizeChatBody(body);
-      if (!normalized.ok) {
-        return c.json({ error: normalized.error }, 400);
-      }
-      const { messages } = normalized;
-      const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
-      if (!lastUserMsg) {
-        return c.json({ error: "no user message found in conversation" }, 400);
-      }
-      const buckets = await resolveBuckets({ mode: "public", bucketsFor: config.bucketsFor }) ?? defaultBuckets("public");
-      const ctx = await store.query(lastUserMsg.content, 6, buckets);
-      const system = [
-        prompts.baseSystemRules,
-        prompts.publicPersona,
-        `Context:
-${ctx.join("\n\n")}`
-      ].join("\n\n");
-      const url = new URL(c.req.url);
-      const wantsStream3 = url.searchParams.get("stream") === "1";
-      if (wantsStream3) {
-        return (0, import_streaming.stream)(c, async (s) => {
-          for await (const delta of answerStream({
-            answerFn: config.answerFn,
-            client,
-            system,
-            messages,
-            mode: "public"
-          })) {
-            await s.write(`data: ${JSON.stringify({ delta })}
+  app.post(
+    "/api/demo/chat",
+    chatBodyLimit(config.server?.maxRequestBytes),
+    // Reject oversized bodies first
+    limitDemo(trustProxy),
+    async (c) => {
+      try {
+        const body = await c.req.json().catch(() => ({}));
+        const normalized = normalizeChatBody(body);
+        if (!normalized.ok) {
+          return c.json({ error: normalized.error }, 400);
+        }
+        const { messages } = normalized;
+        if (!lastUserMessage(messages)) {
+          return c.json({ error: "no user message found in conversation" }, 400);
+        }
+        const buckets = await resolveBuckets({ mode: "public", bucketsFor: config.bucketsFor });
+        const { system } = await prepareChat({ store, prompts, mode: "public", messages, buckets });
+        const model = config.openai.model || DEFAULT_MODEL;
+        const url = new URL(c.req.url);
+        const wantsStream3 = url.searchParams.get("stream") === "1";
+        if (wantsStream3) {
+          return (0, import_streaming.stream)(c, async (s) => {
+            for await (const delta of answerStream({
+              answerFn: config.answerFn,
+              client,
+              system,
+              messages,
+              mode: "public",
+              model
+            })) {
+              await s.write(`data: ${JSON.stringify({ delta })}
 
 `);
-          }
-          await s.write("event: end\ndata: {}\n\n");
+            }
+            await s.write("event: end\ndata: {}\n\n");
+          });
+        }
+        const out = await answerOnce({
+          answerFn: config.answerFn,
+          client,
+          system,
+          messages,
+          mode: "public",
+          model
         });
+        return c.json({ reply: out.content });
+      } catch (error) {
+        const err = error;
+        logger.error("Demo chat error:", err);
+        return c.json({ error: err.message || "Internal error" }, 500);
       }
-      const out = await answerOnce({
-        answerFn: config.answerFn,
-        client,
-        system,
-        messages,
-        mode: "public"
-      });
-      return c.json({ reply: out.content });
-    } catch (error) {
-      const err = error;
-      console.error("Demo chat error:", err);
-      return c.json({ error: err.message || "Internal error" }, 500);
     }
-  });
+  );
   return app;
 }
 
@@ -934,38 +1084,6 @@ ${ctx.join("\n\n")}`
 var import_hono2 = require("hono");
 var import_streaming2 = require("hono/streaming");
 
-// src/core/pipeline.ts
-var MODE_SETTINGS = {
-  public: { topK: 6, label: "Context" },
-  private: { topK: 8, label: "Internal Context" }
-};
-async function prepareChat({
-  store,
-  prompts,
-  mode,
-  messages,
-  personaLayer,
-  channelHint,
-  buckets
-}) {
-  const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
-  if (!lastUserMsg) {
-    throw new Error("no user message found in conversation");
-  }
-  const { topK, label } = MODE_SETTINGS[mode];
-  const ctx = await store.query(lastUserMsg.content, topK, buckets ?? defaultBuckets(mode));
-  const persona = personaLayer?.trim() || (mode === "private" ? prompts.privatePersona : prompts.publicPersona);
-  const hint = channelHint?.trim();
-  const system = [
-    prompts.baseSystemRules,
-    persona,
-    ...hint ? [hint] : [],
-    `${label}:
-${ctx.join("\n\n")}`
-  ].join("\n\n");
-  return { system, messages };
-}
-
 // src/middleware/jwt.ts
 var import_jose2 = require("jose");
 function jwtSubject(c) {
@@ -992,7 +1110,7 @@ function createJWTMiddleware(config) {
     }
     throw new Error("JWT configuration missing (JWKS URL or PUBLIC KEY PEM).");
   }
-  return async function requirePrivateJWT2(c, next) {
+  return async function requirePrivateJWT(c, next) {
     const hdr = c.req.header("authorization") ?? "";
     if (!hdr.startsWith("Bearer ")) return c.json({ error: "Unauthorized" }, 401);
     const token = hdr.slice("Bearer ".length);
@@ -1005,41 +1123,24 @@ function createJWTMiddleware(config) {
     }
   };
 }
-var requirePrivateJWT = createJWTMiddleware({});
 
 // src/middleware/ratelimit.ts
-var DEMO_KEYS = ["chatter-api-key-here"];
-function getKeyFromIP(c) {
-  const h = c.req.header("x-forwarded-for");
-  if (h) return h.split(",")[0].trim();
-  return "unknown-ip";
-}
 function createRateLimiter(config) {
-  const buckets = /* @__PURE__ */ new Map();
-  const WINDOW_MS = 6e4;
+  const limiter = createWindowBucketLimiter(6e4);
   const publicLimit = config.rateLimit?.public || 60;
   const privateLimit = config.rateLimit?.private || 120;
-  function allow(key, limit) {
-    const now = Date.now();
-    const b = buckets.get(key) ?? { count: 0, windowStart: now };
-    if (now - b.windowStart >= WINDOW_MS) {
-      b.count = 0;
-      b.windowStart = now;
-    }
-    b.count += 1;
-    buckets.set(key, b);
-    return b.count <= limit;
-  }
+  const trustProxy = config.rateLimit?.trustProxy ?? true;
+  const demoApiKeys = config.rateLimit?.demoApiKeys ?? [];
   return {
     // Public: key is IP only
     // Demo keys get 10x stricter rate limits
     limitPublic() {
       return async (c, next) => {
         const apiKey = c.req.header("x-api-key");
-        const isDemoKey = apiKey ? DEMO_KEYS.includes(apiKey) : false;
-        const key = `pub:${getKeyFromIP(c)}`;
+        const isDemoKey = apiKey ? demoApiKeys.includes(apiKey) : false;
+        const key = `pub:${clientRateLimitKey(c, trustProxy)}`;
         const limit = isDemoKey ? Math.floor(publicLimit / 10) : publicLimit;
-        if (!allow(key, limit)) {
+        if (!limiter.hit(key, limit)) {
           return c.json(
             {
               error: isDemoKey ? "Demo rate limit exceeded. Please use your own API key for higher limits." : "Rate limit exceeded"
@@ -1055,28 +1156,47 @@ function createRateLimiter(config) {
       return async (c, next) => {
         const sub = c.jwtSub;
         const key = `private:${sub ?? "no-sub"}`;
-        if (!allow(key, privateLimit)) return c.json({ error: "Rate limit" }, 429);
+        if (!limiter.hit(key, privateLimit)) return c.json({ error: "Rate limit" }, 429);
         await next();
       };
     }
   };
 }
-var defaultLimiter = createRateLimiter({});
-var limitPublic = defaultLimiter.limitPublic;
-var limitPrivate = defaultLimiter.limitPrivate;
 
 // src/routes/openai.ts
+function apiKeySubject(c) {
+  const sub = c.apiKeySub;
+  return sub && sub.trim().length > 0 ? sub : void 0;
+}
+function payloadSub(payload) {
+  const sub = payload?.sub;
+  return typeof sub === "string" ? sub : void 0;
+}
+var CONVERSATION_ID_PATTERN = /^[A-Za-z0-9_.:-]{1,200}$/;
+function sanitizeConversationId(value) {
+  const trimmed = value?.trim();
+  return trimmed && CONVERSATION_ID_PATTERN.test(trimmed) ? trimmed : void 0;
+}
+function clientConversationId(c, body) {
+  const header = sanitizeConversationId(c.req.header("x-conversation-id"));
+  if (header) return header;
+  const fromBody = body?.conversation_id;
+  return sanitizeConversationId(typeof fromBody === "string" ? fromBody : void 0);
+}
 function errorJson(c, status, message) {
   return c.json(
     { error: { message, type: status === 401 ? "authentication_error" : "invalid_request_error" } },
     status
   );
 }
+function oversizedBodyError(message) {
+  return { error: { message, type: "invalid_request_error" } };
+}
 function openaiRoutes(deps) {
   const { client, store, config, prompts, apiKeyManager } = deps;
   const app = new import_hono2.Hono();
-  const { limitPublic: limitPublic2, limitPrivate: limitPrivate2 } = createRateLimiter(config);
-  const requirePrivateJWT2 = createJWTMiddleware(config);
+  const { limitPublic, limitPrivate } = createRateLimiter(config);
+  const requirePrivateJWT = createJWTMiddleware(config);
   const enablePublic = config.features?.enablePublicChat !== false;
   const enablePrivate = config.features?.enablePrivateChat !== false;
   const serverModel = config.openai.model || DEFAULT_MODEL;
@@ -1091,7 +1211,10 @@ function openaiRoutes(deps) {
     }
     try {
       const result = await apiKeyManager.verify(key);
-      if (result.valid) return await next();
+      if (result.valid) {
+        c.apiKeySub = payloadSub(result.payload);
+        return await next();
+      }
     } catch {
     }
     return errorJson(c, 401, "Invalid API key");
@@ -1118,6 +1241,9 @@ function openaiRoutes(deps) {
     } catch {
       return errorJson(c, 400, "Conversation must contain at least one user message");
     }
+    const sender = jwtSubject(c) ?? apiKeySubject(c);
+    const conversationId = clientConversationId(c, body) ?? crypto.randomUUID();
+    c.header("x-conversation-id", conversationId);
     const id = `chatcmpl-${crypto.randomUUID()}`;
     const created = Math.floor(Date.now() / 1e3);
     if (wantsStream3 === true) {
@@ -1140,6 +1266,8 @@ function openaiRoutes(deps) {
           system,
           messages,
           mode,
+          sender,
+          conversationId,
           temperature,
           model: serverModel
         })) {
@@ -1155,6 +1283,8 @@ function openaiRoutes(deps) {
       system,
       messages,
       mode,
+      sender,
+      conversationId,
       temperature,
       model: serverModel
     });
@@ -1170,13 +1300,15 @@ function openaiRoutes(deps) {
     });
   };
   if (enablePublic) {
+    app.use("/v1/*", chatBodyLimit(config.server?.maxRequestBytes, oversizedBodyError));
     app.use("/v1/*", requireApiKey);
-    app.use("/v1/*", limitPublic2());
+    app.use("/v1/*", limitPublic());
     app.post("/v1/chat/completions", handleChatCompletions("public"));
   }
   if (enablePrivate) {
-    app.use("/api/private/v1/*", requirePrivateJWT2);
-    app.use("/api/private/v1/*", limitPrivate2());
+    app.use("/api/private/v1/*", chatBodyLimit(config.server?.maxRequestBytes, oversizedBodyError));
+    app.use("/api/private/v1/*", requirePrivateJWT);
+    app.use("/api/private/v1/*", limitPrivate());
     app.post("/api/private/v1/chat/completions", handleChatCompletions("private"));
   }
   return app;
@@ -1194,10 +1326,11 @@ function wantsStream(c) {
 function privateRoutes(deps) {
   const { client, store, config, prompts } = deps;
   const app = new import_hono3.Hono();
-  const requirePrivateJWT2 = createJWTMiddleware(config);
-  const { limitPrivate: limitPrivate2 } = createRateLimiter(config);
-  app.use("/api/private/*", requirePrivateJWT2);
-  app.use("/api/private/*", limitPrivate2());
+  const requirePrivateJWT = createJWTMiddleware(config);
+  const { limitPrivate } = createRateLimiter(config);
+  app.use("/api/private/*", chatBodyLimit(config.server?.maxRequestBytes));
+  app.use("/api/private/*", requirePrivateJWT);
+  app.use("/api/private/*", limitPrivate());
   app.post("/api/private/chat", async (c) => {
     const body = await c.req.json().catch(() => ({}));
     const normalized = normalizeChatBody(body);
@@ -1205,9 +1338,10 @@ function privateRoutes(deps) {
       return c.json({ error: normalized.error }, 400);
     }
     const { messages } = normalized;
+    const sender = jwtSubject(c);
     const buckets = await resolveBuckets({
       mode: "private",
-      sender: jwtSubject(c),
+      sender,
       bucketsFor: config.bucketsFor
     });
     let system;
@@ -1226,6 +1360,7 @@ function privateRoutes(deps) {
           system,
           messages,
           mode: "private",
+          sender,
           model
         })) {
           await s.write(`data: ${JSON.stringify({ delta })}
@@ -1235,7 +1370,15 @@ function privateRoutes(deps) {
         await s.write("event: end\ndata: {}\n\n");
       });
     }
-    const out = await answerOnce({ answerFn, client, system, messages, mode: "private", model });
+    const out = await answerOnce({
+      answerFn,
+      client,
+      system,
+      messages,
+      mode: "private",
+      sender,
+      model
+    });
     return c.json({ reply: out.content });
   });
   return app;
@@ -1247,64 +1390,55 @@ var import_streaming4 = require("hono/streaming");
 
 // src/middleware/auth.ts
 function createAuthMiddleware(deps) {
-  const { apiKeyManager } = deps;
+  const { apiKeyManager, logger } = deps;
   return async function requirePublicKey(c, next) {
     const hdr = c.req.header("x-api-key");
     if (hdr?.startsWith("session_")) {
-      console.log(`[Auth] Session key allowed: ${hdr.slice(0, 20)}...`);
+      logger.debug(`[Auth] Session key allowed: ${hdr.slice(0, 20)}...`);
       await next();
       return;
     }
     if (!apiKeyManager) {
-      console.log("[Auth] No API key manager configured");
+      logger.debug("[Auth] No API key manager configured");
       return c.json({ error: "Unauthorized - API key authentication not configured" }, 401);
     }
     if (!hdr) {
-      console.log("[Auth] No API key provided");
+      logger.debug("[Auth] No API key provided");
       return c.json({ error: "Unauthorized - Missing x-api-key header" }, 401);
     }
     try {
       const result = await apiKeyManager.verify(hdr);
       if (result.valid) {
         const payload = result.payload;
-        console.log(`[Auth] JWT API key authorized: ${payload.name || payload.sub || "unknown"}`);
+        logger.debug(`[Auth] JWT API key authorized: ${payload.name || payload.sub || "unknown"}`);
         await next();
         return;
       }
-      console.log(`[Auth] JWT verification failed: ${result.error}`);
+      logger.debug(`[Auth] JWT verification failed: ${result.error}`);
     } catch (error) {
-      console.log(`[Auth] JWT verification error: ${error}`);
+      logger.warn(`[Auth] JWT verification error: ${error}`);
     }
-    console.log(`[Auth] Invalid API key: ${hdr?.slice(0, 20) || "none"}`);
+    logger.debug(`[Auth] Invalid API key: ${hdr?.slice(0, 20) || "none"}`);
     return c.json({ error: "Unauthorized" }, 401);
   };
 }
 
 // src/middleware/referrer.ts
-var DEMO_KEYS2 = ["chatter-api-key-here"];
-function requireReferrer(allowedOrigins) {
+function requireReferrer(allowedOrigins, demoApiKeys = [], logger = createConsoleLogger()) {
   return async (c, next) => {
     const apiKey = c.req.header("x-api-key");
-    const isDemoKey = apiKey && DEMO_KEYS2.includes(apiKey);
+    const isDemoKey = apiKey ? demoApiKeys.includes(apiKey) : false;
     const isSessionKey = apiKey?.startsWith("session_");
     if (isDemoKey || isSessionKey) {
       const referer = c.req.header("referer");
       const origin = c.req.header("origin");
-      console.log(
+      logger.debug(
         `[Referrer] Checking ${isSessionKey ? "session" : "demo"} key: ${apiKey?.slice(0, 20)}...`
       );
-      console.log(`[Referrer] Origin: ${origin || "none"}, Referer: ${referer || "none"}`);
-      const isAllowed = allowedOrigins.some((allowed) => {
-        if (origin === allowed) return true;
-        if (referer) {
-          if (referer === allowed) return true;
-          if (referer.startsWith(`${allowed}/`)) return true;
-          if (referer.startsWith(`${allowed}?`)) return true;
-        }
-        return false;
-      });
+      logger.debug(`[Referrer] Origin: ${origin || "none"}, Referer: ${referer || "none"}`);
+      const isAllowed = matchesAllowedOrigin(origin, referer, allowedOrigins);
       if (!isAllowed) {
-        console.log(`[Referrer] BLOCKED - not from allowed origins: ${allowedOrigins.join(", ")}`);
+        logger.debug(`[Referrer] BLOCKED - not from allowed origins: ${allowedOrigins.join(", ")}`);
         return c.json(
           {
             error: "Demo API keys only work on official demo pages. Please visit our website or use your own API key."
@@ -1312,29 +1446,29 @@ function requireReferrer(allowedOrigins) {
           403
         );
       }
-      console.log("[Referrer] Allowed - origin matches");
+      logger.debug("[Referrer] Allowed - origin matches");
     }
     await next();
   };
 }
 
 // src/middleware/session.ts
-function validateSessionKey() {
+function validateSessionKey(logger = createConsoleLogger()) {
   return async (c, next) => {
     const apiKey = c.req.header("x-api-key");
     if (apiKey?.startsWith("session_")) {
-      console.log(`[Session] Validating key: ${apiKey.slice(0, 20)}...`);
+      logger.debug(`[Session] Validating key: ${apiKey.slice(0, 20)}...`);
       const info = getSessionInfo(apiKey);
       if (info) {
-        console.log(
+        logger.debug(
           `[Session] Key found - requests: ${info.requests}/${info.maxRequests}, expires: ${new Date(info.expiresAt).toISOString()}`
         );
       } else {
-        console.log("[Session] Key not found in session store");
+        logger.debug("[Session] Key not found in session store");
       }
       const isValid = validateSession(apiKey);
       if (!isValid) {
-        console.log("[Session] REJECTED - expired or quota exceeded");
+        logger.debug("[Session] REJECTED - expired or quota exceeded");
         return c.json(
           {
             error: "Session expired or quota exceeded. Please refresh the page to get a new session."
@@ -1342,7 +1476,7 @@ function validateSessionKey() {
           401
         );
       }
-      console.log("[Session] Valid - request count incremented");
+      logger.debug("[Session] Valid - request count incremented");
     }
     await next();
   };
@@ -1356,15 +1490,19 @@ function wantsStream2(c) {
   return acc.includes("text/event-stream");
 }
 function publicRoutes(deps) {
-  const { client, store, config, prompts } = deps;
+  const { client, store, config, prompts, logger } = deps;
   const app = new import_hono4.Hono();
   const requirePublicKey = createAuthMiddleware(deps);
-  const { limitPublic: limitPublic2 } = createRateLimiter(config);
+  const { limitPublic } = createRateLimiter(config);
   const referrerOrigins = config.server?.allowedOrigins?.length ? config.server.allowedOrigins.filter((o) => o !== "*") : [config.bot.publicUrl, "http://localhost:8181", "http://127.0.0.1:8181"];
-  app.use("/api/public/*", validateSessionKey());
+  app.use("/api/public/*", chatBodyLimit(config.server?.maxRequestBytes));
+  app.use("/api/public/*", validateSessionKey(logger));
   app.use("/api/public/*", requirePublicKey);
-  app.use("/api/public/*", requireReferrer(referrerOrigins));
-  app.use("/api/public/*", limitPublic2());
+  app.use(
+    "/api/public/*",
+    requireReferrer(referrerOrigins, config.rateLimit?.demoApiKeys ?? [], logger)
+  );
+  app.use("/api/public/*", limitPublic());
   app.post("/api/public/chat", async (c) => {
     const body = await c.req.json().catch(() => ({}));
     const normalized = normalizeChatBody(body);
@@ -1406,7 +1544,8 @@ function publicRoutes(deps) {
 
 // src/server.ts
 async function createServer(config) {
-  console.log(`\u{1F680} Starting ${config.bot.name}...`);
+  const logger = resolveLogger(config.logger, config.logLevel);
+  logger.info(`\u{1F680} Starting ${config.bot.name}...`);
   const knowledgeDir = config.knowledgeDir || "./config/knowledge";
   const promptsDir = config.promptsDir || "./config/prompts";
   const publicDir = config.publicDir || "./public";
@@ -1425,24 +1564,26 @@ async function createServer(config) {
   });
   const store = new VectorStore(client, {
     databaseClient: db,
-    knowledgeDir
+    knowledgeDir,
+    logger
   });
   await store.build();
-  console.log("\u2705 Knowledge base ready");
+  logger.info("\u2705 Knowledge base ready");
   const prompts = new PromptLoader(promptsDir, config.bot);
   let apiKeyManager;
-  const secret = process.env.CHATTER_SECRET || config.auth?.secret;
+  const secret = config.auth?.secret || process.env.CHATTER_SECRET;
   if (secret) {
     apiKeyManager = new ApiKeyManager(secret);
-    console.log("\u2705 API key manager initialized");
+    logger.info("\u2705 API key manager initialized");
   } else if (config.auth?.apiKeyManager) {
     apiKeyManager = config.auth.apiKeyManager;
-    console.log("\u2705 Custom API key manager configured");
+    logger.info("\u2705 Custom API key manager configured");
   }
   const app = new import_hono5.Hono();
   if (config.server?.cors !== false) {
     app.use("*", cors(config.server?.allowedOrigins));
   }
+  app.use("*", securityHeaders(config));
   app.get("/healthz", (c) => c.text("ok"));
   app.get(
     "/config",
@@ -1460,7 +1601,7 @@ async function createServer(config) {
     try {
       serveStatic = await loadServeStatic();
     } catch (error) {
-      console.error(`\u274C Static assets disabled: ${error.message}`);
+      logger.error(`\u274C Static assets disabled: ${error.message}`);
     }
   }
   if (serveStatic && staticDir) {
@@ -1510,8 +1651,17 @@ async function createServer(config) {
     app.get("/demo/chatbot", serveStatic({ path: `${publicDir}/demo-chatbot.html` }));
     app.get("/demo/react", serveStatic({ path: `${publicDir}/react-demo.html` }));
   }
-  const senders = createSenderRegistry();
-  const deps = { client, store, db, config, prompts, apiKeyManager, senders };
+  const senders = createSenderRegistry(logger);
+  const deps = {
+    client,
+    store,
+    db,
+    config,
+    prompts,
+    apiKeyManager,
+    senders,
+    logger
+  };
   if (enablePublic) {
     app.route("/", publicRoutes(deps));
   }
@@ -1533,13 +1683,13 @@ async function createServer(config) {
       try {
         await channel.start(deps);
         started.push(channel);
-        console.log(`\u2705 Channel "${channel.name}" started`);
+        logger.info(`\u2705 Channel "${channel.name}" started`);
       } catch (error) {
-        console.error(`\u274C Channel "${channel.name}" failed to start:`, error);
+        logger.error(`\u274C Channel "${channel.name}" failed to start:`, error);
       }
     }
   }
-  console.log(`\u2705 ${config.bot.name} server ready`);
+  logger.info(`\u2705 ${config.bot.name} server ready`);
   return Object.assign(app, {
     // Scoped to this call's started channels, not global — two servers in
     // one process each stop only their own. A channel's `stop()` throwing
@@ -1551,7 +1701,7 @@ async function createServer(config) {
           try {
             await channel.stop?.();
           } catch (error) {
-            console.error(`Channel "${channel.name}" failed to stop:`, error);
+            logger.error(`Channel "${channel.name}" failed to stop:`, error);
           }
         })
       );