teleton 0.8.0 → 0.8.2

package/dist/chunk-3UFPFWYP.js

@@ -0,0 +1,12 @@
+// src/utils/errors.ts
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isHttpError(err) {
+  return typeof err === "object" && err !== null && ("status" in err || "response" in err);
+}
+
+export {
+  getErrorMessage,
+  isHttpError
+};

package/dist/{chunk-NUGDTPE4.js → chunk-4L66JHQE.js}

@@ -239,6 +239,7 @@ var TaskStore = class {
    * Get all parent task results for a dependent task.
    * Uses a single JOIN query instead of N+1 queries.
    */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- result is JSON-parsed dynamic data
   getParentResults(taskId) {
     const rows = this.db.prepare(
       `
@@ -254,7 +255,7 @@ var TaskStore = class {
       let parsedResult;
       try {
         parsedResult = JSON.parse(row.result);
-      } catch (e) {
+      } catch {
         parsedResult = row.result;
       }
       return {

package/dist/{chunk-TVRZJIZX.js → chunk-55SKE6YH.js}

@@ -1,9 +1,9 @@
 import {
   getDatabase
-} from "./chunk-SD4NLLYG.js";
+} from "./chunk-VYKW7FMV.js";
 import {
   createLogger
-} from "./chunk-RCMD3U65.js";
+} from "./chunk-NQ6FZKCE.js";
 
 // src/session/store.ts
 import { randomUUID } from "crypto";
@@ -255,8 +255,8 @@ function shouldResetSession(session, policy) {
   }
   return false;
 }
-function resetSessionWithPolicy(chatId, policy) {
-  const newSession = resetSession(chatId);
+function resetSessionWithPolicy(chatId, _policy) {
+  resetSession(chatId);
   const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   return updateSession(chatId, {
     lastResetDate: today

package/dist/{setup-server-QXED3D2L.js → chunk-57URFK6M.js}

@@ -1,6 +1,6 @@
 import {
   getModelsForProvider
-} from "./chunk-OJCLKU5Z.js";
+} from "./chunk-WFTC3JJW.js";
 import {
   ConfigSchema,
   DealsConfigSchema,
@@ -11,40 +11,26 @@ import {
   isNewWorkspace,
   saveWallet,
   walletExists
-} from "./chunk-JHYZYFZJ.js";
+} from "./chunk-7YKSXOQQ.js";
 import {
   getClaudeCodeApiKey,
   getProviderMetadata,
   getSupportedProviders,
   isClaudeCodeTokenValid,
   validateApiKeyFormat
-} from "./chunk-PHSAHTK4.js";
-import "./chunk-VFA7QMCZ.js";
+} from "./chunk-YOSUPUAJ.js";
 import {
   TELEGRAM_MAX_MESSAGE_LENGTH
-} from "./chunk-IJBWWQE4.js";
+} from "./chunk-C4NKJT2Z.js";
 import {
   fetchWithTimeout
 } from "./chunk-XQUHC3JZ.js";
-import "./chunk-R4YSJ4EY.js";
 import {
   TELETON_ROOT
 } from "./chunk-EYWNOHMJ.js";
 import {
   createLogger
-} from "./chunk-RCMD3U65.js";
-import "./chunk-3RG5ZIWI.js";
-
-// src/webui/setup-server.ts
-import { Hono as Hono2 } from "hono";
-import { serve } from "@hono/node-server";
-import { cors } from "hono/cors";
-import { bodyLimit } from "hono/body-limit";
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join as join3, dirname as dirname2, resolve, relative } from "path";
-import { fileURLToPath } from "url";
-import { exec } from "child_process";
-import { platform } from "os";
+} from "./chunk-NQ6FZKCE.js";
 
 // src/webui/routes/setup.ts
 import { Hono } from "hono";
@@ -110,6 +96,7 @@ var TelegramAuthManager = class {
     const id = randomBytes(16).toString("hex");
     const expiresAt = Date.now() + SESSION_TTL_MS;
     this.session = {
+      type: "phone",
       id,
       client,
       phone,
@@ -122,7 +109,7 @@ var TelegramAuthManager = class {
       createdAt: Date.now(),
       apiId,
       apiHash,
-      timer: setTimeout(() => this.cleanup(), SESSION_TTL_MS)
+      timer: setTimeout(() => void this.cleanup(), SESSION_TTL_MS)
     };
     log.info("Telegram verification code sent");
     return { authSessionId: id, codeDelivery, fragmentUrl, codeLength, expiresAt };
@@ -132,7 +119,7 @@ var TelegramAuthManager = class {
    */
   async verifyCode(authSessionId, code) {
     const session = this.getSession(authSessionId);
-    if (!session) return { status: "expired" };
+    if (!session || session.type !== "phone") return { status: "expired" };
     if (session.codeAttempts >= MAX_CODE_ATTEMPTS) {
       return { status: "too_many_attempts" };
     }
@@ -206,7 +193,7 @@ var TelegramAuthManager = class {
    */
   async resendCode(authSessionId) {
     const session = this.getSession(authSessionId);
-    if (!session || session.state !== "code_sent") return null;
+    if (!session || session.type !== "phone" || session.state !== "code_sent") return null;
     const result = await session.client.invoke(
       new Api.auth.ResendCode({
         phoneNumber: session.phone,
@@ -235,6 +222,111 @@ var TelegramAuthManager = class {
     }
     return { codeDelivery: "sms" };
   }
+  /**
+   * Start QR code authentication session
+   */
+  async startQrSession(apiId, apiHash) {
+    await this.cleanup();
+    const gramLogger = new Logger(LogLevel.NONE);
+    const client = new TelegramClient(new StringSession(""), apiId, apiHash, {
+      connectionRetries: 3,
+      floodSleepThreshold: 0,
+      baseLogger: gramLogger
+    });
+    await client.connect();
+    const result = await client.invoke(
+      new Api.auth.ExportLoginToken({
+        apiId,
+        apiHash,
+        exceptIds: []
+      })
+    );
+    if (!(result instanceof Api.auth.LoginToken)) {
+      await client.disconnect();
+      throw new Error("Unexpected QR auth response");
+    }
+    const id = randomBytes(16).toString("hex");
+    const expiresAt = Date.now() + SESSION_TTL_MS;
+    this.session = {
+      type: "qr",
+      id,
+      client,
+      state: "qr_waiting",
+      passwordAttempts: 0,
+      createdAt: Date.now(),
+      apiId,
+      apiHash,
+      timer: setTimeout(() => void this.cleanup(), SESSION_TTL_MS)
+    };
+    log.info("QR code authentication session started");
+    return {
+      authSessionId: id,
+      token: result.token.toString("base64url"),
+      expires: result.expires,
+      expiresAt
+    };
+  }
+  /**
+   * Refresh QR token / check if scanned
+   */
+  async refreshQrToken(authSessionId) {
+    const session = this.getSession(authSessionId);
+    if (!session || session.type !== "qr") return { status: "expired" };
+    if (session.state === "2fa_required") {
+      return { status: "2fa_required", passwordHint: session.passwordHint };
+    }
+    try {
+      const result = await session.client.invoke(
+        new Api.auth.ExportLoginToken({
+          apiId: session.apiId,
+          apiHash: session.apiHash,
+          exceptIds: []
+        })
+      );
+      if (result instanceof Api.auth.LoginTokenSuccess) {
+        session.state = "authenticated";
+        const user = this.extractUser(result.authorization);
+        await this.saveSession(session);
+        log.info("QR code authentication successful");
+        return { status: "authenticated", user };
+      }
+      if (result instanceof Api.auth.LoginTokenMigrateTo) {
+        await session.client._switchDC(
+          result.dcId
+        );
+        const imported = await session.client.invoke(
+          new Api.auth.ImportLoginToken({ token: result.token })
+        );
+        if (imported instanceof Api.auth.LoginTokenSuccess) {
+          session.state = "authenticated";
+          const user = this.extractUser(imported.authorization);
+          await this.saveSession(session);
+          log.info("QR code authentication successful (after DC migration)");
+          return { status: "authenticated", user };
+        }
+      }
+      if (result instanceof Api.auth.LoginToken) {
+        return {
+          status: "waiting",
+          token: result.token.toString("base64url"),
+          expires: result.expires
+        };
+      }
+      return { status: "waiting" };
+    } catch (err) {
+      const error = err;
+      if (error.errorMessage === "SESSION_PASSWORD_NEEDED") {
+        session.state = "2fa_required";
+        try {
+          const passwordResult = await session.client.invoke(new Api.account.GetPassword());
+          session.passwordHint = passwordResult.hint ?? void 0;
+        } catch {
+        }
+        return { status: "2fa_required", passwordHint: session.passwordHint };
+      }
+      throw err;
+    }
+  }
   /**
    * Cancel and clean up session
    */
@@ -261,7 +353,7 @@ var TelegramAuthManager = class {
   getSession(id) {
     if (!this.session || this.session.id !== id) return null;
     if (Date.now() - this.session.createdAt > SESSION_TTL_MS) {
-      this.cleanup();
+      void this.cleanup();
       return null;
     }
     return this.session;
@@ -361,7 +453,7 @@ function createSetupRoutes() {
   app.get("/detect-claude-code-key", (c) => {
     try {
       const key = getClaudeCodeApiKey();
-      const masked = key.slice(0, 12) + "****" + key.slice(-4);
+      const masked = maskKey(key);
       return c.json({
         success: true,
         data: {
@@ -596,6 +688,50 @@ function createSetupRoutes() {
       );
     }
   });
+  app.post("/telegram/qr-start", async (c) => {
+    try {
+      const body = await c.req.json();
+      if (!body.apiId || !body.apiHash) {
+        return c.json({ success: false, error: "Missing apiId or apiHash" }, 400);
+      }
+      const result = await authManager.startQrSession(body.apiId, body.apiHash);
+      return c.json({ success: true, data: result });
+    } catch (err) {
+      const error = err;
+      if (error.seconds) {
+        return c.json(
+          { success: false, error: `Rate limited. Please wait ${error.seconds} seconds.` },
+          429
+        );
+      }
+      return c.json(
+        { success: false, error: error.errorMessage || error.message || String(err) },
+        500
+      );
+    }
+  });
+  app.post("/telegram/qr-refresh", async (c) => {
+    try {
+      const body = await c.req.json();
+      if (!body.authSessionId) {
+        return c.json({ success: false, error: "Missing authSessionId" }, 400);
+      }
+      const result = await authManager.refreshQrToken(body.authSessionId);
+      return c.json({ success: true, data: result });
+    } catch (err) {
+      const error = err;
+      if (error.seconds) {
+        return c.json(
+          { success: false, error: `Rate limited. Please wait ${error.seconds} seconds.` },
+          429
+        );
+      }
+      return c.json(
+        { success: false, error: error.errorMessage || error.message || String(err) },
+        500
+      );
+    }
+  });
   app.delete("/telegram/session", async (c) => {
     try {
       const body = await c.req.json().catch(() => ({ authSessionId: "" }));
@@ -721,191 +857,6 @@ function createSetupRoutes() {
   return app;
 }
 
-// src/webui/setup-server.ts
-import { randomBytes as randomBytes2 } from "crypto";
-import { readFileSync as readYaml, writeFileSync as writeFileSync3 } from "fs";
-import YAML2 from "yaml";
-var log3 = createLogger("Setup");
-function findWebDist() {
-  const candidates = [resolve("dist/web"), resolve("web")];
-  const __dirname = dirname2(fileURLToPath(import.meta.url));
-  candidates.push(resolve(__dirname, "web"), resolve(__dirname, "../dist/web"));
-  for (const candidate of candidates) {
-    if (existsSync3(join3(candidate, "index.html"))) {
-      return candidate;
-    }
-  }
-  return null;
-}
-function autoOpenBrowser(url) {
-  const os = platform();
-  let cmd;
-  if (os === "darwin") {
-    cmd = `open "${url}"`;
-  } else if (os === "win32") {
-    cmd = `start "${url}"`;
-  } else {
-    cmd = `xdg-open "${url}"`;
-  }
-  exec(cmd, (err) => {
-    if (err) {
-      log3.info(`Open this URL in your browser: ${url}`);
-    }
-  });
-}
-var SetupServer = class {
-  constructor(port = 7777) {
-    this.port = port;
-    this.app = new Hono2();
-    this.launchPromise = new Promise((resolve2) => {
-      this.launchResolve = resolve2;
-    });
-    this.setupMiddleware();
-    this.setupRoutes();
-    this.setupStaticServing();
-  }
-  app;
-  server = null;
-  launchResolve = null;
-  launchPromise;
-  /** Returns a promise that resolves with the auth token when the user clicks "Start Agent" */
-  waitForLaunch() {
-    return this.launchPromise;
-  }
-  setupMiddleware() {
-    this.app.use(
-      "*",
-      cors({
-        origin: [
-          "http://localhost:5173",
-          `http://localhost:${this.port}`,
-          "http://127.0.0.1:5173",
-          `http://127.0.0.1:${this.port}`
-        ],
-        credentials: true,
-        allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
-        allowHeaders: ["Content-Type"],
-        maxAge: 3600
-      })
-    );
-    this.app.use(
-      "*",
-      bodyLimit({
-        maxSize: 2 * 1024 * 1024,
-        onError: (c) => c.json({ success: false, error: "Request body too large (max 2MB)" }, 413)
-      })
-    );
-    this.app.use("*", async (c, next) => {
-      await next();
-      c.res.headers.set("X-Content-Type-Options", "nosniff");
-      c.res.headers.set("X-Frame-Options", "DENY");
-      c.res.headers.set("Referrer-Policy", "strict-origin-when-cross-origin");
-    });
-  }
-  setupRoutes() {
-    this.app.get("/health", (c) => c.json({ status: "ok" }));
-    this.app.route("/api/setup", createSetupRoutes());
-    this.app.get(
-      "/auth/check",
-      (c) => c.json({ success: true, data: { authenticated: false, setup: true } })
-    );
-    this.app.post("/api/setup/launch", async (c) => {
-      try {
-        const token = randomBytes2(32).toString("hex");
-        const configPath = join3(TELETON_ROOT, "config.yaml");
-        const raw = readYaml(configPath, "utf-8");
-        const config = YAML2.parse(raw);
-        config.webui = { ...config.webui || {}, enabled: true, auth_token: token };
-        writeFileSync3(configPath, YAML2.stringify(config), { encoding: "utf-8", mode: 384 });
-        log3.info("Launch requested \u2014 auth token generated");
-        const resolve2 = this.launchResolve;
-        this.launchResolve = null;
-        if (resolve2) {
-          setTimeout(() => resolve2(token), 500);
-        }
-        return c.json({ success: true, data: { token } });
-      } catch (err) {
-        return c.json(
-          { success: false, error: err instanceof Error ? err.message : String(err) },
-          500
-        );
-      }
-    });
-    this.app.onError((err, c) => {
-      log3.error({ err }, "Setup server error");
-      return c.json({ success: false, error: err.message || "Internal server error" }, 500);
-    });
-  }
-  setupStaticServing() {
-    const webDist = findWebDist();
-    if (!webDist) return;
-    const indexHtml = readFileSync2(join3(webDist, "index.html"), "utf-8");
-    const mimeTypes = {
-      js: "application/javascript",
-      css: "text/css",
-      svg: "image/svg+xml",
-      png: "image/png",
-      jpg: "image/jpeg",
-      jpeg: "image/jpeg",
-      ico: "image/x-icon",
-      json: "application/json",
-      woff2: "font/woff2",
-      woff: "font/woff"
-    };
-    this.app.get("*", (c) => {
-      const filePath = resolve(join3(webDist, c.req.path));
-      const rel = relative(webDist, filePath);
-      if (rel.startsWith("..") || resolve(filePath) !== filePath) {
-        return c.html(indexHtml);
-      }
-      try {
-        const content = readFileSync2(filePath);
-        const ext = filePath.split(".").pop() || "";
-        if (mimeTypes[ext]) {
-          const immutable = c.req.path.startsWith("/assets/");
-          return c.body(content, 200, {
-            "Content-Type": mimeTypes[ext],
-            "Cache-Control": immutable ? "public, max-age=31536000, immutable" : "public, max-age=3600"
-          });
-        }
-      } catch {
-      }
-      return c.html(indexHtml);
-    });
-  }
-  async start() {
-    return new Promise((resolve2, reject) => {
-      try {
-        this.server = serve(
-          {
-            fetch: this.app.fetch,
-            hostname: "127.0.0.1",
-            port: this.port
-          },
-          () => {
-            const url = `http://localhost:${this.port}/setup`;
-            log3.info(`Setup wizard: ${url}`);
-            autoOpenBrowser(url);
-            resolve2();
-          }
-        );
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-  async stop() {
-    if (this.server) {
-      return new Promise((resolve2) => {
-        this.server.closeAllConnections();
-        this.server.close(() => {
-          log3.info("Setup server stopped");
-          resolve2();
-        });
-      });
-    }
-  }
-};
 export {
-  SetupServer
+  createSetupRoutes
 };

package/dist/chunk-5SEMA47R.js

@@ -0,0 +1,75 @@
+import {
+  createLogger
+} from "./chunk-NQ6FZKCE.js";
+
+// src/api/tls.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { createHash, X509Certificate } from "crypto";
+import { generate } from "selfsigned";
+var log = createLogger("TLS");
+function computeFingerprint(certPem) {
+  const x509 = new X509Certificate(certPem);
+  const der = x509.raw;
+  return createHash("sha256").update(der).digest("hex");
+}
+function isCertValid(certPem) {
+  try {
+    const x509 = new X509Certificate(certPem);
+    const now = /* @__PURE__ */ new Date();
+    return now >= new Date(x509.validFrom) && now <= new Date(x509.validTo);
+  } catch {
+    return false;
+  }
+}
+async function ensureTlsCert(dataDir) {
+  const certPath = join(dataDir, "api-cert.pem");
+  const keyPath = join(dataDir, "api-key.pem");
+  if (existsSync(certPath) && existsSync(keyPath)) {
+    const cert = readFileSync(certPath, "utf-8");
+    const key = readFileSync(keyPath, "utf-8");
+    if (isCertValid(cert)) {
+      const fingerprint2 = computeFingerprint(cert);
+      log.info("Loaded existing TLS certificate");
+      return { cert, key, fingerprint: fingerprint2 };
+    }
+    log.warn("Existing TLS certificate is expired, regenerating");
+  }
+  log.info("Generating self-signed TLS certificate");
+  const notBeforeDate = /* @__PURE__ */ new Date();
+  const notAfterDate = /* @__PURE__ */ new Date();
+  notAfterDate.setFullYear(notAfterDate.getFullYear() + 2);
+  const pems = await generate([{ name: "commonName", value: "teleton-api" }], {
+    keySize: 2048,
+    algorithm: "sha256",
+    notBeforeDate,
+    notAfterDate,
+    extensions: [
+      { name: "basicConstraints", cA: false, critical: true },
+      {
+        name: "keyUsage",
+        digitalSignature: true,
+        keyEncipherment: true,
+        critical: true
+      },
+      { name: "extKeyUsage", serverAuth: true },
+      {
+        name: "subjectAltName",
+        altNames: [
+          { type: 2, value: "localhost" },
+          { type: 7, ip: "127.0.0.1" },
+          { type: 7, ip: "::1" }
+        ]
+      }
+    ]
+  });
+  writeFileSync(certPath, pems.cert, { mode: 384 });
+  writeFileSync(keyPath, pems.private, { mode: 384 });
+  const fingerprint = computeFingerprint(pems.cert);
+  log.info(`TLS certificate generated (fingerprint: ${fingerprint.slice(0, 16)}...)`);
+  return { cert: pems.cert, key: pems.private, fingerprint };
+}
+
+export {
+  ensureTlsCert
+};

package/dist/{chunk-JHYZYFZJ.js → chunk-7YKSXOQQ.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-VFA7QMCZ.js";
 import {
   TELEGRAM_MAX_MESSAGE_LENGTH
-} from "./chunk-IJBWWQE4.js";
+} from "./chunk-C4NKJT2Z.js";
 import {
   fetchWithTimeout
 } from "./chunk-XQUHC3JZ.js";
@@ -15,7 +15,7 @@ import {
 } from "./chunk-EYWNOHMJ.js";
 import {
   createLogger
-} from "./chunk-RCMD3U65.js";
+} from "./chunk-NQ6FZKCE.js";
 
 // src/ton/endpoint.ts
 var ENDPOINT_CACHE_TTL_MS = 6e4;
@@ -341,10 +341,23 @@ var _LoggingObject = z.object({
   pretty: z.boolean().default(true).describe("Enable pino-pretty formatting (human-readable, colored output)")
 });
 var LoggingConfigSchema = _LoggingObject.default(_LoggingObject.parse({}));
+var _TonProxyObject = z.object({
+  enabled: z.boolean().default(false).describe("Enable TON Proxy (Tonutils-Proxy) for .ton site access"),
+  port: z.number().min(1).max(65535).default(8080).describe("HTTP proxy port (default: 8080)"),
+  binary_path: z.string().optional().describe("Custom path to tonutils-proxy-cli binary (auto-downloaded if omitted)")
+});
+var TonProxyConfigSchema = _TonProxyObject.default(_TonProxyObject.parse({}));
 var _DevObject = z.object({
   hot_reload: z.boolean().default(false).describe("Enable plugin hot-reload (watches ~/.teleton/plugins/ for changes)")
 });
 var DevConfigSchema = _DevObject.default(_DevObject.parse({}));
+var _ApiObject = z.object({
+  enabled: z.boolean().default(false).describe("Enable HTTPS Management API server"),
+  port: z.number().min(1).max(65535).default(7778).describe("HTTPS server port"),
+  key_hash: z.string().default("").describe("SHA-256 hash of the API key (auto-generated if empty)"),
+  allowed_ips: z.array(z.string()).default([]).describe("IP whitelist (empty = allow all authenticated requests)")
+});
+var ApiConfigSchema = _ApiObject.default(_ApiObject.parse({}));
 var McpServerSchema = z.object({
   command: z.string().optional().describe("Stdio command (e.g. 'npx @modelcontextprotocol/server-filesystem /tmp')"),
   args: z.array(z.string()).optional().describe("Explicit args array (overrides command splitting)"),
@@ -404,6 +417,8 @@ var ConfigSchema = z.object({
   dev: DevConfigSchema,
   tool_rag: ToolRagConfigSchema,
   capabilities: CapabilitiesConfigSchema,
+  api: ApiConfigSchema.optional(),
+  ton_proxy: TonProxyConfigSchema,
   mcp: McpConfigSchema,
   plugins: z.record(z.string(), z.unknown()).default({}).describe("Per-plugin config (key = plugin name with underscores)"),
   cocoon: z.object({

package/dist/{chunk-IJBWWQE4.js → chunk-C4NKJT2Z.js}

@@ -23,6 +23,9 @@ var CONTEXT_MAX_RECENT_MESSAGES = 10;
 var CONTEXT_MAX_RELEVANT_CHUNKS = 5;
 var FEED_MESSAGE_MAX_CHARS = 2e3;
 var HYBRID_SEARCH_MIN_SCORE = 0.15;
+var RECENCY_DECAY_FACTOR = 0.05;
+var RECENCY_WEIGHT = 0.15;
+var EMBEDDING_QUERY_MAX_CHARS = 1e3;
 var CONTEXT_OVERFLOW_SUMMARY_MESSAGES = 15;
 var RATE_LIMIT_MAX_RETRIES = 3;
 var SERVER_ERROR_MAX_RETRIES = 3;
@@ -51,9 +54,12 @@ var ADAPTIVE_CHUNK_RATIO_TRIGGER = 0.1;
 var SESSION_SLUG_RECENT_MESSAGES = 10;
 var SESSION_SLUG_MAX_TOKENS = 50;
 var MASKING_KEEP_RECENT_COUNT = 10;
+var RESULT_TRUNCATION_THRESHOLD = 4e3;
+var RESULT_TRUNCATION_KEEP_CHARS = 500;
 var EMBEDDING_CACHE_EVICTION_RATIO = 0.1;
 var WEB_FETCH_MAX_TEXT_LENGTH = 2e4;
 var WEB_SEARCH_MAX_RESULTS = 10;
+var TOOL_CONCURRENCY_LIMIT = 2;
 var TOOL_RAG_MIN_SCORE = 0.1;
 var TOOL_RAG_VECTOR_WEIGHT = 0.6;
 var TOOL_RAG_KEYWORD_WEIGHT = 0.4;
@@ -83,6 +89,9 @@ export {
   CONTEXT_MAX_RELEVANT_CHUNKS,
   FEED_MESSAGE_MAX_CHARS,
   HYBRID_SEARCH_MIN_SCORE,
+  RECENCY_DECAY_FACTOR,
+  RECENCY_WEIGHT,
+  EMBEDDING_QUERY_MAX_CHARS,
   CONTEXT_OVERFLOW_SUMMARY_MESSAGES,
   RATE_LIMIT_MAX_RETRIES,
   SERVER_ERROR_MAX_RETRIES,
@@ -111,9 +120,12 @@ export {
   SESSION_SLUG_RECENT_MESSAGES,
   SESSION_SLUG_MAX_TOKENS,
   MASKING_KEEP_RECENT_COUNT,
+  RESULT_TRUNCATION_THRESHOLD,
+  RESULT_TRUNCATION_KEEP_CHARS,
   EMBEDDING_CACHE_EVICTION_RATIO,
   WEB_FETCH_MAX_TEXT_LENGTH,
   WEB_SEARCH_MAX_RESULTS,
+  TOOL_CONCURRENCY_LIMIT,
   TOOL_RAG_MIN_SCORE,
   TOOL_RAG_VECTOR_WEIGHT,
   TOOL_RAG_KEYWORD_WEIGHT