wiki-graph-core 0.3.1

package/dist/wikimatch/policy-judge.js

@@ -0,0 +1,430 @@
+import { z } from "zod";
+import {
+  ParsedJsonError,
+  RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE,
+  requestGuaranteedJson
+} from "../guaranteed/index.js";
+import { listCandidateSelectableQids } from "./options.js";
+const policyDecisionSchema = z.object({
+  candidateId: z.string().min(1),
+  decision: z.enum(["continue", "recall", "skip_this_time", "never_recall"]),
+  qid: z.string().nullable().optional()
+}).strict();
+const policyGroupSchema = z.object({
+  decisions: z.array(policyDecisionSchema),
+  groupId: z.string().min(1)
+}).strict();
+const policyResponseSchema = z.object({
+  groups: z.array(policyGroupSchema)
+}).strict();
+async function judgeWikimatchPolicy(options) {
+  try {
+    return await requestGuaranteedJson({
+      messages: buildPolicyMessages(options),
+      parse: (response) => parsePolicyResponse(
+        options.candidates,
+        normalizePolicyResponse(response),
+        options.window.groups
+      ),
+      request: options.request,
+      responseIntentClassifierPrompt: RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE,
+      schema: policyResponseSchema,
+      ...options.maxRetries === void 0 ? {} : { maxRetries: options.maxRetries }
+    });
+  } catch (error) {
+    return {
+      continuations: [],
+      fallback: {
+        issues: [formatFallbackIssue(error)],
+        reason: "guaranteed_json_failed"
+      },
+      mentions: [],
+      policyUpdates: []
+    };
+  }
+}
+function normalizePolicyResponse(response) {
+  return {
+    groups: response.groups.map((group) => ({
+      decisions: group.decisions.map((decision) => ({
+        candidateId: decision.candidateId,
+        decision: decision.decision,
+        ...normalizeDecisionQid(decision.qid)
+      })),
+      groupId: group.groupId
+    }))
+  };
+}
+function normalizeDecisionQid(qid) {
+  const normalized = qid?.trim();
+  return normalized === void 0 || normalized === "" ? {} : { qid: normalized };
+}
+function parsePolicyResponse(candidates, response, groups = inferGroups(candidates)) {
+  const issues = validatePolicyResponse(candidates, response, groups);
+  if (issues.length > 0) {
+    throw new ParsedJsonError(issues);
+  }
+  const candidatesById = createCandidateMap(candidates);
+  const continuations = [];
+  const mentions = [];
+  const policyUpdates = [];
+  for (const group of response.groups) {
+    const continuedCandidateIds = [];
+    for (const decision of group.decisions) {
+      const candidate = candidatesById.get(decision.candidateId);
+      if (decision.decision === "continue") {
+        if (candidate.hasMoreOptions !== true) {
+          policyUpdates.push({
+            candidateId: candidate.id,
+            decision: "skip_this_time",
+            surface: candidate.surface
+          });
+          continue;
+        }
+        continuedCandidateIds.push(candidate.id);
+        continue;
+      }
+      if (decision.decision === "recall") {
+        mentions.push({
+          candidateId: candidate.id,
+          qid: decision.qid,
+          range: candidate.range,
+          surface: candidate.surface
+        });
+        continue;
+      }
+      policyUpdates.push({
+        candidateId: candidate.id,
+        decision: decision.decision,
+        ...decision.qid === void 0 ? {} : { qid: decision.qid },
+        surface: candidate.surface
+      });
+    }
+    if (continuedCandidateIds.length > 0) {
+      continuations.push({
+        candidateIds: continuedCandidateIds,
+        groupId: group.groupId
+      });
+    }
+  }
+  return {
+    continuations,
+    mentions,
+    policyUpdates
+  };
+}
+function validatePolicyResponse(candidates, response, groups = inferGroups(candidates)) {
+  const issues = [];
+  const candidatesById = createCandidateMap(candidates);
+  const groupsById = createGroupMap(groups);
+  const seenGroupIds = /* @__PURE__ */ new Set();
+  const seenCandidateIds = /* @__PURE__ */ new Set();
+  const recalled = [];
+  for (const group of response.groups) {
+    const expectedCandidateIds = groupsById.get(group.groupId);
+    if (expectedCandidateIds === void 0) {
+      issues.push(
+        `Unknown groupId "${group.groupId}". Use exactly these group IDs: ${[
+          ...groupsById.keys()
+        ].join(", ")}.`
+      );
+      continue;
+    }
+    if (seenGroupIds.has(group.groupId)) {
+      issues.push(`Duplicate group result for ${group.groupId}.`);
+      continue;
+    }
+    seenGroupIds.add(group.groupId);
+    for (const decision of group.decisions) {
+      const candidate = candidatesById.get(decision.candidateId);
+      if (candidate === void 0) {
+        issues.push(
+          `Unknown candidateId "${decision.candidateId}". Use only one of: ${[
+            ...candidatesById.keys()
+          ].join(", ")}.`
+        );
+        continue;
+      }
+      if (!expectedCandidateIds.has(decision.candidateId)) {
+        issues.push(
+          `Candidate ${decision.candidateId} does not belong to group ${group.groupId}. Use only candidates from that group: ${[
+            ...expectedCandidateIds
+          ].join(", ")}.`
+        );
+        continue;
+      }
+      if (seenCandidateIds.has(decision.candidateId)) {
+        issues.push(
+          `Duplicate decision for candidate ${decision.candidateId}. Return exactly one decision per candidate at most.`
+        );
+        continue;
+      }
+      seenCandidateIds.add(decision.candidateId);
+      if (decision.decision === "recall") {
+        validateRecallDecision(issues, candidate, decision);
+        recalled.push({ candidate, decision });
+        continue;
+      }
+      if (decision.decision === "continue") {
+        if (decision.qid !== void 0) {
+          issues.push(
+            `Candidate ${candidate.id} uses decision "continue" but includes qid. Continue means this candidate page has no final choice yet.`
+          );
+        }
+        continue;
+      }
+      if (decision.qid !== void 0) {
+        issues.push(
+          `Candidate ${candidate.id} uses decision "${decision.decision}" but includes qid. Include qid only when decision is "recall".`
+        );
+      }
+    }
+  }
+  for (const groupId of groupsById.keys()) {
+    if (!seenGroupIds.has(groupId)) {
+      issues.push(
+        `Missing group result for ${groupId}. Return exactly one result for every input group; use decisions: [] when nothing should be recalled.`
+      );
+    }
+  }
+  for (let leftIndex = 0; leftIndex < recalled.length; leftIndex += 1) {
+    for (let rightIndex = leftIndex + 1; rightIndex < recalled.length; rightIndex += 1) {
+      const left = recalled[leftIndex];
+      const right = recalled[rightIndex];
+      if (rangesOverlap(left.candidate.range, right.candidate.range)) {
+        issues.push(
+          `Decision conflict: candidates ${left.candidate.id} and ${right.candidate.id} both use decision "recall", but their ranges overlap.
+- ${left.candidate.id}: "${left.candidate.surface}" [${left.candidate.range.start}, ${left.candidate.range.end})
+- ${right.candidate.id}: "${right.candidate.surface}" [${right.candidate.range.start}, ${right.candidate.range.end})
+Only one recalled mention may occupy an overlapping text range. Choose the most specific valid mention, or mark the others as skip_this_time / never_recall.`
+        );
+      }
+    }
+  }
+  return issues;
+}
+function validateRecallDecision(issues, candidate, decision) {
+  if (decision.qid === void 0) {
+    issues.push(
+      `Candidate ${candidate.id} uses decision "recall" but does not provide qid. A recalled mention must choose one concrete QID from the candidate options.`
+    );
+    return;
+  }
+  if (isDisambiguationQid(candidate, decision.qid)) {
+    issues.push(
+      `Candidate ${candidate.id} selected source disambiguation QID ${decision.qid}. Source disambiguation QIDs are hidden behind DIS references and cannot be final mention groundings. Choose a QID from entityOptions or disambiguationOptions.meanings instead.`
+    );
+    return;
+  }
+  if (!isAllowedQid(candidate, decision.qid)) {
+    issues.push(formatIllegalQidIssue(candidate, decision.qid));
+  }
+}
+function isAllowedQid(candidate, qid) {
+  return listAllowedQids(candidate).includes(qid);
+}
+function isDisambiguationQid(candidate, qid) {
+  return candidate.qidOptions.some(
+    (option) => option.disambiguation !== void 0 && option.qid === qid
+  );
+}
+function listAllowedQids(candidate) {
+  return listCandidateSelectableQids(candidate);
+}
+function formatIllegalQidIssue(candidate, qid) {
+  return `Candidate ${candidate.id} selected qid ${qid}, but that QID is not available for this candidate. Allowed QIDs for "${candidate.surface}" are: ${listAllowedQids(candidate).join(", ")}.`;
+}
+function rangesOverlap(left, right) {
+  return left.start < right.end && right.start < left.end;
+}
+function createCandidateMap(candidates) {
+  return new Map(candidates.map((candidate) => [candidate.id, candidate]));
+}
+function createGroupMap(groups) {
+  return new Map(
+    groups.map((group) => [group.id, new Set(group.candidateIds)])
+  );
+}
+function inferGroups(candidates) {
+  if (candidates.length === 0) {
+    return [];
+  }
+  return [
+    {
+      candidateIds: candidates.map((candidate) => candidate.id),
+      id: "g1",
+      range: {
+        end: Math.max(...candidates.map((candidate) => candidate.range.end)),
+        start: Math.min(
+          ...candidates.map((candidate) => candidate.range.start)
+        )
+      }
+    }
+  ];
+}
+function buildPolicyMessages(input) {
+  return [
+    {
+      role: "system",
+      content: formatPolicySystemPrompt(input)
+    },
+    {
+      role: "user",
+      content: formatPolicyPrompt(input)
+    }
+  ];
+}
+function formatPolicySystemPrompt(input) {
+  return [
+    "You judge which precomputed Wikidata mention candidates should be recalled.",
+    "",
+    "Recall policy:",
+    input.policyPrompt,
+    "",
+    "Rules:",
+    "- Return JSON only.",
+    "- Return exactly one group result for every input group.",
+    "- Use decisions: [] only when this group has no selected mention and no policy update.",
+    "- First judge whether each candidate mention is worth recalling in this exact tagged context, before choosing among QID candidates.",
+    '- If the mention is not worth recalling in context, use "never_recall" immediately; do not inspect later pages just because more QIDs might exist.',
+    '- Use "never_recall" when this exact candidate span is not a standalone knowledge graph object in context.',
+    "- Candidate lists may be incomplete when a candidate has more pages.",
+    '- Use decision "continue" only after the mention has passed the context-worthiness test and the current candidate page has no good QID but more pages are available.',
+    '- "continue" is not a rejection. It asks to inspect the next candidate page for that candidate.',
+    '- If a surface should be recalled but the current incomplete page lacks a suitable QID, use "continue" instead of skip_this_time.',
+    '- Do not use "continue" for single-character surnames, abbreviations, side labels, generic words, fragments, roles, quantities, attributes, or discourse words that are not useful standalone knowledge graph objects in context.',
+    "- Do not invent candidates, ranges, surfaces, or QIDs.",
+    "- A recalled mention must choose a QID from entityOptions or disambiguationOptions.meanings.",
+    '- Include qid only when decision is "recall"; do not include qid for continue, skip_this_time, or never_recall.',
+    "- Never return DIS identifiers as qid values; DIS identifiers are only disambiguation references.",
+    "- Overlapping recalled ranges are illegal; choose the most specific valid mention."
+  ].join("\n");
+}
+function formatPolicyPrompt(input) {
+  return [
+    "Tagged context:",
+    formatTaggedContext(input),
+    "",
+    "Candidate groups:",
+    formatGroupsForPrompt(input).map((group) => JSON.stringify(group)).join("\n"),
+    "",
+    "Return this JSON shape:",
+    JSON.stringify({
+      groups: [
+        {
+          decisions: [
+            {
+              candidateId: "candidate id from this group",
+              decision: "recall | continue | skip_this_time | never_recall",
+              qid: "required only when decision is recall"
+            }
+          ],
+          groupId: "group id from the input"
+        }
+      ]
+    })
+  ].join("\n");
+}
+function formatTaggedContext(input) {
+  const groups = [...input.window.groups].sort(
+    (left, right) => left.range.start - right.range.start
+  );
+  const parts = [];
+  let cursor = input.window.baseOffset;
+  for (const group of groups) {
+    parts.push(
+      input.window.text.slice(
+        cursor - input.window.baseOffset,
+        group.range.start - input.window.baseOffset
+      )
+    );
+    parts.push(
+      `<group id="${escapeXmlAttribute(group.id)}">${escapeXmlText(
+        input.window.text.slice(
+          group.range.start - input.window.baseOffset,
+          group.range.end - input.window.baseOffset
+        )
+      )}</group>`
+    );
+    cursor = group.range.end;
+  }
+  parts.push(input.window.text.slice(cursor - input.window.baseOffset));
+  return parts.join("");
+}
+function formatGroupsForPrompt(input) {
+  const candidatesById = createCandidateMap(input.window.candidates);
+  return input.window.groups.map((group) => ({
+    candidates: group.candidateIds.flatMap((candidateId) => {
+      const candidate = candidatesById.get(candidateId);
+      return candidate === void 0 ? [] : [formatCandidateForPrompt(candidate)];
+    }),
+    groupId: group.id
+  }));
+}
+function formatCandidateForPrompt(candidate, _group) {
+  const formattedOptions = formatQidOptions(candidate.qidOptions);
+  return {
+    candidateId: candidate.id,
+    ...candidate.hasMoreOptions === true ? { hasMoreOptions: true } : {},
+    ...formattedOptions.disambiguationOptions.length === 0 ? {} : { disambiguationOptions: formattedOptions.disambiguationOptions },
+    ...formattedOptions.entityOptions.length === 0 ? {} : { entityOptions: formattedOptions.entityOptions }
+  };
+}
+function formatQidOptions(options) {
+  const disambiguationOptions = [];
+  const entityOptions = [];
+  for (const option of options) {
+    if (option.disambiguation !== void 0) {
+      disambiguationOptions.push({
+        ...option.label === void 0 ? {} : { label: option.label },
+        meanings: option.disambiguation.profile?.meanings.map(formatMeaningForPrompt) ?? option.disambiguation.linkedQids.map((item) => ({
+          name: item.title,
+          qid: item.qid
+        }))
+      });
+      continue;
+    }
+    entityOptions.push({
+      ...option.description === void 0 ? {} : { description: option.description },
+      ...option.label === void 0 ? {} : { label: option.label },
+      qid: option.qid
+    });
+  }
+  return {
+    disambiguationOptions,
+    entityOptions
+  };
+}
+function formatMeaningForPrompt(meaning) {
+  return {
+    ...meaning.information === "" ? {} : { information: meaning.information },
+    name: meaning.name,
+    qid: meaning.qid
+  };
+}
+function escapeXmlAttribute(value) {
+  return escapeXmlText(value).replaceAll('"', "&quot;");
+}
+function escapeXmlText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function formatFallbackIssue(error) {
+  if (error instanceof ParsedJsonError) {
+    return error.issues.join("\n");
+  }
+  if (error instanceof Error) {
+    const issues = error.issues;
+    if (Array.isArray(issues) && issues.every((issue) => typeof issue === "string")) {
+      return issues.join("\n");
+    }
+    return error.message;
+  }
+  return String(error);
+}
+export {
+  formatCandidateForPrompt,
+  judgeWikimatchPolicy,
+  parsePolicyResponse,
+  validatePolicyResponse
+};
+//# sourceMappingURL=policy-judge.js.map

package/dist/wikimatch/policy-judge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/wikimatch/policy-judge.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport {\n  ParsedJsonError,\n  RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE,\n  requestGuaranteedJson,\n  type GuaranteedRequest,\n} from \"../guaranteed/index.js\";\nimport type { LLMessage } from \"../llm/index.js\";\n\nimport { listCandidateSelectableQids } from \"./options.js\";\nimport type {\n  WikimatchAcceptedMention,\n  WikimatchCandidate,\n  WikimatchConflictGroup,\n  WikimatchPolicyContinuation,\n  WikimatchQidOption,\n  WikimatchPolicyDecisionOutput,\n  WikimatchPolicyJudgeInput,\n  WikimatchPolicyJudgeResult,\n  WikimatchPolicyResponse,\n  WikimatchPolicyUpdate,\n} from \"./types.js\";\n\nconst policyDecisionSchema = z\n  .object({\n    candidateId: z.string().min(1),\n    decision: z.enum([\"continue\", \"recall\", \"skip_this_time\", \"never_recall\"]),\n    qid: z.string().nullable().optional(),\n  })\n  .strict();\n\nconst policyGroupSchema = z\n  .object({\n    decisions: z.array(policyDecisionSchema),\n    groupId: z.string().min(1),\n  })\n  .strict();\n\nconst policyResponseSchema = z\n  .object({\n    groups: z.array(policyGroupSchema),\n  })\n  .strict();\n\nexport interface JudgeWikimatchPolicyOptions extends WikimatchPolicyJudgeInput {\n  readonly maxRetries?: number;\n  readonly request: GuaranteedRequest;\n}\n\nexport async function judgeWikimatchPolicy(\n  options: JudgeWikimatchPolicyOptions,\n): Promise<WikimatchPolicyJudgeResult> {\n  try {\n    return await requestGuaranteedJson({\n      messages: buildPolicyMessages(options),\n      parse: (response) =>\n        parsePolicyResponse(\n          options.candidates,\n          normalizePolicyResponse(response),\n          options.window.groups,\n        ),\n      request: options.request,\n      responseIntentClassifierPrompt:\n        RESPONSE_INTENT_CLASSIFIER_PROMPT_TEMPLATE,\n      schema: policyResponseSchema,\n      ...(options.maxRetries === undefined\n        ? {}\n        : { maxRetries: options.maxRetries }),\n    });\n  } catch (error) {\n    return {\n      continuations: [],\n      fallback: {\n        issues: [formatFallbackIssue(error)],\n        reason: \"guaranteed_json_failed\",\n      },\n      mentions: [],\n      policyUpdates: [],\n    };\n  }\n}\n\nfunction normalizePolicyResponse(\n  response: z.infer<typeof policyResponseSchema>,\n): WikimatchPolicyResponse {\n  return {\n    groups: response.groups.map((group) => ({\n      decisions: group.decisions.map((decision) => ({\n        candidateId: decision.candidateId,\n        decision: decision.decision,\n        ...normalizeDecisionQid(decision.qid),\n      })),\n      groupId: group.groupId,\n    })),\n  };\n}\n\nfunction normalizeDecisionQid(qid: string | null | undefined): {\n  readonly qid?: string;\n} {\n  const normalized = qid?.trim();\n\n  return normalized === undefined || normalized === \"\"\n    ? {}\n    : { qid: normalized };\n}\n\nexport function parsePolicyResponse(\n  candidates: readonly WikimatchCandidate[],\n  response: WikimatchPolicyResponse,\n  groups: readonly WikimatchConflictGroup[] = inferGroups(candidates),\n): WikimatchPolicyJudgeResult {\n  const issues = validatePolicyResponse(candidates, response, groups);\n\n  if (issues.length > 0) {\n    throw new ParsedJsonError(issues);\n  }\n\n  const candidatesById = createCandidateMap(candidates);\n  const continuations: WikimatchPolicyContinuation[] = [];\n  const mentions: WikimatchAcceptedMention[] = [];\n  const policyUpdates: WikimatchPolicyUpdate[] = [];\n\n  for (const group of response.groups) {\n    const continuedCandidateIds: string[] = [];\n\n    for (const decision of group.decisions) {\n      const candidate = candidatesById.get(decision.candidateId)!;\n\n      if (decision.decision === \"continue\") {\n        if (candidate.hasMoreOptions !== true) {\n          policyUpdates.push({\n            candidateId: candidate.id,\n            decision: \"skip_this_time\",\n            surface: candidate.surface,\n          });\n          continue;\n        }\n        continuedCandidateIds.push(candidate.id);\n        continue;\n      }\n\n      if (decision.decision === \"recall\") {\n        mentions.push({\n          candidateId: candidate.id,\n          qid: decision.qid!,\n          range: candidate.range,\n          surface: candidate.surface,\n        });\n        continue;\n      }\n\n      policyUpdates.push({\n        candidateId: candidate.id,\n        decision: decision.decision,\n        ...(decision.qid === undefined ? {} : { qid: decision.qid }),\n        surface: candidate.surface,\n      });\n    }\n\n    if (continuedCandidateIds.length > 0) {\n      continuations.push({\n        candidateIds: continuedCandidateIds,\n        groupId: group.groupId,\n      });\n    }\n  }\n\n  return {\n    continuations,\n    mentions,\n    policyUpdates,\n  };\n}\n\nexport function validatePolicyResponse(\n  candidates: readonly WikimatchCandidate[],\n  response: WikimatchPolicyResponse,\n  groups: readonly WikimatchConflictGroup[] = inferGroups(candidates),\n): readonly string[] {\n  const issues: string[] = [];\n  const candidatesById = createCandidateMap(candidates);\n  const groupsById = createGroupMap(groups);\n  const seenGroupIds = new Set<string>();\n  const seenCandidateIds = new Set<string>();\n  const recalled: Array<{\n    readonly candidate: WikimatchCandidate;\n    readonly decision: WikimatchPolicyDecisionOutput;\n  }> = [];\n\n  for (const group of response.groups) {\n    const expectedCandidateIds = groupsById.get(group.groupId);\n\n    if (expectedCandidateIds === undefined) {\n      issues.push(\n        `Unknown groupId \"${group.groupId}\". Use exactly these group IDs: ${[\n          ...groupsById.keys(),\n        ].join(\", \")}.`,\n      );\n      continue;\n    }\n    if (seenGroupIds.has(group.groupId)) {\n      issues.push(`Duplicate group result for ${group.groupId}.`);\n      continue;\n    }\n    seenGroupIds.add(group.groupId);\n\n    for (const decision of group.decisions) {\n      const candidate = candidatesById.get(decision.candidateId);\n\n      if (candidate === undefined) {\n        issues.push(\n          `Unknown candidateId \"${decision.candidateId}\". Use only one of: ${[\n            ...candidatesById.keys(),\n          ].join(\", \")}.`,\n        );\n        continue;\n      }\n      if (!expectedCandidateIds.has(decision.candidateId)) {\n        issues.push(\n          `Candidate ${decision.candidateId} does not belong to group ${group.groupId}. Use only candidates from that group: ${[\n            ...expectedCandidateIds,\n          ].join(\", \")}.`,\n        );\n        continue;\n      }\n      if (seenCandidateIds.has(decision.candidateId)) {\n        issues.push(\n          `Duplicate decision for candidate ${decision.candidateId}. Return exactly one decision per candidate at most.`,\n        );\n        continue;\n      }\n\n      seenCandidateIds.add(decision.candidateId);\n\n      if (decision.decision === \"recall\") {\n        validateRecallDecision(issues, candidate, decision);\n        recalled.push({ candidate, decision });\n        continue;\n      }\n\n      if (decision.decision === \"continue\") {\n        if (decision.qid !== undefined) {\n          issues.push(\n            `Candidate ${candidate.id} uses decision \"continue\" but includes qid. Continue means this candidate page has no final choice yet.`,\n          );\n        }\n        continue;\n      }\n\n      if (decision.qid !== undefined) {\n        issues.push(\n          `Candidate ${candidate.id} uses decision \"${decision.decision}\" but includes qid. Include qid only when decision is \"recall\".`,\n        );\n      }\n    }\n  }\n\n  for (const groupId of groupsById.keys()) {\n    if (!seenGroupIds.has(groupId)) {\n      issues.push(\n        `Missing group result for ${groupId}. Return exactly one result for every input group; use decisions: [] when nothing should be recalled.`,\n      );\n    }\n  }\n\n  for (let leftIndex = 0; leftIndex < recalled.length; leftIndex += 1) {\n    for (\n      let rightIndex = leftIndex + 1;\n      rightIndex < recalled.length;\n      rightIndex += 1\n    ) {\n      const left = recalled[leftIndex]!;\n      const right = recalled[rightIndex]!;\n\n      if (rangesOverlap(left.candidate.range, right.candidate.range)) {\n        issues.push(\n          `Decision conflict: candidates ${left.candidate.id} and ${right.candidate.id} both use decision \"recall\", but their ranges overlap.\\n` +\n            `- ${left.candidate.id}: \"${left.candidate.surface}\" [${left.candidate.range.start}, ${left.candidate.range.end})\\n` +\n            `- ${right.candidate.id}: \"${right.candidate.surface}\" [${right.candidate.range.start}, ${right.candidate.range.end})\\n` +\n            \"Only one recalled mention may occupy an overlapping text range. Choose the most specific valid mention, or mark the others as skip_this_time / never_recall.\",\n        );\n      }\n    }\n  }\n\n  return issues;\n}\n\nfunction validateRecallDecision(\n  issues: string[],\n  candidate: WikimatchCandidate,\n  decision: WikimatchPolicyDecisionOutput,\n): void {\n  if (decision.qid === undefined) {\n    issues.push(\n      `Candidate ${candidate.id} uses decision \"recall\" but does not provide qid. A recalled mention must choose one concrete QID from the candidate options.`,\n    );\n    return;\n  }\n  if (isDisambiguationQid(candidate, decision.qid)) {\n    issues.push(\n      `Candidate ${candidate.id} selected source disambiguation QID ${decision.qid}. Source disambiguation QIDs are hidden behind DIS references and cannot be final mention groundings. Choose a QID from entityOptions or disambiguationOptions.meanings instead.`,\n    );\n    return;\n  }\n  if (!isAllowedQid(candidate, decision.qid)) {\n    issues.push(formatIllegalQidIssue(candidate, decision.qid));\n  }\n}\n\nfunction isAllowedQid(candidate: WikimatchCandidate, qid: string): boolean {\n  return listAllowedQids(candidate).includes(qid);\n}\n\nfunction isDisambiguationQid(\n  candidate: WikimatchCandidate,\n  qid: string,\n): boolean {\n  return candidate.qidOptions.some(\n    (option) => option.disambiguation !== undefined && option.qid === qid,\n  );\n}\n\nfunction listAllowedQids(candidate: WikimatchCandidate): readonly string[] {\n  return listCandidateSelectableQids(candidate);\n}\n\nfunction formatIllegalQidIssue(\n  candidate: WikimatchCandidate,\n  qid: string,\n): string {\n  return (\n    `Candidate ${candidate.id} selected qid ${qid}, but that QID is not available for this candidate. ` +\n    `Allowed QIDs for \"${candidate.surface}\" are: ${listAllowedQids(candidate).join(\", \")}.`\n  );\n}\n\nfunction rangesOverlap(\n  left: { readonly end: number; readonly start: number },\n  right: { readonly end: number; readonly start: number },\n): boolean {\n  return left.start < right.end && right.start < left.end;\n}\n\nfunction createCandidateMap(\n  candidates: readonly WikimatchCandidate[],\n): ReadonlyMap<string, WikimatchCandidate> {\n  return new Map(candidates.map((candidate) => [candidate.id, candidate]));\n}\n\nfunction createGroupMap(\n  groups: readonly WikimatchConflictGroup[],\n): ReadonlyMap<string, ReadonlySet<string>> {\n  return new Map(\n    groups.map((group) => [group.id, new Set(group.candidateIds)]),\n  );\n}\n\nfunction inferGroups(\n  candidates: readonly WikimatchCandidate[],\n): readonly WikimatchConflictGroup[] {\n  if (candidates.length === 0) {\n    return [];\n  }\n\n  return [\n    {\n      candidateIds: candidates.map((candidate) => candidate.id),\n      id: \"g1\",\n      range: {\n        end: Math.max(...candidates.map((candidate) => candidate.range.end)),\n        start: Math.min(\n          ...candidates.map((candidate) => candidate.range.start),\n        ),\n      },\n    },\n  ];\n}\n\nfunction buildPolicyMessages(input: WikimatchPolicyJudgeInput): LLMessage[] {\n  return [\n    {\n      role: \"system\",\n      content: formatPolicySystemPrompt(input),\n    },\n    {\n      role: \"user\",\n      content: formatPolicyPrompt(input),\n    },\n  ];\n}\n\nfunction formatPolicySystemPrompt(input: WikimatchPolicyJudgeInput): string {\n  return [\n    \"You judge which precomputed Wikidata mention candidates should be recalled.\",\n    \"\",\n    \"Recall policy:\",\n    input.policyPrompt,\n    \"\",\n    \"Rules:\",\n    \"- Return JSON only.\",\n    \"- Return exactly one group result for every input group.\",\n    \"- Use decisions: [] only when this group has no selected mention and no policy update.\",\n    \"- First judge whether each candidate mention is worth recalling in this exact tagged context, before choosing among QID candidates.\",\n    '- If the mention is not worth recalling in context, use \"never_recall\" immediately; do not inspect later pages just because more QIDs might exist.',\n    '- Use \"never_recall\" when this exact candidate span is not a standalone knowledge graph object in context.',\n    \"- Candidate lists may be incomplete when a candidate has more pages.\",\n    '- Use decision \"continue\" only after the mention has passed the context-worthiness test and the current candidate page has no good QID but more pages are available.',\n    '- \"continue\" is not a rejection. It asks to inspect the next candidate page for that candidate.',\n    '- If a surface should be recalled but the current incomplete page lacks a suitable QID, use \"continue\" instead of skip_this_time.',\n    '- Do not use \"continue\" for single-character surnames, abbreviations, side labels, generic words, fragments, roles, quantities, attributes, or discourse words that are not useful standalone knowledge graph objects in context.',\n    \"- Do not invent candidates, ranges, surfaces, or QIDs.\",\n    \"- A recalled mention must choose a QID from entityOptions or disambiguationOptions.meanings.\",\n    '- Include qid only when decision is \"recall\"; do not include qid for continue, skip_this_time, or never_recall.',\n    \"- Never return DIS identifiers as qid values; DIS identifiers are only disambiguation references.\",\n    \"- Overlapping recalled ranges are illegal; choose the most specific valid mention.\",\n  ].join(\"\\n\");\n}\n\nfunction formatPolicyPrompt(input: WikimatchPolicyJudgeInput): string {\n  return [\n    \"Tagged context:\",\n    formatTaggedContext(input),\n    \"\",\n    \"Candidate groups:\",\n    formatGroupsForPrompt(input)\n      .map((group) => JSON.stringify(group))\n      .join(\"\\n\"),\n    \"\",\n    \"Return this JSON shape:\",\n    JSON.stringify({\n      groups: [\n        {\n          decisions: [\n            {\n              candidateId: \"candidate id from this group\",\n              decision: \"recall | continue | skip_this_time | never_recall\",\n              qid: \"required only when decision is recall\",\n            },\n          ],\n          groupId: \"group id from the input\",\n        },\n      ],\n    }),\n  ].join(\"\\n\");\n}\n\nfunction formatTaggedContext(input: WikimatchPolicyJudgeInput): string {\n  const groups = [...input.window.groups].sort(\n    (left, right) => left.range.start - right.range.start,\n  );\n  const parts: string[] = [];\n  let cursor = input.window.baseOffset;\n\n  for (const group of groups) {\n    parts.push(\n      input.window.text.slice(\n        cursor - input.window.baseOffset,\n        group.range.start - input.window.baseOffset,\n      ),\n    );\n    parts.push(\n      `<group id=\"${escapeXmlAttribute(group.id)}\">${escapeXmlText(\n        input.window.text.slice(\n          group.range.start - input.window.baseOffset,\n          group.range.end - input.window.baseOffset,\n        ),\n      )}</group>`,\n    );\n    cursor = group.range.end;\n  }\n\n  parts.push(input.window.text.slice(cursor - input.window.baseOffset));\n\n  return parts.join(\"\");\n}\n\nfunction formatGroupsForPrompt(input: WikimatchPolicyJudgeInput): object[] {\n  const candidatesById = createCandidateMap(input.window.candidates);\n\n  return input.window.groups.map((group) => ({\n    candidates: group.candidateIds.flatMap((candidateId) => {\n      const candidate = candidatesById.get(candidateId);\n\n      return candidate === undefined\n        ? []\n        : [formatCandidateForPrompt(candidate)];\n    }),\n    groupId: group.id,\n  }));\n}\n\nexport function formatCandidateForPrompt(\n  candidate: WikimatchCandidate,\n  _group?: WikimatchConflictGroup,\n): object {\n  const formattedOptions = formatQidOptions(candidate.qidOptions);\n\n  return {\n    candidateId: candidate.id,\n    ...(candidate.hasMoreOptions === true ? { hasMoreOptions: true } : {}),\n    ...(formattedOptions.disambiguationOptions.length === 0\n      ? {}\n      : { disambiguationOptions: formattedOptions.disambiguationOptions }),\n    ...(formattedOptions.entityOptions.length === 0\n      ? {}\n      : { entityOptions: formattedOptions.entityOptions }),\n  };\n}\n\nfunction formatQidOptions(options: readonly WikimatchQidOption[]): {\n  readonly disambiguationOptions: readonly object[];\n  readonly entityOptions: readonly object[];\n} {\n  const disambiguationOptions: object[] = [];\n  const entityOptions: object[] = [];\n\n  for (const option of options) {\n    if (option.disambiguation !== undefined) {\n      disambiguationOptions.push({\n        ...(option.label === undefined ? {} : { label: option.label }),\n        meanings:\n          option.disambiguation.profile?.meanings.map(formatMeaningForPrompt) ??\n          option.disambiguation.linkedQids.map((item) => ({\n            name: item.title,\n            qid: item.qid,\n          })),\n      });\n      continue;\n    }\n\n    entityOptions.push({\n      ...(option.description === undefined\n        ? {}\n        : { description: option.description }),\n      ...(option.label === undefined ? {} : { label: option.label }),\n      qid: option.qid,\n    });\n  }\n\n  return {\n    disambiguationOptions,\n    entityOptions,\n  };\n}\n\nfunction formatMeaningForPrompt(\n  meaning: NonNullable<\n    NonNullable<WikimatchQidOption[\"disambiguation\"]>[\"profile\"]\n  >[\"meanings\"][number],\n): object {\n  return {\n    ...(meaning.information === \"\" ? {} : { information: meaning.information }),\n    name: meaning.name,\n    qid: meaning.qid,\n  };\n}\n\nfunction escapeXmlAttribute(value: string): string {\n  return escapeXmlText(value).replaceAll('\"', \"&quot;\");\n}\n\nfunction escapeXmlText(value: string): string {\n  return value\n    .replaceAll(\"&\", \"&amp;\")\n    .replaceAll(\"<\", \"&lt;\")\n    .replaceAll(\">\", \"&gt;\");\n}\n\nfunction formatFallbackIssue(error: unknown): string {\n  if (error instanceof ParsedJsonError) {\n    return error.issues.join(\"\\n\");\n  }\n  if (error instanceof Error) {\n    const issues = (error as { readonly issues?: unknown }).issues;\n\n    if (\n      Array.isArray(issues) &&\n      issues.every((issue) => typeof issue === \"string\")\n    ) {\n      return issues.join(\"\\n\");\n    }\n\n    return error.message;\n  }\n\n  return String(error);\n}\n"],"mappings":"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","names":[]}

package/dist/wikimatch/range-suppression.d.ts

@@ -0,0 +1,9 @@
+interface SuppressContainedRangeInput {
+    readonly range: {
+        readonly end: number;
+        readonly start: number;
+    };
+}
+declare function suppressContainedRanges<T extends SuppressContainedRangeInput>(items: readonly T[]): readonly T[];
+
+export { type SuppressContainedRangeInput, suppressContainedRanges };

package/dist/wikimatch/range-suppression.js

@@ -0,0 +1,27 @@
+function suppressContainedRanges(items) {
+  const sorted = [...items].filter((item) => item.range.start < item.range.end).sort(compareByRangeForSuppression);
+  const kept = [];
+  for (const item of sorted) {
+    if (kept.some((candidate) => containsRange(candidate, item))) {
+      continue;
+    }
+    kept.push(item);
+  }
+  return kept.sort(compareByOriginalOrder);
+}
+function compareByRangeForSuppression(left, right) {
+  return left.range.start - right.range.start || right.range.end - left.range.end || rangeLength(right) - rangeLength(left);
+}
+function compareByOriginalOrder(left, right) {
+  return left.range.start - right.range.start || left.range.end - right.range.end || rangeLength(left) - rangeLength(right);
+}
+function containsRange(container, item) {
+  return container.range.start <= item.range.start && item.range.end <= container.range.end && rangeLength(container) > rangeLength(item);
+}
+function rangeLength(item) {
+  return item.range.end - item.range.start;
+}
+export {
+  suppressContainedRanges
+};
+//# sourceMappingURL=range-suppression.js.map

package/dist/wikimatch/range-suppression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/wikimatch/range-suppression.ts"],"sourcesContent":["export interface SuppressContainedRangeInput {\n  readonly range: {\n    readonly end: number;\n    readonly start: number;\n  };\n}\n\nexport function suppressContainedRanges<T extends SuppressContainedRangeInput>(\n  items: readonly T[],\n): readonly T[] {\n  const sorted = [...items]\n    .filter((item) => item.range.start < item.range.end)\n    .sort(compareByRangeForSuppression);\n  const kept: T[] = [];\n\n  for (const item of sorted) {\n    if (kept.some((candidate) => containsRange(candidate, item))) {\n      continue;\n    }\n\n    kept.push(item);\n  }\n\n  return kept.sort(compareByOriginalOrder);\n}\n\nfunction compareByRangeForSuppression<T extends SuppressContainedRangeInput>(\n  left: T,\n  right: T,\n): number {\n  return (\n    left.range.start - right.range.start ||\n    right.range.end - left.range.end ||\n    rangeLength(right) - rangeLength(left)\n  );\n}\n\nfunction compareByOriginalOrder<T extends SuppressContainedRangeInput>(\n  left: T,\n  right: T,\n): number {\n  return (\n    left.range.start - right.range.start ||\n    left.range.end - right.range.end ||\n    rangeLength(left) - rangeLength(right)\n  );\n}\n\nfunction containsRange<T extends SuppressContainedRangeInput>(\n  container: T,\n  item: T,\n): boolean {\n  return (\n    container.range.start <= item.range.start &&\n    item.range.end <= container.range.end &&\n    rangeLength(container) > rangeLength(item)\n  );\n}\n\nfunction rangeLength(item: SuppressContainedRangeInput): number {\n  return item.range.end - item.range.start;\n}\n"],"mappings":"AAOO,SAAS,wBACd,OACc;AACd,QAAM,SAAS,CAAC,GAAG,KAAK,EACrB,OAAO,CAAC,SAAS,KAAK,MAAM,QAAQ,KAAK,MAAM,GAAG,EAClD,KAAK,4BAA4B;AACpC,QAAM,OAAY,CAAC;AAEnB,aAAW,QAAQ,QAAQ;AACzB,QAAI,KAAK,KAAK,CAAC,cAAc,cAAc,WAAW,IAAI,CAAC,GAAG;AAC5D;AAAA,IACF;AAEA,SAAK,KAAK,IAAI;AAAA,EAChB;AAEA,SAAO,KAAK,KAAK,sBAAsB;AACzC;AAEA,SAAS,6BACP,MACA,OACQ;AACR,SACE,KAAK,MAAM,QAAQ,MAAM,MAAM,SAC/B,MAAM,MAAM,MAAM,KAAK,MAAM,OAC7B,YAAY,KAAK,IAAI,YAAY,IAAI;AAEzC;AAEA,SAAS,uBACP,MACA,OACQ;AACR,SACE,KAAK,MAAM,QAAQ,MAAM,MAAM,SAC/B,KAAK,MAAM,MAAM,MAAM,MAAM,OAC7B,YAAY,IAAI,IAAI,YAAY,KAAK;AAEzC;AAEA,SAAS,cACP,WACA,MACS;AACT,SACE,UAAU,MAAM,SAAS,KAAK,MAAM,SACpC,KAAK,MAAM,OAAO,UAAU,MAAM,OAClC,YAAY,SAAS,IAAI,YAAY,IAAI;AAE7C;AAEA,SAAS,YAAY,MAA2C;AAC9D,SAAO,KAAK,MAAM,MAAM,KAAK,MAAM;AACrC;","names":[]}

package/dist/wikimatch/surface-screening.d.ts

@@ -0,0 +1,16 @@
+import { GuaranteedRequest } from '../guaranteed/types.js';
+import { WikimatchSurfaceProtectionInput, WikimatchSurfaceProtectionResult, WikimatchSurface, WikimatchSurfaceProtectionResponse } from './types.js';
+import '../llm/types.js';
+import 'ai';
+import 'zod';
+import '../wikipage/types.js';
+
+interface JudgeWikimatchSurfaceProtectionOptions extends WikimatchSurfaceProtectionInput {
+    readonly maxRetries?: number;
+    readonly request: GuaranteedRequest;
+}
+declare function judgeWikimatchSurfaceProtection(options: JudgeWikimatchSurfaceProtectionOptions): Promise<WikimatchSurfaceProtectionResult>;
+declare function parseSurfaceProtectionResponse(surfaces: readonly WikimatchSurface[], response: WikimatchSurfaceProtectionResponse): WikimatchSurfaceProtectionResult;
+declare function validateSurfaceProtectionResponse(surfaces: readonly WikimatchSurface[], response: WikimatchSurfaceProtectionResponse): readonly string[];
+
+export { type JudgeWikimatchSurfaceProtectionOptions, judgeWikimatchSurfaceProtection, parseSurfaceProtectionResponse, validateSurfaceProtectionResponse };