@remnic/core 1.1.4 → 1.1.6

package/dist/chunk-AKV3HOGZ.js

@@ -0,0 +1,757 @@
+import {
+  buildEvidencePack
+} from "./chunk-74WWN7ZW.js";
+
+// src/explicit-cue-recall.ts
+var DEFAULT_MAX_CHARS = 2400;
+var DEFAULT_MAX_ITEM_CHARS = 1200;
+var DEFAULT_MAX_REFERENCES = 24;
+var REFERENCE_SCAN_TOKEN_FACTOR = 3;
+var TURN_REFERENCE_WINDOW_RADIUS = 0;
+var LEXICAL_CUE_WINDOW_RADIUS = 1;
+var LEXICAL_CUE_SEARCH_LIMIT = 3;
+var LEXICAL_CUE_MAX_TOKENS = 400;
+var LATEST_STATE_CUES = /* @__PURE__ */ new Set([
+  "as of",
+  "currently",
+  "latest",
+  "most recent",
+  "newest",
+  "now",
+  "updated",
+  "changed",
+  "change"
+]);
+var STRUCTURED_PLAN_FIELD_CUES = /* @__PURE__ */ new Set([
+  "accommodation",
+  "attraction",
+  "breakfast",
+  "current city",
+  "dinner",
+  "flight",
+  "flights",
+  "hotel",
+  "lunch",
+  "restaurant",
+  "restaurants",
+  "transportation",
+  "traveler",
+  "travelers"
+]);
+var STRUCTURED_PLAN_DEPENDENCY_CUES = /* @__PURE__ */ new Set([
+  "comparison",
+  "constraint",
+  "constraints",
+  "dependency",
+  "dependencies",
+  "join",
+  "same",
+  "shared"
+]);
+var BENCHMARK_ABILITY_CUES = /* @__PURE__ */ new Map([
+  ["information extraction", "ability=information_extraction"],
+  ["knowledge update", "ability=knowledge_update"],
+  ["multi session reasoning", "ability=multi_session_reasoning"],
+  ["multi-session reasoning", "ability=multi_session_reasoning"],
+  ["instruction following", "ability=instruction_following"]
+]);
+var BENCHMARK_ANCHOR_VALUE_STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "about",
+  "an",
+  "for",
+  "from",
+  "in",
+  "on",
+  "the",
+  "to",
+  "use",
+  "using",
+  "with"
+]);
+var RELATIVE_TEMPORAL_CUES = [
+  "as of",
+  "most recent",
+  "last time",
+  "last week",
+  "last month",
+  "last year",
+  "last session",
+  "last conversation",
+  "next time",
+  "next week",
+  "next month",
+  "next year",
+  "next session",
+  "next conversation",
+  "previous time",
+  "previous week",
+  "previous month",
+  "previous year",
+  "previous session",
+  "previous conversation",
+  "prior time",
+  "prior week",
+  "prior month",
+  "prior year",
+  "prior session",
+  "prior conversation",
+  "today",
+  "yesterday",
+  "tomorrow",
+  "tonight",
+  "earlier",
+  "later",
+  "recently",
+  "previously",
+  "currently",
+  "now",
+  "latest",
+  "newest",
+  "oldest",
+  "earliest",
+  "before",
+  "after",
+  "since",
+  "updated",
+  "changed",
+  "change"
+];
+var SPEAKER_NAME_STOPWORDS = /* @__PURE__ */ new Set([
+  "A",
+  "According",
+  "An",
+  "And",
+  "Are",
+  "As",
+  "At",
+  "Before",
+  "Can",
+  "Compare",
+  "Could",
+  "Did",
+  "Do",
+  "Does",
+  "For",
+  "From",
+  "Had",
+  "Has",
+  "Have",
+  "How",
+  "In",
+  "Is",
+  "It",
+  "Join",
+  "Of",
+  "On",
+  "Or",
+  "Please",
+  "Review",
+  "Step",
+  "Tell",
+  "The",
+  "To",
+  "Turn",
+  "Use",
+  "Was",
+  "Were",
+  "What",
+  "When",
+  "Where",
+  "Which",
+  "Who",
+  "Why",
+  "Will",
+  "Would"
+]);
+var QUESTION_SLOT_STOPWORDS = /* @__PURE__ */ new Set([
+  "answer",
+  "choice",
+  "did",
+  "does",
+  "do",
+  "is",
+  "should",
+  "single",
+  "the",
+  "user",
+  "was",
+  "were"
+]);
+async function buildExplicitCueRecallSection(options) {
+  const engine = options.engine;
+  const query = options.query.trim();
+  const maxChars = normalizePositiveInteger(options.maxChars, DEFAULT_MAX_CHARS);
+  if (!engine || query.length === 0 || maxChars <= 0) {
+    return "";
+  }
+  const maxReferences = normalizePositiveInteger(
+    options.maxReferences,
+    DEFAULT_MAX_REFERENCES
+  );
+  if (maxReferences <= 0) {
+    return "";
+  }
+  const evidenceItems = [];
+  const seenTurns = /* @__PURE__ */ new Set();
+  await collectTurnReferenceEvidence({
+    engine,
+    sessionId: options.sessionId,
+    query,
+    maxReferences,
+    evidenceItems,
+    seenTurns
+  });
+  await collectLexicalCueEvidence({
+    engine,
+    sessionId: options.sessionId,
+    query,
+    maxReferences,
+    includeBenchmarkAnchorCues: options.includeBenchmarkAnchorCues,
+    includeStructuredPlanCues: options.includeStructuredPlanCues,
+    evidenceItems,
+    seenTurns
+  });
+  return buildEvidencePack(evidenceItems, {
+    title: "Explicit Cue Evidence",
+    maxChars,
+    maxItemChars: normalizePositiveInteger(
+      options.maxItemChars,
+      DEFAULT_MAX_ITEM_CHARS
+    )
+  });
+}
+async function collectTurnReferenceEvidence(options) {
+  if (!options.sessionId) {
+    return;
+  }
+  const references = collectExplicitTurnReferences(options.query).slice(
+    0,
+    options.maxReferences
+  );
+  if (references.length === 0) {
+    return;
+  }
+  const windows = /* @__PURE__ */ new Map();
+  for (const reference of references) {
+    for (const center of candidateTurnIndexesForReference(reference)) {
+      if (center < 0) {
+        continue;
+      }
+      const fromTurn = Math.max(0, center - TURN_REFERENCE_WINDOW_RADIUS);
+      const toTurn = center + TURN_REFERENCE_WINDOW_RADIUS;
+      windows.set(`${fromTurn}:${toTurn}`, { fromTurn, toTurn });
+    }
+  }
+  for (const window of [...windows.values()].sort(
+    (left, right) => left.fromTurn - right.fromTurn || left.toTurn - right.toTurn
+  )) {
+    const expanded = await options.engine.expandContext(
+      options.sessionId,
+      window.fromTurn,
+      window.toTurn,
+      2e3
+    );
+    appendExpandedEvidence(
+      options.evidenceItems,
+      options.seenTurns,
+      options.sessionId,
+      expanded
+    );
+  }
+}
+async function collectLexicalCueEvidence(options) {
+  const cues = collectLexicalCues(options.query, {
+    includeBenchmarkAnchorCues: options.includeBenchmarkAnchorCues,
+    includeStructuredPlanCues: options.includeStructuredPlanCues
+  }).slice(0, options.maxReferences);
+  const preferLatest = hasLatestStateIntent(options.query);
+  for (const cue of cues) {
+    const results = sortLexicalCueResults(
+      await options.engine.searchContextFull(
+        cue,
+        LEXICAL_CUE_SEARCH_LIMIT,
+        options.sessionId
+      ),
+      preferLatest
+    );
+    for (const result of results) {
+      const windowRadius = preferLatest ? 0 : LEXICAL_CUE_WINDOW_RADIUS;
+      const fromTurn = Math.max(0, result.turn_index - windowRadius);
+      const toTurn = result.turn_index + windowRadius;
+      const expanded = await options.engine.expandContext(
+        result.session_id,
+        fromTurn,
+        toTurn,
+        LEXICAL_CUE_MAX_TOKENS
+      );
+      if (expanded.length === 0) {
+        appendEvidenceItem(options.evidenceItems, options.seenTurns, {
+          id: `${result.session_id}:${result.turn_index}`,
+          sessionId: result.session_id,
+          turnIndex: result.turn_index,
+          role: result.role,
+          content: result.content,
+          ...typeof result.score === "number" ? { score: result.score } : {}
+        });
+        continue;
+      }
+      appendExpandedEvidence(
+        options.evidenceItems,
+        options.seenTurns,
+        result.session_id,
+        expanded
+      );
+    }
+  }
+}
+function appendExpandedEvidence(evidenceItems, seenTurns, sessionId, expanded) {
+  for (const message of expanded) {
+    appendEvidenceItem(evidenceItems, seenTurns, {
+      id: `${sessionId}:${message.turn_index}`,
+      sessionId,
+      turnIndex: message.turn_index,
+      role: message.role,
+      content: message.content
+    });
+  }
+}
+function appendEvidenceItem(evidenceItems, seenTurns, item) {
+  if (seenTurns.has(item.id)) {
+    return;
+  }
+  seenTurns.add(item.id);
+  evidenceItems.push(item);
+}
+function collectExplicitTurnReferences(query) {
+  const references = /* @__PURE__ */ new Map();
+  const addReference = (value, label) => {
+    const existing = references.get(String(value));
+    references.set(String(value), {
+      number: value,
+      includeDirectTurn: (existing?.includeDirectTurn ?? false) || label === "turn"
+    });
+  };
+  const tokens = tokenizeReferenceQuery(query);
+  for (let index = 0; index < tokens.length; index += 1) {
+    const label = normalizeReferenceLabel(tokens[index]);
+    if (!label) {
+      continue;
+    }
+    const parsed = parseReferenceNumbers(tokens, index + 1);
+    for (const number of parsed.numbers) {
+      addReference(number, label);
+    }
+    index = Math.max(index, parsed.nextIndex - 1);
+  }
+  return [...references.values()].sort((left, right) => left.number - right.number);
+}
+function collectLexicalCues(query, options = {}) {
+  const cues = /* @__PURE__ */ new Set();
+  for (const match of query.matchAll(/\b[A-Za-z][A-Za-z0-9]{0,12}\d+:\d+\b/g)) {
+    cues.add(match[0]);
+  }
+  for (const match of query.matchAll(/\b\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}(?::\d{2})?Z?)?\b/g)) {
+    cues.add(match[0]);
+  }
+  for (const cue of collectTemporalLexicalCues(query)) {
+    cues.add(cue);
+  }
+  for (const cue of collectQuestionSlotCues(query)) {
+    cues.add(cue);
+  }
+  if (options.includeBenchmarkAnchorCues) {
+    for (const cue of collectBenchmarkAnchorCues(query)) {
+      cues.add(cue);
+    }
+  }
+  if (options.includeStructuredPlanCues) {
+    for (const cue of collectStructuredPlanCues(query)) {
+      cues.add(cue);
+    }
+  }
+  for (const match of query.matchAll(/\b(?:session|source|chat|plan|task|event|file|tool)[_-][A-Za-z0-9][A-Za-z0-9_.:-]{0,80}\b/gi)) {
+    cues.add(match[0]);
+  }
+  for (const match of query.matchAll(/\b[A-Z][a-z]{1,30}(?:\s+[A-Z][a-z]{1,30}){0,2}\b/g)) {
+    const value = normalizeSpeakerNameCue(match[0]);
+    if (value) {
+      cues.add(value);
+    }
+  }
+  for (const match of query.matchAll(/\[([A-Za-z0-9][A-Za-z0-9_.:/ -]{1,80})\]/g)) {
+    const value = match[1]?.trim();
+    if (value) {
+      cues.add(value);
+    }
+  }
+  return [...cues].sort((left, right) => left.localeCompare(right));
+}
+function collectQuestionSlotCues(query) {
+  const cues = /* @__PURE__ */ new Set();
+  for (const match of query.matchAll(
+    /\b(?:what|which)\s+([a-z][a-z0-9_-]{2,30})\s+(?:does|do|did|is|are|was|were|should|would|could|can|will)\b/gi
+  )) {
+    const value = match[1]?.toLowerCase();
+    if (value && !QUESTION_SLOT_STOPWORDS.has(value)) {
+      cues.add(value);
+    }
+  }
+  return [...cues].sort((left, right) => left.localeCompare(right));
+}
+function collectBenchmarkAnchorCues(query) {
+  const cues = /* @__PURE__ */ new Set();
+  const normalizedQuery = query.toLowerCase().replace(/\s+/g, " ");
+  for (const [phrase, cue] of BENCHMARK_ABILITY_CUES) {
+    if (containsBoundedPhrase(normalizedQuery, phrase)) {
+      cues.add(cue);
+    }
+  }
+  const tokens = tokenizeAnchorQuery(query);
+  for (let index = 0; index < tokens.length; index += 1) {
+    let prefix = normalizeBenchmarkAnchorPrefix(tokens[index]);
+    if (!prefix) {
+      continue;
+    }
+    let valueIndex = index + 1;
+    if (prefix === "source" && tokens[valueIndex]?.toLowerCase() === "chat") {
+      prefix = "source_chat";
+      valueIndex += 1;
+    }
+    const maybeIdLabel = tokens[valueIndex]?.toLowerCase();
+    if (maybeIdLabel === "id" || maybeIdLabel === "ids") {
+      valueIndex += 1;
+    }
+    let consumedValue = false;
+    for (let currentValueIndex = valueIndex; currentValueIndex < tokens.length; currentValueIndex += 1) {
+      const rawValue = tokens[currentValueIndex];
+      const normalizedValue = rawValue?.toLowerCase();
+      if (!rawValue || normalizeBenchmarkAnchorPrefix(rawValue)) {
+        break;
+      }
+      if (normalizedValue === "and" || normalizedValue === "or") {
+        continue;
+      }
+      if (BENCHMARK_ANCHOR_VALUE_STOPWORDS.has(normalizedValue)) {
+        break;
+      }
+      if (!isBenchmarkAnchorValue(rawValue)) {
+        break;
+      }
+      addBenchmarkAnchorCues(cues, prefix, rawValue);
+      consumedValue = true;
+      index = currentValueIndex;
+    }
+    if (!consumedValue) {
+      continue;
+    }
+  }
+  return [...cues].sort((left, right) => left.localeCompare(right));
+}
+function addBenchmarkAnchorCues(cues, prefix, rawValue) {
+  cues.add(`${prefix}_id=${rawValue}`);
+  cues.add(`${prefix}-${rawValue}`);
+  if (prefix === "source_chat") {
+    cues.add(`chat_id=${rawValue}`);
+  }
+}
+function isBenchmarkAnchorValue(token) {
+  for (const char of token) {
+    if (isAsciiDigitChar(char)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isAsciiDigitChar(char) {
+  const code = char.charCodeAt(0);
+  return code >= 48 && code <= 57;
+}
+function normalizeBenchmarkAnchorPrefix(token) {
+  switch (token?.toLowerCase()) {
+    case "ability":
+    case "chat":
+    case "plan":
+    case "rubric":
+    case "source":
+      return token.toLowerCase();
+    default:
+      return void 0;
+  }
+}
+function tokenizeAnchorQuery(query) {
+  const tokens = [];
+  let current = "";
+  const push = () => {
+    const token = trimTrailingAnchorTokenPunctuation(current);
+    if (token.length > 0) {
+      tokens.push(token);
+    }
+    current = "";
+  };
+  for (const char of query) {
+    if (isAsciiLetterOrDigit(char) || char === "_" || char === "-" || char === "." || char === ":") {
+      current += char;
+      continue;
+    }
+    push();
+  }
+  push();
+  return tokens;
+}
+function trimTrailingAnchorTokenPunctuation(token) {
+  let end = token.length;
+  while (end > 0) {
+    const char = token[end - 1];
+    if (char !== "." && char !== ":" && char !== ";" && char !== "!" && char !== "?") {
+      break;
+    }
+    end -= 1;
+  }
+  return token.slice(0, end);
+}
+function collectStructuredPlanCues(query) {
+  const cues = /* @__PURE__ */ new Set();
+  const normalizedQuery = query.toLowerCase().replace(/\s+/g, " ");
+  for (const cue of STRUCTURED_PLAN_FIELD_CUES) {
+    if (containsBoundedPhrase(normalizedQuery, cue)) {
+      cues.add(cue);
+    }
+  }
+  if (cues.size === 0) {
+    return [];
+  }
+  for (const cue of STRUCTURED_PLAN_DEPENDENCY_CUES) {
+    if (containsBoundedPhrase(normalizedQuery, cue)) {
+      cues.add(cue);
+    }
+  }
+  return [...cues].sort((left, right) => left.localeCompare(right));
+}
+function containsBoundedPhrase(normalizedHaystack, phrase) {
+  let searchFrom = 0;
+  while (searchFrom < normalizedHaystack.length) {
+    const index = normalizedHaystack.indexOf(phrase, searchFrom);
+    if (index < 0) {
+      return false;
+    }
+    const afterIndex = index + phrase.length;
+    if (isTemporalCueBoundary(normalizedHaystack[index - 1]) && isTemporalCueBoundary(normalizedHaystack[afterIndex])) {
+      return true;
+    }
+    searchFrom = afterIndex;
+  }
+  return false;
+}
+function collectTemporalLexicalCues(query) {
+  const cues = /* @__PURE__ */ new Set();
+  const normalizedQuery = query.toLowerCase().replace(/\s+/g, " ");
+  for (const cue of RELATIVE_TEMPORAL_CUES) {
+    if (containsBoundedPhrase(normalizedQuery, cue)) {
+      cues.add(cue);
+    }
+  }
+  return [...cues].sort((left, right) => left.localeCompare(right));
+}
+function hasLatestStateIntent(query) {
+  return collectTemporalLexicalCues(query).some(
+    (cue) => LATEST_STATE_CUES.has(cue)
+  );
+}
+function sortLexicalCueResults(results, preferLatest) {
+  return [...results].sort((left, right) => {
+    if (preferLatest) {
+      const sessionOrder2 = left.session_id.localeCompare(right.session_id);
+      if (sessionOrder2 !== 0) {
+        return sessionOrder2;
+      }
+      const turnOrder = right.turn_index - left.turn_index;
+      if (turnOrder !== 0) {
+        return turnOrder;
+      }
+      return (right.score ?? 0) - (left.score ?? 0);
+    }
+    const scoreDelta = (right.score ?? 0) - (left.score ?? 0);
+    if (scoreDelta !== 0) {
+      return scoreDelta;
+    }
+    const sessionOrder = left.session_id.localeCompare(right.session_id);
+    if (sessionOrder !== 0) {
+      return sessionOrder;
+    }
+    return left.turn_index - right.turn_index;
+  });
+}
+function normalizeSpeakerNameCue(value) {
+  const words = value.trim().split(/\s+/).filter(Boolean);
+  while (words.length > 0 && SPEAKER_NAME_STOPWORDS.has(words[0])) {
+    words.shift();
+  }
+  while (words.length > 0 && SPEAKER_NAME_STOPWORDS.has(words[words.length - 1])) {
+    words.pop();
+  }
+  return words.length > 0 ? words.join(" ") : void 0;
+}
+function isTemporalCueBoundary(char) {
+  if (!char) {
+    return true;
+  }
+  return !isAsciiLetterOrDigit(char);
+}
+function tokenizeReferenceQuery(query) {
+  const tokens = [];
+  let current = "";
+  const flushCurrent = () => {
+    if (current) {
+      tokens.push(current);
+      current = "";
+    }
+  };
+  for (const char of query) {
+    if (isAsciiLetterOrDigit(char)) {
+      current += char;
+      continue;
+    }
+    flushCurrent();
+    if (char === "#" || char === ",") {
+      tokens.push(char);
+    } else if (isReferenceDash(char)) {
+      tokens.push("-");
+    }
+  }
+  flushCurrent();
+  return tokens;
+}
+function parseReferenceNumbers(tokens, startIndex) {
+  const numbers = [];
+  let lastNumber;
+  let pendingRangeStart;
+  let index = startIndex;
+  const scanEnd = Math.min(
+    tokens.length,
+    startIndex + DEFAULT_MAX_REFERENCES * REFERENCE_SCAN_TOKEN_FACTOR
+  );
+  for (; index < scanEnd; index += 1) {
+    const token = tokens[index];
+    const normalized = token.toLowerCase();
+    const value = parseNonNegativeIntegerToken(token);
+    if (value !== void 0) {
+      if (pendingRangeStart !== void 0) {
+        numbers.push(...expandReferenceRange(pendingRangeStart, value));
+        pendingRangeStart = void 0;
+      } else {
+        numbers.push(value);
+      }
+      lastNumber = value;
+      continue;
+    }
+    if (normalized === "#" || normalized === "number" || normalized === ",") {
+      continue;
+    }
+    if (normalized === "-" || normalized === "to" || normalized === "through" || normalized === "thru") {
+      if (lastNumber !== void 0) {
+        if (numbers[numbers.length - 1] === lastNumber) {
+          numbers.pop();
+        }
+        pendingRangeStart = lastNumber;
+      }
+      continue;
+    }
+    if (normalized === "and" && numbers.length > 0) {
+      continue;
+    }
+    if (normalizeReferenceLabel(token)) {
+      break;
+    }
+    break;
+  }
+  if (pendingRangeStart !== void 0) {
+    numbers.push(pendingRangeStart);
+  }
+  return {
+    numbers: [...new Set(numbers)],
+    nextIndex: index
+  };
+}
+function expandReferenceRange(start, end) {
+  const low = Math.min(start, end);
+  const high = Math.max(start, end);
+  if (high - low + 1 > DEFAULT_MAX_REFERENCES) {
+    return [start, end];
+  }
+  const values = [];
+  for (let value = low; value <= high; value += 1) {
+    values.push(value);
+  }
+  return values;
+}
+function normalizeReferenceLabel(token) {
+  const normalized = token?.toLowerCase();
+  switch (normalized) {
+    case "step":
+    case "steps":
+      return "step";
+    case "turn":
+    case "turns":
+      return "turn";
+    case "action":
+    case "actions":
+      return "action";
+    case "observation":
+    case "observations":
+      return "observation";
+    default:
+      return void 0;
+  }
+}
+function candidateTurnIndexesForReference(reference) {
+  const candidates = /* @__PURE__ */ new Set();
+  if (reference.includeDirectTurn) {
+    for (let offset = -1; offset <= 1; offset += 1) {
+      candidates.add(reference.number + offset);
+    }
+  }
+  const pairedBase = reference.number * 2;
+  for (let offset = -2; offset <= 3; offset += 1) {
+    candidates.add(pairedBase + offset);
+  }
+  return [...candidates].sort((left, right) => left - right);
+}
+function parseNonNegativeIntegerToken(token) {
+  if (token.length === 0) {
+    return void 0;
+  }
+  let value = 0;
+  for (const char of token) {
+    const code = char.charCodeAt(0);
+    if (code < 48 || code > 57) {
+      return void 0;
+    }
+    value = value * 10 + (code - 48);
+  }
+  return value;
+}
+function normalizePositiveInteger(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.max(0, Math.floor(value));
+}
+function isAsciiLetterOrDigit(char) {
+  const code = char.charCodeAt(0);
+  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function isReferenceDash(char) {
+  return char === "-" || char === "\u2010" || char === "\u2011" || char === "\u2012" || char === "\u2013" || char === "\u2014" || char === "\u2015";
+}
+
+export {
+  buildExplicitCueRecallSection,
+  collectExplicitTurnReferences,
+  collectLexicalCues,
+  collectQuestionSlotCues,
+  collectBenchmarkAnchorCues,
+  collectStructuredPlanCues,
+  collectTemporalLexicalCues
+};
+//# sourceMappingURL=chunk-AKV3HOGZ.js.map