@khanglvm/llm-router 2.3.1 → 2.3.2

package/CHANGELOG.md

@@ -7,6 +7,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.3.2] - 2026-04-17
+
+### Fixed
+- Web UI provider presets now correctly populate the Endpoints field during add-provider setup when the current value is still empty or still on a prior preset default, while preserving any manually entered endpoint or API key values.
+
 ## [2.3.0] - 2026-03-24
 
 ### Added

package/README.md

@@ -18,13 +18,13 @@ llr start    # start the local gateway
 llr ai-help  # agent-oriented setup brief
 ```
 
-1. Open the Web UI and add a provider (API key or OAuth login)
+1. Open the Web UI and add a provider (API key or OAuth login). Built-in provider presets prefill the usual endpoint and starter models.
 2. Create model aliases with routing strategy
 3. Start the gateway and point your tools at the local endpoint
 
 ## What You Can Do
 
-- **Add & manage providers** — connect any OpenAI/Anthropic-compatible API endpoint, test connectivity, auto-discover models
+- **Add & manage providers** — connect any OpenAI/Anthropic-compatible API endpoint, start from built-in provider presets, test connectivity, auto-discover models
 - **Unified endpoint** — one local gateway that accepts both OpenAI and Anthropic request formats
 - **Model aliases with routing** — group models into stable alias names with weighted round-robin, quota-aware balancing, and automatic fallback
 - **Rate limiting** — set request caps per model or across all models over configurable time windows

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@khanglvm/llm-router",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "description": "LLM Router: single gateway endpoint for multi-provider LLMs with unified OpenAI+Anthropic format and seamless fallback",
   "keywords": [
     "llm-router",

package/src/cli/router-module.js

@@ -123,7 +123,7 @@ const WEAK_MASTER_KEY_PATTERN = /(password|changeme|default|secret|token|admin|q
 export const CLOUDFLARE_FREE_SECRET_SIZE_LIMIT_BYTES = 5 * 1024;
 const CLOUDFLARE_FREE_TIER_PATTERN = /\bfree\b/i;
 const CLOUDFLARE_PAID_TIER_PATTERN = /\b(pro|business|enterprise|paid|unbound)\b/i;
-const MODEL_ALIAS_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/;
+const MODEL_ALIAS_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:\-\[\]]*$/;
 const MODEL_ROUTING_STRATEGY_OPTIONS = [
   {
     value: "auto",
@@ -3931,7 +3931,11 @@ function buildFactoryDroidStatusSection(state = {}) {
     ["Settings File", state.settingsFilePath || resolveFactoryDroidSettingsFilePath({})],
     ["Backup File", state.backupFilePath || "(not created)"],
     ["Base URL", state.configuredBaseUrl || "(not set)"],
+    ["Provider", state.configuredProvider || "(not set)"],
     ["Default Model", state.bindings?.defaultModel || "(not set)"],
+    ["Mission Orchestrator", state.bindings?.missionOrchestratorModel || "(not set)"],
+    ["Mission Worker", state.bindings?.missionWorkerModel || "(not set)"],
+    ["Mission Validator", state.bindings?.missionValidatorModel || "(not set)"],
     ["Reasoning Effort", state.bindings?.reasoningEffort || "(not set)"],
     ["Error", state.error || "(none)"]
   ]);
@@ -6646,10 +6650,23 @@ async function doSetFactoryDroidRouting(context) {
   }
 
   const existingBindings = existingState.bindings || {};
+  const resolvedDefaultModel = String(readArg(args, ["default-model", "defaultModel"], undefined) !== undefined
+    ? readArg(args, ["default-model", "defaultModel"], "")
+    : (existingBindings.defaultModel || pickDefaultManagedRoute(config) || "")).trim();
+  const legacyMissionModel = String(readArg(args, ["mission-model", "missionModel"], undefined) !== undefined
+    ? readArg(args, ["mission-model", "missionModel"], "")
+    : "").trim();
   const bindings = {
-    defaultModel: String(readArg(args, ["default-model", "defaultModel"], undefined) !== undefined
-      ? readArg(args, ["default-model", "defaultModel"], "")
-      : (existingBindings.defaultModel || pickDefaultManagedRoute(config) || "")).trim(),
+    defaultModel: resolvedDefaultModel,
+    missionOrchestratorModel: String(readArg(args, ["mission-orchestrator-model", "missionOrchestratorModel"], undefined) !== undefined
+      ? readArg(args, ["mission-orchestrator-model", "missionOrchestratorModel"], "")
+      : (existingBindings.missionOrchestratorModel || legacyMissionModel || resolvedDefaultModel || "")).trim(),
+    missionWorkerModel: String(readArg(args, ["mission-worker-model", "missionWorkerModel"], undefined) !== undefined
+      ? readArg(args, ["mission-worker-model", "missionWorkerModel"], "")
+      : (existingBindings.missionWorkerModel || legacyMissionModel || resolvedDefaultModel || "")).trim(),
+    missionValidatorModel: String(readArg(args, ["mission-validator-model", "missionValidatorModel"], undefined) !== undefined
+      ? readArg(args, ["mission-validator-model", "missionValidatorModel"], "")
+      : (existingBindings.missionValidatorModel || legacyMissionModel || resolvedDefaultModel || "")).trim(),
     reasoningEffort: normalizeFactoryDroidReasoningEffort(
       readArg(args, ["reasoning-effort", "reasoningEffort"], undefined) !== undefined
         ? readArg(args, ["reasoning-effort", "reasoningEffort"], "")
@@ -6674,7 +6691,11 @@ async function doSetFactoryDroidRouting(context) {
         ["Settings File", patchResult.settingsFilePath],
         ["Backup File", patchResult.backupFilePath],
         ["Base URL", patchResult.baseUrl],
+        ["Provider", patchResult.configuredProvider || "generic-chat-completion-api"],
         ["Default Model", patchResult.bindings?.defaultModel || "(not set)"],
+        ["Mission Orchestrator", patchResult.bindings?.missionOrchestratorModel || "(not set)"],
+        ["Mission Worker", patchResult.bindings?.missionWorkerModel || "(not set)"],
+        ["Mission Validator", patchResult.bindings?.missionValidatorModel || "(not set)"],
         ["Reasoning Effort", patchResult.bindings?.reasoningEffort || "(not set)"]
       ]
     )
@@ -9430,6 +9451,8 @@ async function runAiHelpAction(context) {
     "### Factory Droid",
     "- required_gate=patch_gate_factory_droid=ready",
     `- enable/update route: ${CLI_COMMAND} config --operation=set-factory-droid-routing --enabled=true --default-model=<target_model_or_group>`,
+    `- optional mission bindings: --mission-orchestrator-model=<route> --mission-worker-model=<route> --mission-validator-model=<route>`,
+    `- legacy shortcut: --mission-model=<target_model_or_group> sets all three Mission defaults`,
     `- optional reasoning: --reasoning-effort=off|none|low|medium|high`,
     `- disable route: ${CLI_COMMAND} config --operation=set-factory-droid-routing --enabled=false`,
     "",
@@ -10701,6 +10724,10 @@ const routerModule = {
           { name: "master-key-length", required: false, description: "Generated master key length (min 24).", example: "--master-key-length=48" },
           { name: "master-key-prefix", required: false, description: "Generated master key prefix.", example: "--master-key-prefix=gw_" },
           { name: "default-model", required: false, description: `For set-codex-cli-routing / set-factory-droid-routing: managed route binding, or ${CODEX_CLI_INHERIT_MODEL_VALUE} to keep Codex's own model selection.`, example: "--default-model=chat.default" },
+          { name: "mission-model", required: false, description: "Legacy shortcut for set-factory-droid-routing: applies the same managed route binding to all Factory Mission defaults.", example: "--mission-model=chat.deep" },
+          { name: "mission-orchestrator-model", required: false, description: "For set-factory-droid-routing: managed route binding for Factory mission orchestration.", example: "--mission-orchestrator-model=chat.plan" },
+          { name: "mission-worker-model", required: false, description: "For set-factory-droid-routing: managed route binding for Factory mission workers.", example: "--mission-worker-model=chat.build" },
+          { name: "mission-validator-model", required: false, description: "For set-factory-droid-routing: managed route binding for Factory mission validators.", example: "--mission-validator-model=chat.review" },
           { name: "thinking-level", required: false, description: "For set-codex-cli-routing / set-claude-code-routing / set-claude-code-effort-level: reasoning level.", example: "--thinking-level=medium" },
           { name: "reasoning-effort", required: false, description: "For set-factory-droid-routing: reasoning effort level (off, none, low, medium, high).", example: "--reasoning-effort=medium" },
           { name: "factory-droid-settings-file", required: false, description: "Explicit Factory Droid settings.json path for routing/status operations.", example: "--factory-droid-settings-file=~/.factory/settings.json" },
@@ -10775,7 +10802,7 @@ const routerModule = {
           `${CLI_COMMAND} config --operation=set-codex-cli-routing --enabled=true --default-model=chat.default`,
           `${CLI_COMMAND} config --operation=set-claude-code-routing --enabled=true --primary-model=chat.default --default-haiku-model=chat.fast`,
           `${CLI_COMMAND} config --operation=set-claude-code-effort-level --thinking-level=high`,
-          `${CLI_COMMAND} config --operation=set-factory-droid-routing --enabled=true --default-model=chat.default --reasoning-effort=medium`,
+          `${CLI_COMMAND} config --operation=set-factory-droid-routing --enabled=true --default-model=chat.default --mission-orchestrator-model=chat.plan --mission-worker-model=chat.build --mission-validator-model=chat.review --reasoning-effort=medium`,
           `${CLI_COMMAND} config --operation=set-amp-client-routing --enabled=true --amp-client-settings-scope=workspace`,
           `${CLI_COMMAND} config --operation=set-amp-config --patch-amp-client-config=true --amp-client-settings-scope=workspace --amp-client-url=${LOCAL_ROUTER_ORIGIN} --amp-client-api-key=gw_...`,
           `${CLI_COMMAND} config --operation=list-routing`,

package/src/node/coding-tool-config.js

@@ -966,11 +966,16 @@ export async function patchClaudeCodeEffortLevel({
 }
 
 const FACTORY_DROID_ROUTER_MARKER = "_llmRouterManaged";
+const FACTORY_DROID_ROUTER_PROVIDER = "generic-chat-completion-api";
 
 function normalizeFactoryDroidBindings(bindings = {}) {
   const source = bindings && typeof bindings === "object" && !Array.isArray(bindings) ? bindings : {};
+  const legacyMissionModel = normalizeModelBinding(source.missionModel);
   return {
     defaultModel: normalizeModelBinding(source.defaultModel),
+    missionOrchestratorModel: normalizeModelBinding(source.missionOrchestratorModel) || legacyMissionModel,
+    missionWorkerModel: normalizeModelBinding(source.missionWorkerModel) || legacyMissionModel,
+    missionValidatorModel: normalizeModelBinding(source.missionValidatorModel) || legacyMissionModel,
     reasoningEffort: normalizeFactoryDroidReasoningEffort(source.reasoningEffort)
   };
 }
@@ -987,15 +992,95 @@ function findRouterManagedCustomModelIndex(customModels) {
   );
 }
 
+function getRouterManagedCustomModel(customModels) {
+  const routerIndex = findRouterManagedCustomModelIndex(customModels);
+  return routerIndex >= 0 ? customModels[routerIndex] : null;
+}
+
+function stripRouterManagedCustomModels(customModels) {
+  if (!Array.isArray(customModels)) return [];
+  return customModels.filter(
+    (entry) => !(entry && typeof entry === "object" && entry[FACTORY_DROID_ROUTER_MARKER] === true)
+  );
+}
+
+function getNestedObjectValue(source, keys = []) {
+  let current = source;
+  for (const key of keys) {
+    if (!current || typeof current !== "object" || Array.isArray(current) || !(key in current)) {
+      return undefined;
+    }
+    current = current[key];
+  }
+  return current;
+}
+
+function setNestedObjectValue(target, keys = [], value) {
+  if (!target || typeof target !== "object" || Array.isArray(target) || !Array.isArray(keys) || keys.length === 0) {
+    return;
+  }
+
+  let current = target;
+  for (let index = 0; index < keys.length - 1; index += 1) {
+    const key = keys[index];
+    const nextValue = current[key];
+    if (!nextValue || typeof nextValue !== "object" || Array.isArray(nextValue)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+
+  current[keys[keys.length - 1]] = value;
+}
+
+function deleteNestedObjectValue(target, keys = []) {
+  if (!target || typeof target !== "object" || Array.isArray(target) || !Array.isArray(keys) || keys.length === 0) {
+    return;
+  }
+
+  const parents = [];
+  let current = target;
+  for (let index = 0; index < keys.length - 1; index += 1) {
+    const key = keys[index];
+    if (!current[key] || typeof current[key] !== "object" || Array.isArray(current[key])) {
+      return;
+    }
+    parents.push([current, key]);
+    current = current[key];
+  }
+
+  delete current[keys[keys.length - 1]];
+
+  for (let index = parents.length - 1; index >= 0; index -= 1) {
+    const [parent, key] = parents[index];
+    const value = parent[key];
+    if (value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) {
+      delete parent[key];
+      continue;
+    }
+    break;
+  }
+}
+
+function applyNestedBackupValue(target, keys = [], snapshot) {
+  if (snapshot?.exists) {
+    setNestedObjectValue(target, keys, String(snapshot.value || ""));
+    return;
+  }
+  deleteNestedObjectValue(target, keys);
+}
+
 function captureFactoryDroidBackup(config) {
   const customModels = Array.isArray(config?.customModels) ? config.customModels : [];
-  const model = String(config?.model || "").trim();
-  const reasoningEffort = String(config?.reasoningEffort || "").trim();
   return {
     tool: "factory-droid",
-    version: 1,
-    model: { exists: Boolean(model), value: model },
-    reasoningEffort: { exists: Boolean(reasoningEffort), value: reasoningEffort },
+    version: 2,
+    model: getBackupValue(config?.model),
+    sessionDefaultModel: getBackupValue(getNestedObjectValue(config, ["sessionDefaultSettings", "model"])),
+    missionOrchestratorModel: getBackupValue(config?.missionOrchestratorModel),
+    missionWorkerModel: getBackupValue(getNestedObjectValue(config, ["missionModelSettings", "workerModel"])),
+    missionValidationWorkerModel: getBackupValue(getNestedObjectValue(config, ["missionModelSettings", "validationWorkerModel"])),
+    reasoningEffort: getBackupValue(config?.reasoningEffort),
     hadCustomModels: customModels.length > 0
   };
 }
@@ -1005,17 +1090,16 @@ function applyFactoryDroidBackup(config, backup = {}) {
     ? structuredClone(config)
     : {};
 
-  const customModels = Array.isArray(next.customModels) ? [...next.customModels] : [];
-  const routerIndex = findRouterManagedCustomModelIndex(customModels);
-  if (routerIndex >= 0) customModels.splice(routerIndex, 1);
+  const customModels = stripRouterManagedCustomModels(next.customModels);
   if (customModels.length > 0) next.customModels = customModels;
   else delete next.customModels;
 
-  if (backup?.model?.exists) next.model = backup.model.value;
-  else delete next.model;
-
-  if (backup?.reasoningEffort?.exists) next.reasoningEffort = backup.reasoningEffort.value;
-  else delete next.reasoningEffort;
+  applyBackupValue(next, "model", backup?.model);
+  applyNestedBackupValue(next, ["sessionDefaultSettings", "model"], backup?.sessionDefaultModel);
+  applyBackupValue(next, "missionOrchestratorModel", backup?.missionOrchestratorModel);
+  applyNestedBackupValue(next, ["missionModelSettings", "workerModel"], backup?.missionWorkerModel);
+  applyNestedBackupValue(next, ["missionModelSettings", "validationWorkerModel"], backup?.missionValidationWorkerModel);
+  applyBackupValue(next, "reasoningEffort", backup?.reasoningEffort);
 
   return next;
 }
@@ -1060,9 +1144,9 @@ export async function readFactoryDroidRoutingState({
   const settingsState = await readJsonObjectFile(resolvedSettingsPath, `Factory Droid settings file '${resolvedSettingsPath}'`);
   const backupState = await readJsonObjectFile(resolvedBackupPath, `Backup file '${resolvedBackupPath}'`);
   const customModels = Array.isArray(settingsState.data?.customModels) ? settingsState.data.customModels : [];
-  const routerIndex = findRouterManagedCustomModelIndex(customModels);
-  const routerEntry = routerIndex >= 0 ? customModels[routerIndex] : null;
+  const routerEntry = getRouterManagedCustomModel(customModels);
   const configuredBaseUrl = routerEntry ? String(routerEntry.baseUrl || "").trim() : "";
+  const configuredProvider = routerEntry ? String(routerEntry.provider || "").trim() : "";
   const routedViaRouter = Boolean(
     expectedBaseUrl
       && routerEntry
@@ -1077,8 +1161,15 @@ export async function readFactoryDroidRoutingState({
     backupExists: backupState.existed,
     routedViaRouter,
     configuredBaseUrl,
+    configuredProvider,
     bindings: normalizeFactoryDroidBindings({
-      defaultModel: routerEntry?.model || settingsState.data?.model || "",
+      defaultModel: getNestedObjectValue(settingsState.data, ["sessionDefaultSettings", "model"])
+        || settingsState.data?.model
+        || routerEntry?.model
+        || "",
+      missionOrchestratorModel: settingsState.data?.missionOrchestratorModel || "",
+      missionWorkerModel: getNestedObjectValue(settingsState.data, ["missionModelSettings", "workerModel"]) || "",
+      missionValidatorModel: getNestedObjectValue(settingsState.data, ["missionModelSettings", "validationWorkerModel"]) || "",
       reasoningEffort: normalizeFactoryDroidReasoningEffort(settingsState.data?.reasoningEffort)
     })
   };
@@ -1118,26 +1209,47 @@ export async function patchFactoryDroidSettingsFile({
     await writeJsonObjectFile(resolvedBackupPath, backup);
   }
 
-  const customModels = Array.isArray(nextSettings.customModels) ? [...nextSettings.customModels] : [];
-  const routerIndex = findRouterManagedCustomModelIndex(customModels);
+  const customModels = stripRouterManagedCustomModels(nextSettings.customModels);
   const routerEntry = {
     [FACTORY_DROID_ROUTER_MARKER]: true,
-    model: normalizedBindings.defaultModel || "llm-router",
+    model: normalizedBindings.defaultModel
+      || normalizedBindings.missionOrchestratorModel
+      || normalizedBindings.missionWorkerModel
+      || normalizedBindings.missionValidatorModel
+      || "llm-router",
     displayName: "LLM Router",
     baseUrl,
     apiKey: normalizedApiKey,
-    provider: "openai"
+    provider: FACTORY_DROID_ROUTER_PROVIDER
   };
 
-  if (routerIndex >= 0) {
-    customModels[routerIndex] = routerEntry;
-  } else {
-    customModels.push(routerEntry);
-  }
+  customModels.push(routerEntry);
   nextSettings.customModels = customModels;
 
   if (normalizedBindings.defaultModel) {
     nextSettings.model = normalizedBindings.defaultModel;
+    setNestedObjectValue(nextSettings, ["sessionDefaultSettings", "model"], normalizedBindings.defaultModel);
+  } else {
+    delete nextSettings.model;
+    deleteNestedObjectValue(nextSettings, ["sessionDefaultSettings", "model"]);
+  }
+
+  if (normalizedBindings.missionOrchestratorModel) {
+    nextSettings.missionOrchestratorModel = normalizedBindings.missionOrchestratorModel;
+  } else {
+    delete nextSettings.missionOrchestratorModel;
+  }
+
+  if (normalizedBindings.missionWorkerModel) {
+    setNestedObjectValue(nextSettings, ["missionModelSettings", "workerModel"], normalizedBindings.missionWorkerModel);
+  } else {
+    deleteNestedObjectValue(nextSettings, ["missionModelSettings", "workerModel"]);
+  }
+
+  if (normalizedBindings.missionValidatorModel) {
+    setNestedObjectValue(nextSettings, ["missionModelSettings", "validationWorkerModel"], normalizedBindings.missionValidatorModel);
+  } else {
+    deleteNestedObjectValue(nextSettings, ["missionModelSettings", "validationWorkerModel"]);
   }
 
   if (normalizedBindings.reasoningEffort) {
@@ -1152,6 +1264,7 @@ export async function patchFactoryDroidSettingsFile({
     backupFilePath: resolvedBackupPath,
     settingsCreated: !settingsState.existed,
     baseUrl,
+    configuredProvider: FACTORY_DROID_ROUTER_PROVIDER,
     bindings: normalizedBindings
   };
 }

package/src/node/large-request-log.js

@@ -0,0 +1,54 @@
+import os from "node:os";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import {
+  LARGE_REQUEST_LOG_PATH_ENV
+} from "../runtime/handler/large-request-log.js";
+
+export const DEFAULT_LARGE_REQUEST_LOG_FILENAME = ".llm-router.large-requests.jsonl";
+
+function normalizeText(value, fallback = "") {
+  const text = String(value ?? fallback).trim();
+  return text || fallback;
+}
+
+function createEntryId() {
+  return `${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
+}
+
+export function resolveLargeRequestLogPath(configPath = "", explicitPath = "", env = process.env) {
+  const envOverride = String(env?.[LARGE_REQUEST_LOG_PATH_ENV] || "").trim();
+  const override = String(explicitPath || envOverride).trim();
+  if (override) return path.resolve(override);
+
+  const resolvedConfigPath = String(configPath || "").trim();
+  if (resolvedConfigPath) {
+    const absoluteConfigPath = path.resolve(resolvedConfigPath);
+    const configDir = path.dirname(absoluteConfigPath);
+    const configName = path.basename(absoluteConfigPath);
+    const stem = configName
+      .replace(/\.[^.]+$/, "")
+      .replace(/[^A-Za-z0-9._-]+/g, "-")
+      .replace(/-+/g, "-")
+      .replace(/^-+|-+$/g, "");
+    return path.join(configDir, `.${stem || "llm-router"}.large-requests.jsonl`);
+  }
+
+  return path.join(os.homedir(), DEFAULT_LARGE_REQUEST_LOG_FILENAME);
+}
+
+export function createLargeRequestLogEntry(entry = {}) {
+  return {
+    id: normalizeText(entry.id) || createEntryId(),
+    time: normalizeText(entry.time) || new Date().toISOString(),
+    ...entry
+  };
+}
+
+export async function appendLargeRequestLogEntry(filePath, entry) {
+  const targetPath = resolveLargeRequestLogPath("", filePath);
+  const normalized = createLargeRequestLogEntry(entry);
+  await fs.mkdir(path.dirname(targetPath), { recursive: true });
+  await fs.appendFile(targetPath, `${JSON.stringify(normalized)}\n`, { encoding: "utf8", mode: 0o600 });
+  return normalized;
+}

package/src/node/litellm-context-catalog.js

@@ -73,12 +73,24 @@ function extractLiteLlmContextWindow(entry) {
   return null;
 }
 
+function extractLiteLlmCapabilities(entry = {}) {
+  const capabilities = {};
+  let hasAny = false;
+  if (typeof entry.supports_response_schema === "boolean") {
+    capabilities.supportsResponseFormat = entry.supports_response_schema;
+    hasAny = true;
+  }
+  return hasAny ? capabilities : undefined;
+}
+
 function createLiteLlmLookupResult(modelName, entry = {}) {
+  const capabilities = extractLiteLlmCapabilities(entry);
   return {
     model: String(modelName || "").trim(),
     contextWindow: extractLiteLlmContextWindow(entry),
     provider: String(entry?.litellm_provider || "").trim(),
-    mode: String(entry?.mode || "").trim()
+    mode: String(entry?.mode || "").trim(),
+    ...(capabilities ? { capabilities } : {})
   };
 }
 

package/src/node/local-server.js

@@ -11,6 +11,8 @@ import { readConfigFile, getDefaultConfigPath } from "./config-store.js";
 import { FIXED_LOCAL_ROUTER_HOST, FIXED_LOCAL_ROUTER_PORT } from "./local-server-settings.js";
 import { readActivityLogSettings } from "../shared/local-router-defaults.js";
 import { appendActivityLogEntry, resolveActivityLogPath } from "./activity-log.js";
+import { appendLargeRequestLogEntry, resolveLargeRequestLogPath } from "./large-request-log.js";
+import { isLargeRequestLoggingEnabled } from "../runtime/handler/large-request-log.js";
 
 const DEFAULT_CONFIG_RELOAD_DEBOUNCE_MS = 300;
 const MAX_CONFIG_RELOAD_DEBOUNCE_MS = 5000;
@@ -240,6 +242,7 @@ export async function startLocalRouteServer({
   host = FIXED_LOCAL_ROUTER_HOST,
   configPath = getDefaultConfigPath(),
   activityLogPath = "",
+  largeRequestLogPath = "",
   watchConfig = true,
   configReloadDebounceMs = process.env.LLM_ROUTER_CONFIG_RELOAD_DEBOUNCE_MS,
   validateConfig,
@@ -249,6 +252,7 @@ export async function startLocalRouteServer({
 } = {}) {
   const reloadDebounceMs = resolveReloadDebounceMs(configReloadDebounceMs);
   const resolvedActivityLogPath = resolveActivityLogPath(configPath, activityLogPath);
+  const resolvedLargeRequestLogPath = resolveLargeRequestLogPath(configPath, largeRequestLogPath, process.env);
   let activityLogEnabled = true;
   const configStore = createLiveConfigStore({
     configPath,
@@ -278,6 +282,12 @@ export async function startLocalRouteServer({
       }).catch((error) => {
         console.warn(`[llm-router] Failed writing activity log: ${formatError(error)}`);
       });
+    },
+    onLargeRequestLog: (entry) => {
+      if (!isLargeRequestLoggingEnabled(process.env)) return;
+      void appendLargeRequestLogEntry(resolvedLargeRequestLogPath, entry).catch((error) => {
+        console.warn(`[llm-router] Failed writing large request log: ${formatError(error)}`);
+      });
     }
   });