@khanglvm/llm-router 2.0.0-beta.1 → 2.0.0

package/src/node/web-console-ui/dropdown-placement.js

@@ -0,0 +1,153 @@
+import { useLayoutEffect, useState } from "react";
+
+const DEFAULT_VIEWPORT_PADDING = 12;
+
+function isScrollableOverflow(value) {
+  return /auto|scroll|hidden|clip|overlay/.test(String(value || "").toLowerCase());
+}
+
+function intersectRects(baseRect, nextRect) {
+  return {
+    top: Math.max(baseRect.top, nextRect.top),
+    right: Math.min(baseRect.right, nextRect.right),
+    bottom: Math.min(baseRect.bottom, nextRect.bottom),
+    left: Math.max(baseRect.left, nextRect.left)
+  };
+}
+
+export function getClippingAncestors(node) {
+  if (typeof window === "undefined") return [];
+
+  const ancestors = [];
+  let current = node?.parentElement || null;
+
+  while (current && current !== document.body && current !== document.documentElement) {
+    const style = window.getComputedStyle(current);
+    if (
+      isScrollableOverflow(style.overflow)
+      || isScrollableOverflow(style.overflowY)
+      || isScrollableOverflow(style.overflowX)
+    ) {
+      ancestors.push(current);
+    }
+    current = current.parentElement;
+  }
+
+  return ancestors;
+}
+
+export function getDropdownBoundaryRect(node, { viewportPadding = DEFAULT_VIEWPORT_PADDING } = {}) {
+  if (typeof window === "undefined") return null;
+
+  let boundaryRect = {
+    top: viewportPadding,
+    right: window.innerWidth - viewportPadding,
+    bottom: window.innerHeight - viewportPadding,
+    left: viewportPadding
+  };
+
+  for (const ancestor of getClippingAncestors(node)) {
+    boundaryRect = intersectRects(boundaryRect, ancestor.getBoundingClientRect());
+  }
+
+  return boundaryRect;
+}
+
+export function calculateDropdownPlacement({
+  anchorRect,
+  boundaryRect,
+  preferredSide = "bottom",
+  offset = 4,
+  desiredHeight = 288
+} = {}) {
+  if (!anchorRect || !boundaryRect) {
+    return {
+      side: preferredSide === "top" ? "top" : "bottom",
+      maxHeight: desiredHeight
+    };
+  }
+
+  const spaceAbove = Math.max(0, anchorRect.top - boundaryRect.top - offset);
+  const spaceBelow = Math.max(0, boundaryRect.bottom - anchorRect.bottom - offset);
+  const resolvedPreferredSide = preferredSide === "top" ? "top" : "bottom";
+  const side = spaceAbove === spaceBelow
+    ? resolvedPreferredSide
+    : spaceAbove > spaceBelow
+      ? "top"
+      : "bottom";
+  const maxHeight = Math.max(
+    0,
+    Math.min(
+      desiredHeight,
+      side === "top" ? spaceAbove : spaceBelow
+    )
+  );
+
+  return {
+    side,
+    maxHeight
+  };
+}
+
+export function useDropdownPlacement({
+  open = false,
+  anchorRef,
+  preferredSide = "bottom",
+  offset = 4,
+  desiredHeight = 288
+} = {}) {
+  const [placement, setPlacement] = useState(() => ({
+    side: preferredSide === "top" ? "top" : "bottom",
+    maxHeight: desiredHeight
+  }));
+
+  useLayoutEffect(() => {
+    if (!open || typeof window === "undefined") return undefined;
+
+    const anchorNode = anchorRef?.current || null;
+    if (!anchorNode) {
+      setPlacement({
+        side: preferredSide === "top" ? "top" : "bottom",
+        maxHeight: desiredHeight
+      });
+      return undefined;
+    }
+
+    const updatePlacement = () => {
+      setPlacement(calculateDropdownPlacement({
+        anchorRect: anchorNode.getBoundingClientRect(),
+        boundaryRect: getDropdownBoundaryRect(anchorNode),
+        preferredSide,
+        offset,
+        desiredHeight
+      }));
+    };
+
+    updatePlacement();
+
+    const ancestors = getClippingAncestors(anchorNode);
+    window.addEventListener("resize", updatePlacement);
+    for (const ancestor of ancestors) {
+      ancestor.addEventListener("scroll", updatePlacement, { passive: true });
+    }
+
+    let resizeObserver = null;
+    if (typeof ResizeObserver === "function") {
+      resizeObserver = new ResizeObserver(updatePlacement);
+      resizeObserver.observe(anchorNode);
+      for (const ancestor of ancestors) {
+        resizeObserver.observe(ancestor);
+      }
+    }
+
+    return () => {
+      window.removeEventListener("resize", updatePlacement);
+      for (const ancestor of ancestors) {
+        ancestor.removeEventListener("scroll", updatePlacement);
+      }
+      resizeObserver?.disconnect?.();
+    };
+  }, [open, anchorRef, preferredSide, offset, desiredHeight]);
+
+  return placement;
+}

package/src/node/web-console-ui/select-search-utils.js

@@ -6,6 +6,12 @@ export function hasSelectSearchQuery(value) {
   return normalizeSelectSearchText(value).length > 0;
 }
 
+export function shouldShowSelectSearchInput({
+  searchEnabled = true,
+} = {}) {
+  return Boolean(searchEnabled);
+}
+
 export function getSelectSearchKey(event) {
   const key = String(event?.key || "");
   if (!key || key.length !== 1) return "";

package/src/node/web-console-ui/transient-integer-input-utils.js

@@ -0,0 +1,12 @@
+const TRANSIENT_INTEGER_INPUT_PATTERN = /^\d*$/;
+
+export function classifyTransientIntegerInput(rawValue) {
+  const nextValue = String(rawValue ?? "");
+  const accepted = TRANSIENT_INTEGER_INPUT_PATTERN.test(nextValue);
+  return {
+    accepted,
+    draftValue: accepted ? nextValue : "",
+    shouldCommit: accepted && nextValue !== "",
+    commitValue: accepted && nextValue !== "" ? nextValue : ""
+  };
+}

package/src/runtime/balancer.js

@@ -55,6 +55,66 @@ function resolveCandidateWeight(candidate) {
   return Math.floor(parsed);
 }
 
+function resolveCandidateContextWindow(candidate) {
+  const raw = candidate?.contextWindow ?? candidate?.model?.contextWindow;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0) return null;
+  return Math.floor(parsed);
+}
+
+function shouldApplyContextAwareOrdering(route, estimatedRequiredTokens) {
+  if (!Number.isFinite(estimatedRequiredTokens) || estimatedRequiredTokens <= 0) return false;
+  return Boolean(route?.routeStrategy || route?.routeType === "alias");
+}
+
+function partitionEligibleEntriesByContextWindow(eligibleEntries, estimatedRequiredTokens) {
+  if (!Array.isArray(eligibleEntries) || eligibleEntries.length <= 1) {
+    return {
+      prioritizedEntries: [...(eligibleEntries || [])],
+      deferredEntries: []
+    };
+  }
+
+  const fittingKnown = [];
+  const unknownWindow = [];
+  const tooSmallKnown = [];
+
+  for (const entry of eligibleEntries) {
+    const contextWindow = resolveCandidateContextWindow(entry?.candidate);
+    if (!contextWindow) {
+      unknownWindow.push(entry);
+      continue;
+    }
+
+    if (contextWindow >= estimatedRequiredTokens) {
+      fittingKnown.push(entry);
+      continue;
+    }
+
+    tooSmallKnown.push(entry);
+  }
+
+  const prioritizedEntries = [...fittingKnown, ...unknownWindow];
+  if (prioritizedEntries.length === 0) {
+    return {
+      prioritizedEntries: [...tooSmallKnown].sort((left, right) => {
+        const leftWindow = resolveCandidateContextWindow(left?.candidate) || 0;
+        const rightWindow = resolveCandidateContextWindow(right?.candidate) || 0;
+        if (rightWindow !== leftWindow) {
+          return rightWindow - leftWindow;
+        }
+        return sortEntriesByOriginalOrder(left, right);
+      }),
+      deferredEntries: []
+    };
+  }
+
+  return {
+    prioritizedEntries,
+    deferredEntries: tooSmallKnown
+  };
+}
+
 function resolveHealthState(candidateState, now) {
   const openUntil = Math.max(
     normalizeNonNegativeInteger(candidateState?.openUntil),
@@ -229,6 +289,7 @@ export async function rankRouteCandidates({
   stateStore,
   config,
   rateLimitEvaluations,
+  requestContext,
   now = Date.now()
 }) {
   const normalizedStrategy = normalizeStrategyName(strategy || route?.routeStrategy || route?.strategy);
@@ -254,14 +315,30 @@ export async function rankRouteCandidates({
   const ineligibleEntries = entries
     .filter((entry) => !entry.eligible)
     .sort(sortEntriesByOriginalOrder);
+  const estimatedRequiredTokens = normalizeNonNegativeInteger(
+    requestContext?.estimatedRequiredTokens ??
+    requestContext?.requiredTokens ??
+    requestContext?.totalTokensEstimate
+  );
 
   const routeCursor = stateStore
     ? await stateStore.getRouteCursor(resolvedRouteKey)
     : 0;
-  const ranking = rankEligibleEntries(normalizedStrategy, eligibleEntries, routeCursor);
+  const contextAwareGroups = shouldApplyContextAwareOrdering(route, estimatedRequiredTokens)
+    ? partitionEligibleEntriesByContextWindow(eligibleEntries, estimatedRequiredTokens)
+    : {
+        prioritizedEntries: eligibleEntries,
+        deferredEntries: []
+      };
+  const ranking = rankEligibleEntries(
+    normalizedStrategy,
+    contextAwareGroups.prioritizedEntries,
+    routeCursor
+  );
 
   const rankedEntries = [
     ...ranking.orderedEligible,
+    ...contextAwareGroups.deferredEntries,
     ...ineligibleEntries
   ];
 

package/src/runtime/codex-request-transformer.js

@@ -193,10 +193,15 @@ function normalizeMessageRole(role) {
   return 'user';
 }
 
-function normalizeInputMessageContent(content) {
+function getResponsesTextPartTypeForRole(role) {
+  return normalizeMessageRole(role) === 'assistant' ? 'output_text' : 'input_text';
+}
+
+function normalizeInputMessageContent(content, role) {
+  const textPartType = getResponsesTextPartTypeForRole(role);
   if (typeof content === 'string') {
     return content
-      ? [{ type: 'input_text', text: content }]
+      ? [{ type: textPartType, text: content }]
       : [];
   }
 
@@ -208,7 +213,7 @@ function normalizeInputMessageContent(content) {
 
     if ((part.type === 'text' || part.type === 'input_text' || part.type === 'output_text') && typeof part.text === 'string') {
       parts.push({
-        type: 'input_text',
+        type: textPartType,
         text: part.text
       });
       continue;
@@ -284,11 +289,12 @@ function convertMessagesToResponseInput(messages) {
       continue;
     }
 
-    const contentParts = normalizeInputMessageContent(normalizedMessage.content);
+    const normalizedRole = normalizeMessageRole(normalizedMessage.role);
+    const contentParts = normalizeInputMessageContent(normalizedMessage.content, normalizedRole);
     if (contentParts.length > 0) {
       items.push({
         type: 'message',
-        role: normalizeMessageRole(normalizedMessage.role),
+        role: normalizedRole,
         content: contentParts
       });
     } else {
@@ -296,8 +302,11 @@ function convertMessagesToResponseInput(messages) {
       if (fallbackText) {
         items.push({
           type: 'message',
-          role: normalizeMessageRole(normalizedMessage.role),
-          content: [{ type: 'input_text', text: fallbackText }]
+          role: normalizedRole,
+          content: [{
+            type: getResponsesTextPartTypeForRole(normalizedRole),
+            text: fallbackText
+          }]
         });
       }
     }