@iderouter/index-mcp 0.2.0-beta.1

package/src/embedding-failure-penalty.js

@@ -0,0 +1,60 @@
+export function recordEmbeddingFailurePenalty({
+  state = null,
+  model = "",
+  source = "",
+  message = "",
+  nowMs = Date.now(),
+}) {
+  const next = state && typeof state === "object" ? { ...state } : {};
+  const key = String(model || "").trim();
+  if (!key) return next;
+  next[key] = {
+    model: key,
+    source: String(source || "").trim(),
+    message: String(message || "").trim(),
+    failedAt: Number(nowMs || 0),
+  };
+  return next;
+}
+
+export function activeEmbeddingFailurePenalty({
+  state = null,
+  model = "",
+  nowMs = Date.now(),
+  cooldownMs = 0,
+}) {
+  const key = String(model || "").trim();
+  if (!key || !state || typeof state !== "object") return null;
+  const entry = state[key];
+  if (!entry) return null;
+  const failedAt = Number(entry.failedAt || 0);
+  const cooldown = Math.max(0, Number(cooldownMs || 0));
+  if (!failedAt || !cooldown) return null;
+  if (Number(nowMs || 0) - failedAt >= cooldown) return null;
+  return entry;
+}
+
+export function clearEmbeddingFailurePenalty({
+  state = null,
+  model = "",
+}) {
+  const key = String(model || "").trim();
+  if (!key || !state || typeof state !== "object" || !state[key]) return state;
+  const next = { ...state };
+  delete next[key];
+  return next;
+}
+
+export function hasActiveEmbeddingFailurePenalty({
+  state = null,
+  model = "",
+  nowMs = Date.now(),
+  cooldownMs = 0,
+}) {
+  return Boolean(activeEmbeddingFailurePenalty({
+    state,
+    model,
+    nowMs,
+    cooldownMs,
+  }));
+}

package/src/embedding-failure-policy.js

@@ -0,0 +1,52 @@
+export function isEmbeddingAuthenticationError(error) {
+  const message = error instanceof Error ? error.message : String(error || "");
+  const lower = message.toLowerCase();
+  return lower.includes("401 unauthorized") ||
+    lower.includes("invalid token") ||
+    lower.includes("invalid api key") ||
+    lower.includes("incorrect api key");
+}
+
+export function isRetryableEmbeddingOutageError(error) {
+  const message = error instanceof Error ? error.message : String(error || "");
+  const lower = message.toLowerCase();
+  if (isEmbeddingAuthenticationError(message)) return false;
+  return lower.includes("embedding request failed") ||
+    lower.includes("embedding chunk flush timed out") ||
+    lower.includes("service_unavailable") ||
+    lower.includes("request_failed") ||
+    lower.includes("/embeddings");
+}
+
+export function shouldDegradeToCoarseOnEmbeddingFailure({
+  coarseReady = false,
+  priorityFineReady = false,
+  error,
+}) {
+  if (!coarseReady) return false;
+  if (priorityFineReady) return false;
+  return isEmbeddingAuthenticationError(error);
+}
+
+export function shouldDegradeToCoarseFromState({
+  job = null,
+  index = null,
+  error,
+}) {
+  return shouldDegradeToCoarseOnEmbeddingFailure({
+    coarseReady: Boolean(job?.coarseReady || index?.coarseReady),
+    priorityFineReady: Boolean(job?.priorityFineReady || index?.priorityFineReady),
+    error,
+  });
+}
+
+export function shouldDeferSemanticRetryFromState({
+  job = null,
+  index = null,
+  error,
+}) {
+  const coarseReady = Boolean(job?.coarseReady || index?.coarseReady);
+  const priorityFineReady = Boolean(job?.priorityFineReady || index?.priorityFineReady);
+  if (!coarseReady || priorityFineReady) return false;
+  return isRetryableEmbeddingOutageError(error);
+}

package/src/embedding-flush-timeout.js

@@ -0,0 +1,33 @@
+export function embeddingFlushTimeoutMs({
+  source = "",
+  requestTimeoutMs = 0,
+  priorityTimeoutMs = 0,
+  priorityFallbackTimeoutMs = 0,
+}) {
+  const sourceText = String(source || "");
+  const requestMs = Math.max(0, Number(requestTimeoutMs || 0));
+  const priorityMs = Math.max(0, Number(priorityTimeoutMs || 0));
+  const priorityFallbackMs = Math.max(0, Number(priorityFallbackTimeoutMs || 0));
+
+  if (sourceText.startsWith("priority_usable_strategy_fallback")) {
+    return Math.max(
+      Math.min(
+        Math.max(requestMs, priorityFallbackMs),
+        priorityFallbackMs,
+      ),
+      priorityFallbackMs,
+    );
+  }
+
+  if (sourceText.startsWith("priority_usable_strategy")) {
+    return Math.max(
+      Math.min(
+        Math.max(requestMs, priorityMs),
+        Math.max(priorityMs, 24000),
+      ),
+      priorityMs,
+    );
+  }
+
+  return Math.max(requestMs * 2, priorityMs);
+}

package/src/embedding-inflight-status.js

@@ -0,0 +1,18 @@
+export function shouldAnnotateEmbeddingInFlight({
+  jobStatus = "",
+  currentStep = "",
+  totalChunks = 0,
+  embeddedCount = 0,
+  batchStartedAt = "",
+  updatedAt = "",
+  slowThresholdMs = 15000,
+  nowMs = Date.now(),
+}) {
+  if (String(jobStatus || "") !== "indexing") return false;
+  if (!String(currentStep || "").toLowerCase().includes("embedding batch")) return false;
+  if (Number(totalChunks || 0) <= 0) return false;
+  if (Number(embeddedCount || 0) > 0) return false;
+  const startedMs = Date.parse(String(batchStartedAt || updatedAt || ""));
+  if (!Number.isFinite(startedMs) || startedMs <= 0) return false;
+  return nowMs - startedMs >= Math.max(0, Number(slowThresholdMs) || 0);
+}

package/src/embedding-model-policy.js

@@ -0,0 +1,44 @@
+export function choosePreferredPriorityUsableEmbeddingModel(candidates = [], existingIndex = null) {
+  if (existingIndex?.complete === true) return null;
+  const list = Array.isArray(candidates) ? candidates.filter(Boolean) : [];
+  const firstSemanticPreferred = list.find((candidate) => String(candidate || "").trim() === "openai/text-embedding-3-small");
+  return firstSemanticPreferred || list[0] || null;
+}
+
+export function chooseDeferredResumeEmbeddingModel({
+  candidates = [],
+  failedModel = "",
+  cachedHealthModel = "",
+  penalizedModels = [],
+}) {
+  const list = Array.isArray(candidates) ? candidates.filter(Boolean) : [];
+  if (list.length === 0) return "";
+  const failed = String(failedModel || "").trim();
+  const cached = String(cachedHealthModel || "").trim();
+  const penalized = new Set((Array.isArray(penalizedModels) ? penalizedModels : []).filter(Boolean));
+
+  const nonFailed = list.filter((candidate) => candidate !== failed);
+  const nonPenalizedNonFailed = nonFailed.filter((candidate) => !penalized.has(candidate));
+  if (cached && nonPenalizedNonFailed.includes(cached)) return cached;
+  if (nonPenalizedNonFailed.length > 0) return nonPenalizedNonFailed[0];
+
+  const healthyNonFailed = nonFailed;
+  if (cached && healthyNonFailed.includes(cached)) return cached;
+  if (healthyNonFailed.length > 0) return healthyNonFailed[0];
+
+  if (cached && list.includes(cached)) return cached;
+  return list[0] || "";
+}
+
+export function shouldUseResumeFallbackForCoarseDeferred({
+  force = false,
+  existingIndex = null,
+  hasReusableFineVectors = false,
+  resumeFallbackModel = "",
+}) {
+  if (force) return false;
+  if (existingIndex?.complete === true) return false;
+  if (!resumeFallbackModel) return false;
+  if (hasReusableFineVectors) return true;
+  return existingIndex?.complete === false;
+}

package/src/embedding-next-switch.js

@@ -0,0 +1,18 @@
+export function nextProviderSwitchSeconds({
+  currentAttempt = 0,
+  totalAttempts = 0,
+  timeoutMs = 0,
+  batchStartedAt = "",
+  updatedAt = "",
+  nowMs = Date.now(),
+}) {
+  const current = Math.max(0, Number(currentAttempt || 0));
+  const total = Math.max(0, Number(totalAttempts || 0));
+  if (current <= 0 || total <= 1 || current >= total) return 0;
+  const startedMs = Date.parse(String(batchStartedAt || updatedAt || ""));
+  if (!Number.isFinite(startedMs) || startedMs <= 0) return 0;
+  const budgetMs = Math.max(0, Number(timeoutMs || 0));
+  if (!budgetMs) return 0;
+  const remainingMs = budgetMs - (Number(nowMs || 0) - startedMs);
+  return Math.max(0, Math.ceil(remainingMs / 1000));
+}

package/src/embedding-request-status-detail.js

@@ -0,0 +1,25 @@
+export function describeEmbeddingRequestSource(source = "") {
+  const sourceText = String(source || "");
+  if (sourceText.startsWith("priority_usable_strategy_fast_path")) {
+    return "first-semantic fast path";
+  }
+  if (sourceText.startsWith("priority_usable_strategy_selection_timeout_fallback")) {
+    return "selection-timeout fallback";
+  }
+  if (sourceText.startsWith("priority_usable_strategy_fallback")) {
+    return "fallback";
+  }
+  if (sourceText.startsWith("priority_usable_strategy")) {
+    return "priority usable";
+  }
+  if (sourceText.startsWith("previous_failure_fallback_deferred_resume")) {
+    return "deferred resume fallback";
+  }
+  if (sourceText.startsWith("background_fine_post_priority_strategy")) {
+    return "post-priority background";
+  }
+  if (sourceText.startsWith("background_fine_strategy")) {
+    return "background fine";
+  }
+  return "";
+}

package/src/embedding-request-status.js

@@ -0,0 +1,22 @@
+export function resolveEmbeddingAttemptState({
+  defaultModel = "",
+  defaultTimeoutMs = 0,
+  defaultMaxRetries = 0,
+  attemptPlan = [],
+  attemptIndex = -1,
+}) {
+  const attempts = Array.isArray(attemptPlan) ? attemptPlan : [];
+  if (attemptIndex >= 0 && attemptIndex < attempts.length) {
+    const attempt = attempts[attemptIndex] || {};
+    return {
+      model: String(attempt.model || defaultModel || ""),
+      timeoutMs: Number(attempt.timeoutMs || defaultTimeoutMs || 0),
+      maxRetries: Number(attempt.maxRetries ?? defaultMaxRetries ?? 0),
+    };
+  }
+  return {
+    model: String(defaultModel || ""),
+    timeoutMs: Number(defaultTimeoutMs || 0),
+    maxRetries: Number(defaultMaxRetries || 0),
+  };
+}

package/src/embedding-selection-order.js

@@ -0,0 +1,23 @@
+export function shouldPreferPriorityUsableOverCachedHealth({
+  force = false,
+  hasReusableFineVectors = false,
+  priorityUsableModel = "",
+  cachedHealthModel = "",
+  cachedHealthOk = true,
+  cachedHealthLatencyMs = 0,
+  slowThresholdMs = 0,
+}) {
+  if (force) return false;
+  if (hasReusableFineVectors) return false;
+  const preferred = String(priorityUsableModel || "").trim();
+  if (!preferred) return false;
+  const cached = String(cachedHealthModel || "").trim();
+  if (!cached) return true;
+  const healthyCached = cachedHealthOk !== false;
+  const latencyMs = Math.max(0, Number(cachedHealthLatencyMs) || 0);
+  const thresholdMs = Math.max(0, Number(slowThresholdMs) || 0);
+  if (healthyCached && cached !== preferred && thresholdMs > 0 && latencyMs > 0 && latencyMs <= thresholdMs) {
+    return false;
+  }
+  return cached !== preferred;
+}

package/src/fine-run-queue.js

@@ -0,0 +1,14 @@
+export function buildFineRunQueue({
+  priorityReadyFiles,
+  remainingFineFiles,
+}) {
+  const queue = [];
+  const seen = new Set();
+  for (const file of [...(Array.isArray(priorityReadyFiles) ? priorityReadyFiles : []), ...(Array.isArray(remainingFineFiles) ? remainingFineFiles : [])]) {
+    const relativePath = file?.relativePath;
+    if (!relativePath || seen.has(relativePath)) continue;
+    seen.add(relativePath);
+    queue.push(file);
+  }
+  return queue;
+}