@alexeiled/pi-model-router 0.6.4 → 0.7.0

package/extensions/config.ts

@@ -3,11 +3,22 @@ import { join } from 'node:path';
 import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
 import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
 import { getAgentDir } from '@earendil-works/pi-coding-agent';
-import { DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS } from './constants';
+import {
+  DEFAULT_CONTEXT_WINDOW,
+  DEFAULT_JEV_CONTEXT,
+  DEFAULT_JEV_RETRY,
+  DEFAULT_MAX_TOKENS,
+  MAX_JEV_ATTEMPTS,
+  MAX_JEV_BACKOFF_MS,
+  MAX_JEV_CONTEXT_TURNS,
+  MAX_JEV_STATE_TOKENS,
+} from './constants';
 import type {
   ClassifierConfig,
   ConfigLoadResult,
   JevConfig,
+  JevContextConfig,
+  JevRetryConfig,
   ModelDefinition,
   ParsedConfigFile,
   RawRouterConfig,
@@ -135,9 +146,18 @@ export const mergeConfig = (
   const overrideModels = isObjectRecord(override.models) ? override.models : {};
   const mergedModels = { ...baseModels, ...overrideModels };
 
+  const mergedJev = mergeRawValue(base.jev, override.jev);
+  const nestedJev = (key: 'context' | 'retry') =>
+    mergeRawValue(
+      isObjectRecord(base.jev) ? base.jev[key] : undefined,
+      isObjectRecord(override.jev) ? override.jev[key] : undefined,
+    );
+  const jev = isObjectRecord(mergedJev)
+    ? { ...mergedJev, context: nestedJev('context'), retry: nestedJev('retry') }
+    : mergedJev;
   return {
     ui: mergeRawValue(base.ui, override.ui),
-    jev: mergeRawValue(base.jev, override.jev),
+    jev,
     debug: override.debug ?? base.debug,
     classifierModel: override.classifierModel ?? base.classifierModel,
     phaseBias: override.phaseBias ?? base.phaseBias,
@@ -385,7 +405,8 @@ export const DEFAULT_JEV_CONFIG = {
   model: 'jev-1.13.0',
   timeoutMs: 1500,
   confidenceThreshold: 0.65,
-  maxStateChars: 12000,
+  probabilityThreshold: 0.8,
+  maxStateTokens: 3000,
   mode: 'advisory',
 } as const;
 
@@ -405,6 +426,55 @@ export const isJevEndpoint = (value: unknown): value is string => {
   }
 };
 
+const normalizeJevContext = (raw: unknown): JevContextConfig | undefined => {
+  if (raw === undefined) return { ...DEFAULT_JEV_CONTEXT };
+  if (
+    !isObjectRecord(raw) ||
+    Object.keys(raw).some((key) => !Object.hasOwn(DEFAULT_JEV_CONTEXT, key))
+  )
+    return undefined;
+  const context = { ...DEFAULT_JEV_CONTEXT, ...raw };
+  if (
+    typeof context.previousTurns !== 'number' ||
+    !Number.isSafeInteger(context.previousTurns) ||
+    context.previousTurns < 0 ||
+    context.previousTurns > MAX_JEV_CONTEXT_TURNS ||
+    typeof context.maxHistoryTokens !== 'number' ||
+    !Number.isInteger(context.maxHistoryTokens) ||
+    context.maxHistoryTokens < 0 ||
+    context.maxHistoryTokens > MAX_JEV_STATE_TOKENS ||
+    typeof context.maxToolTokens !== 'number' ||
+    !Number.isInteger(context.maxToolTokens) ||
+    context.maxToolTokens < 0 ||
+    context.maxToolTokens > MAX_JEV_STATE_TOKENS ||
+    !['none', 'last', 'last-error'].includes(context.toolResults)
+  )
+    return undefined;
+  return context;
+};
+
+const normalizeJevRetry = (raw: unknown): JevRetryConfig | undefined => {
+  if (raw === undefined) return { ...DEFAULT_JEV_RETRY };
+  if (
+    !isObjectRecord(raw) ||
+    Object.keys(raw).some((key) => !Object.hasOwn(DEFAULT_JEV_RETRY, key))
+  )
+    return undefined;
+  const retry = { ...DEFAULT_JEV_RETRY, ...raw };
+  if (
+    typeof retry.maxAttempts !== 'number' ||
+    !Number.isSafeInteger(retry.maxAttempts) ||
+    retry.maxAttempts < 1 ||
+    retry.maxAttempts > MAX_JEV_ATTEMPTS ||
+    typeof retry.backoffMs !== 'number' ||
+    !Number.isSafeInteger(retry.backoffMs) ||
+    retry.backoffMs < 0 ||
+    retry.backoffMs > MAX_JEV_BACKOFF_MS
+  )
+    return undefined;
+  return retry;
+};
+
 export const normalizeJevConfig = (
   raw: unknown,
   warnings: string[],
@@ -416,6 +486,10 @@ export const normalizeJevConfig = (
   };
   if (!isObjectRecord(raw)) return invalid();
   const value: Record<string, unknown> = { ...DEFAULT_JEV_CONFIG, ...raw };
+  const context = normalizeJevContext(value.context);
+  if (!context) return invalid();
+  const retry = normalizeJevRetry(value.retry);
+  if (!retry) return invalid();
   if (
     (value.enabled !== undefined && typeof value.enabled !== 'boolean') ||
     !isJevEndpoint(value.endpoint) ||
@@ -429,10 +503,14 @@ export const normalizeJevConfig = (
     !Number.isFinite(value.confidenceThreshold) ||
     value.confidenceThreshold < 0 ||
     value.confidenceThreshold > 1 ||
-    typeof value.maxStateChars !== 'number' ||
-    !Number.isInteger(value.maxStateChars) ||
-    value.maxStateChars < 1 ||
-    value.maxStateChars > 12000 ||
+    typeof value.probabilityThreshold !== 'number' ||
+    !Number.isFinite(value.probabilityThreshold) ||
+    value.probabilityThreshold <= 0 ||
+    value.probabilityThreshold > 1 ||
+    typeof value.maxStateTokens !== 'number' ||
+    !Number.isInteger(value.maxStateTokens) ||
+    value.maxStateTokens < 1 ||
+    value.maxStateTokens > MAX_JEV_STATE_TOKENS ||
     value.mode !== 'advisory' ||
     (value.apiKey !== undefined &&
       (typeof value.apiKey !== 'string' || /[\r\n]/.test(value.apiKey)))
@@ -449,7 +527,10 @@ export const normalizeJevConfig = (
     model: value.model,
     timeoutMs: value.timeoutMs,
     confidenceThreshold: value.confidenceThreshold,
-    maxStateChars: value.maxStateChars,
+    probabilityThreshold: value.probabilityThreshold,
+    maxStateTokens: value.maxStateTokens,
+    context,
+    retry,
     mode: 'advisory',
   };
 };
@@ -597,7 +678,17 @@ export const normalizeConfig = (raw: RawRouterConfig): ConfigLoadResult => {
             'classifierModel has an invalid thinking level. Ignored.',
           );
         }
-        classifierModel = { model: resolved.canonicalRef, thinking };
+        const timeoutMs =
+          typeof rawClassifier.timeoutMs === 'number' &&
+          Number.isFinite(rawClassifier.timeoutMs) &&
+          rawClassifier.timeoutMs > 0 &&
+          rawClassifier.timeoutMs <= MAX_TIMER_DELAY_MS
+            ? rawClassifier.timeoutMs
+            : undefined;
+        if (rawClassifier.timeoutMs !== undefined && timeoutMs === undefined) {
+          warnings.push('classifierModel has an invalid timeoutMs. Ignored.');
+        }
+        classifierModel = { model: resolved.canonicalRef, thinking, timeoutMs };
       } catch {
         warnings.push('Invalid classifierModel model reference. Ignored.');
       }

package/extensions/constants.ts

@@ -1,3 +1,20 @@
 export const MAX_DEBUG_HISTORY = 50;
+// Bound JSON metadata as well as text; expand only with measured long-dialogue needs.
+export const MAX_JEV_CONTEXT_TURNS = 20;
+export const MAX_JEV_STATE_TOKENS = 24_000;
+export const MAX_JEV_ESTIMATED_REQUEST_TOKENS = 28_000;
+export const DEFAULT_JEV_CONTEXT = {
+  previousTurns: 2,
+  maxHistoryTokens: 500,
+  toolResults: 'last-error',
+  maxToolTokens: 250,
+} as const;
+/** One retry of a documented transient status; the total budget stays `jev.timeoutMs`. */
+export const DEFAULT_JEV_RETRY = { maxAttempts: 2, backoffMs: 400 } as const;
+export const MAX_JEV_ATTEMPTS = 5;
+export const MAX_JEV_BACKOFF_MS = 60_000;
+export const DEFAULT_CLASSIFIER_TIMEOUT_MS = 10_000;
+/** Runtime-only per-turn caches: continuations and advised decisions. */
+export const MAX_TURN_CACHE_ENTRIES = 16;
 export const DEFAULT_CONTEXT_WINDOW = 128_000;
 export const DEFAULT_MAX_TOKENS = 16_384;

package/extensions/context.ts

@@ -1,4 +1,11 @@
 import type { Context, Message } from '@earendil-works/pi-ai';
+import { DEFAULT_JEV_CONTEXT } from './constants';
+import type {
+  JevContextConfig,
+  JevContextMetrics,
+  JevContextState,
+  JevTextExcerpt,
+} from './types';
 
 export const extractTextFromContent = (
   content: string | Message['content'],
@@ -82,6 +89,184 @@ export const getBoundedRecentContext = (
     .join('\n\n');
 };
 
+const textOnly = (message: Message): string =>
+  typeof message.content === 'string'
+    ? message.content
+    : message.content
+        .filter((part) => part.type === 'text')
+        .map((part) => part.text)
+        .join('\n');
+
+const utf8 = new TextEncoder();
+
+/** Conservative Jev preflight estimate; TypeSafe does not publish its tokenizer. */
+export const estimateJevTextTokens = (text: string): number => {
+  let ascii = 0;
+  let nonAsciiBytes = 0;
+  for (const character of text) {
+    if ((character.codePointAt(0) ?? 0) <= 0x7f) ascii += 1;
+    else nonAsciiBytes += utf8.encode(character).length;
+  }
+  return Math.ceil((ascii / 4 + nonAsciiBytes / 2) * 1.1);
+};
+
+/**
+ * Includes fixed headroom for the structured four-choice request envelope. Live
+ * `usage.input_tokens` exceeded the text estimate by 110-135 tokens on ten
+ * structured requests, so the headroom is set well above that gap.
+ */
+export const estimateJevRequestTokens = (serializedRequest: string): number =>
+  400 + estimateJevTextTokens(serializedRequest);
+
+const safePrefix = (text: string, units: number): string =>
+  text.slice(0, units).replace(/[\uD800-\uDBFF]$/u, '');
+const safeSuffix = (text: string, units: number): string =>
+  units <= 0 ? '' : text.slice(-units).replace(/^[\uDC00-\uDFFF]/u, '');
+
+const largestFitting = (
+  text: string,
+  tokenLimit: number,
+  render: (units: number) => string,
+): string => {
+  let low = 0;
+  let high = text.length;
+  let selected = '';
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    const candidate = render(middle);
+    if (estimateJevTextTokens(candidate) <= tokenLimit) {
+      selected = candidate;
+      low = middle + 1;
+    } else high = middle - 1;
+  }
+  return selected;
+};
+
+const excerpt = (text: string, tokenLimit: number): JevTextExcerpt => {
+  if (estimateJevTextTokens(text) <= tokenLimit)
+    return { text, truncated: false };
+  if (tokenLimit < estimateJevTextTokens('…'))
+    return {
+      text: largestFitting(text, tokenLimit, (units) =>
+        safePrefix(text, units),
+      ),
+      truncated: true,
+    };
+  return {
+    text: largestFitting(text, tokenLimit, (units) => {
+      const content = Math.max(0, units - 1);
+      const head = Math.ceil(content / 2);
+      return `${safePrefix(text, head)}…${safeSuffix(text, content - head)}`;
+    }),
+    truncated: true,
+  };
+};
+
+/** Fixed structural selection, not intent scoring. Only selected text reaches Jev. */
+export const buildJevContext = (
+  context: Context,
+  maxTokens: number,
+  options: JevContextConfig = DEFAULT_JEV_CONTEXT,
+): { state: JevContextState; metrics: JevContextMetrics } => {
+  const budget = Number.isFinite(maxTokens)
+    ? Math.max(0, Math.floor(maxTokens))
+    : 0;
+  const latest = context.messages.findLastIndex(
+    (message) => message.role === 'user',
+  );
+  const current = context.messages[latest];
+  const state: JevContextState = {
+    currentRequest: excerpt(current ? textOnly(current) : '', budget),
+    recentDialogue: [],
+    recentToolEvidence: [],
+  };
+  let remaining = budget - estimateJevTextTokens(state.currentRequest.text);
+  const turns: { start: number; end: number }[] = [];
+  let end = latest;
+  for (
+    let index = latest - 1;
+    index >= 0 && turns.length < Math.max(1, options.previousTurns);
+    index--
+  ) {
+    if (context.messages[index]?.role !== 'user') continue;
+    turns.push({ start: index, end });
+    end = index;
+  }
+  const dialogue: { role: 'user' | 'assistant'; text: string; turn: number }[] =
+    [];
+  for (const [turn, bounds] of turns
+    .slice(0, options.previousTurns)
+    .entries()) {
+    const messages = context.messages.slice(bounds.start, bounds.end);
+    const user = messages[0];
+    const answer = messages.findLast(
+      (message) =>
+        message.role === 'assistant' && textOnly(message).trim().length > 0,
+    );
+    // Newest turn first for allocation; render the final payload chronologically.
+    if (answer)
+      dialogue.push({ role: 'assistant', text: textOnly(answer), turn });
+    if (user && textOnly(user).trim())
+      dialogue.push({ role: 'user', text: textOnly(user), turn });
+  }
+  let historyBudget = Math.min(remaining, options.maxHistoryTokens);
+  const includedTurns = new Set<number>();
+  for (const [index, entry] of dialogue.entries()) {
+    const limit = Math.floor(historyBudget / (dialogue.length - index));
+    if (limit < 1) break;
+    const selected = excerpt(entry.text, limit);
+    state.recentDialogue.unshift({ role: entry.role, ...selected });
+    includedTurns.add(entry.turn);
+    const selectedTokens = estimateJevTextTokens(selected.text);
+    historyBudget -= selectedTokens;
+    remaining -= selectedTokens;
+  }
+  const previous = turns[0];
+  if (
+    options.toolResults !== 'none' &&
+    previous &&
+    remaining > 0 &&
+    options.maxToolTokens > 0
+  ) {
+    const tool = context.messages
+      .slice(previous.start, previous.end)
+      .findLast((message) => message.role === 'toolResult');
+    if (
+      tool?.role === 'toolResult' &&
+      (options.toolResults === 'last' || tool.isError === true)
+    ) {
+      const text = textOnly(tool);
+      if (text.trim())
+        state.recentToolEvidence.push({
+          ...excerpt(text, Math.min(remaining, options.maxToolTokens)),
+          isError: tool.isError === true,
+        });
+    }
+  }
+  const all = [
+    state.currentRequest,
+    ...state.recentDialogue,
+    ...state.recentToolEvidence,
+  ];
+  return {
+    state,
+    metrics: {
+      currentRequestTokens: estimateJevTextTokens(state.currentRequest.text),
+      historyTokens: state.recentDialogue.reduce(
+        (sum, entry) => sum + estimateJevTextTokens(entry.text),
+        0,
+      ),
+      toolTokens: state.recentToolEvidence.reduce(
+        (sum, entry) => sum + estimateJevTextTokens(entry.text),
+        0,
+      ),
+      historyTurns: includedTurns.size,
+      toolResults: state.recentToolEvidence.length,
+      truncatedBlocks: all.filter((entry) => entry.truncated).length,
+    },
+  };
+};
+
 export const hasImageAttachment = (context: Context): boolean =>
   context.messages.some(
     (message) =>