wiki-graph-core 0.3.1 → 0.4.1

package/dist/text/reader/chunk-batch/parser/resolver.d.ts

@@ -0,0 +1,28 @@
+import { SentenceId } from '../../../../document/types.js';
+import { EvidenceResolutionFailure } from '../../../../graph/evidence-selection/anchor/types.js';
+import { FragmentProjection } from '../fragment-projection.js';
+import { GuaranteedChoiceRequest, ResolveChunkEvidenceInput } from './schema.js';
+import '../types.js';
+import '../../../../runtime/common/language.js';
+import '../../../../external/llm/client/core.js';
+import '../../../../external/llm/context.js';
+import '../../../../external/llm/cache.js';
+import '../../../../external/llm/types.js';
+import 'ai';
+import 'zod';
+
+declare class ChunkEvidenceResolver {
+    #private;
+    constructor(input: {
+        readonly choiceSystemPrompt: string;
+        readonly projection: FragmentProjection;
+        readonly responseIntentClassifierPrompt: string;
+        readonly requestChoice: GuaranteedChoiceRequest;
+    });
+    resolve(input: ResolveChunkEvidenceInput): Promise<readonly [
+        sentenceIds: readonly SentenceId[],
+        failure: EvidenceResolutionFailure | undefined
+    ]>;
+}
+
+export { ChunkEvidenceResolver };

package/dist/text/reader/chunk-batch/parser/resolver.js

@@ -0,0 +1,267 @@
+import {
+  ParsedJsonError,
+  requestGuaranteedJson
+} from "../../../../external/guaranteed/index.js";
+import {
+  resolveEvidenceSelectionList,
+  EvidenceResolver
+} from "../../../../graph/evidence-selection/index.js";
+import {
+  createEvidenceSelectionList,
+  toEvidenceResolutionFailure
+} from "./evidence.js";
+import {
+  expectSingleSpan,
+  formatChoiceCandidate,
+  formatError,
+  isParsedJsonValidationFailure,
+  isRecord,
+  toChoiceFieldName
+} from "./helpers.js";
+import {
+  choiceResponseSchema
+} from "./schema.js";
+const MAX_CHOICE_RETRIES = 3;
+class ChunkEvidenceResolver {
+  #choiceSystemPrompt;
+  #evidenceResolver = new EvidenceResolver();
+  #projection;
+  #responseIntentClassifierPrompt;
+  #requestChoice;
+  constructor(input) {
+    this.#choiceSystemPrompt = input.choiceSystemPrompt;
+    this.#projection = input.projection;
+    this.#responseIntentClassifierPrompt = input.responseIntentClassifierPrompt;
+    this.#requestChoice = input.requestChoice;
+  }
+  async resolve(input) {
+    const evidence = input.data.evidence;
+    if (evidence === void 0 || evidence === null) {
+      return [[], void 0];
+    }
+    if (!isRecord(evidence) && !Array.isArray(evidence)) {
+      return [
+        [],
+        {
+          candidates: [],
+          code: "invalid_evidence",
+          fieldName: "evidence",
+          message: `Chunk #${input.chunkIndex} ("${input.chunkLabel}"): evidence must be an object or array`
+        }
+      ];
+    }
+    const projectedSentences = this.#projection.sentences;
+    const candidateSentenceIds = projectedSentences.map(
+      (sentence) => sentence.sentenceId
+    );
+    const selectionSentences = projectedSentences.map((sentence, index) => ({
+      id: `S${index + 1}`,
+      sentenceId: sentence.sentenceId,
+      text: sentence.projectedText
+    }));
+    const selectionEvidence = createEvidenceSelectionList(evidence);
+    const [selectionResolution, selectionFailure] = selectionEvidence === void 0 ? [void 0, void 0] : resolveEvidenceSelectionList({
+      evidence: selectionEvidence,
+      sentences: selectionSentences
+    });
+    if (selectionResolution !== void 0) {
+      return [selectionResolution.sentenceIds, void 0];
+    }
+    const exactMatchSentenceIds = Array.isArray(evidence) ? [] : this.#resolveExactProjectionEvidence(evidence);
+    if (exactMatchSentenceIds.length > 0) {
+      return [exactMatchSentenceIds, void 0];
+    }
+    const candidateTexts = projectedSentences.map(
+      (sentence) => sentence.projectedText
+    );
+    const [resolution, failure] = Array.isArray(evidence) ? [void 0, void 0] : this.#evidenceResolver.resolve(
+      evidence,
+      candidateSentenceIds,
+      candidateTexts
+    );
+    if (resolution !== void 0) {
+      return [resolution.sentenceIds, void 0];
+    }
+    const fallbackFailure = selectionFailure === void 0 ? failure : toEvidenceResolutionFailure(selectionFailure, "evidence");
+    if (fallbackFailure === void 0) {
+      return [[], void 0];
+    }
+    const shouldUseChoice = fallbackFailure.code.startsWith("ambiguous") || fallbackFailure.code === "low_confidence" && input.isLastGenerationAttempt && fallbackFailure.candidates.length > 0;
+    if (!shouldUseChoice) {
+      return [[], fallbackFailure];
+    }
+    const choiceFieldName = toChoiceFieldName(fallbackFailure.fieldName);
+    if (choiceFieldName === void 0) {
+      return [[], fallbackFailure];
+    }
+    const [choiceCandidate, choiceFailure] = await this.#chooseAmbiguousCandidate({
+      candidates: fallbackFailure.candidates,
+      chunkData: input.data,
+      chunkIndex: input.chunkIndex,
+      chunkLabel: input.chunkLabel,
+      fieldName: choiceFieldName
+    });
+    if (choiceFailure !== void 0) {
+      if (choiceFailure.code === "choice_parse_failed_full_fragment") {
+        return [candidateSentenceIds, void 0];
+      }
+      return [[], choiceFailure];
+    }
+    if (choiceCandidate === void 0) {
+      return [
+        [],
+        {
+          candidates: fallbackFailure.candidates,
+          code: "choice_failed",
+          fieldName: fallbackFailure.fieldName,
+          message: `Second-stage choice failed for ${fallbackFailure.fieldName}: no candidate returned.`
+        }
+      ];
+    }
+    if (choiceFieldName === "evidence") {
+      return [[choiceCandidate.sentenceId], void 0];
+    }
+    if (Array.isArray(evidence)) {
+      return [[], fallbackFailure];
+    }
+    if (input.isLastGenerationAttempt) {
+      const [resolved2, resolveFailure2] = this.#evidenceResolver.resolveWithOverrides({
+        candidateSentenceIds,
+        candidateTexts,
+        evidence,
+        overrides: {
+          [choiceFieldName]: choiceCandidate
+        }
+      });
+      if (resolved2 !== void 0) {
+        return [resolved2.sentenceIds, void 0];
+      }
+      return [[], resolveFailure2];
+    }
+    const repairedEvidence = {
+      ...evidence,
+      [choiceFieldName]: {
+        mode: "full",
+        text: choiceCandidate.text
+      }
+    };
+    const [resolved, resolveFailure] = this.#evidenceResolver.resolve(
+      repairedEvidence,
+      candidateSentenceIds,
+      candidateTexts
+    );
+    if (resolved !== void 0) {
+      return [resolved.sentenceIds, void 0];
+    }
+    return [[], resolveFailure];
+  }
+  #resolveExactProjectionEvidence(evidence) {
+    const startValue = evidence.start_anchor ?? evidence.start;
+    const [startAnchor, startFailure] = this.#evidenceResolver.parseAnchor(
+      startValue,
+      "start_anchor"
+    );
+    if (startFailure !== void 0 || startAnchor?.text === void 0) {
+      return [];
+    }
+    const startMatch = expectSingleSpan(
+      this.#projection.findExactMatches(startAnchor.text)
+    );
+    if (startMatch === void 0) {
+      return [];
+    }
+    const endValue = evidence.end_anchor ?? evidence.end;
+    if (endValue === void 0) {
+      return this.#projection.resolveSentenceIds(startMatch);
+    }
+    const [endAnchor, endFailure] = this.#evidenceResolver.parseAnchor(
+      endValue,
+      "end_anchor"
+    );
+    if (endFailure !== void 0 || endAnchor?.text === void 0) {
+      return [];
+    }
+    const endMatch = expectSingleSpan(
+      this.#projection.findExactMatches(endAnchor.text)
+    );
+    if (endMatch === void 0 || endMatch.offset < startMatch.offset) {
+      return [];
+    }
+    return this.#projection.resolveSentenceIds({
+      length: endMatch.offset + endMatch.length - startMatch.offset,
+      offset: startMatch.offset
+    });
+  }
+  async #chooseAmbiguousCandidate(input) {
+    const messages = this.#buildChoiceMessages(input);
+    const candidateIds = input.candidates.map(
+      (candidate) => candidate.occurrenceId
+    );
+    try {
+      const choice = await requestGuaranteedJson({
+        maxRetries: MAX_CHOICE_RETRIES,
+        messages,
+        parse: (data) => {
+          const candidate = input.candidates.find(
+            (item) => item.occurrenceId === data.choice
+          );
+          if (candidate === void 0) {
+            throw new ParsedJsonError([
+              `Invalid choice "${data.choice}". Expected one of: ${candidateIds.join(", ")}`
+            ]);
+          }
+          return candidate;
+        },
+        responseIntentClassifierPrompt: this.#responseIntentClassifierPrompt,
+        request: this.#requestChoice,
+        schema: choiceResponseSchema
+      });
+      return [choice, void 0];
+    } catch (error) {
+      if (isParsedJsonValidationFailure(error)) {
+        return [
+          void 0,
+          {
+            candidates: input.candidates,
+            code: "choice_parse_failed_full_fragment",
+            fieldName: input.fieldName,
+            message: `Second-stage choice parse validation failed for ${input.fieldName}; falling back to the full fragment span.`
+          }
+        ];
+      }
+      return [
+        void 0,
+        {
+          candidates: input.candidates,
+          code: "choice_failed",
+          fieldName: input.fieldName,
+          message: `Second-stage choice failed for ${input.fieldName}: ${formatError(error)}`
+        }
+      ];
+    }
+  }
+  #buildChoiceMessages(input) {
+    return [
+      {
+        content: this.#choiceSystemPrompt,
+        role: "system"
+      },
+      {
+        content: `Previously generated chunk (do NOT rewrite it):
+\`\`\`json
+${JSON.stringify(input.chunkData, null, 2)}
+\`\`\`
+
+Resolve only this field: "${input.fieldName}" for chunk #${input.chunkIndex} [${input.chunkLabel}].
+Choose exactly one candidate occurrence ID from the list below.
+
+` + input.candidates.map(formatChoiceCandidate).join("\n"),
+        role: "user"
+      }
+    ];
+  }
+}
+export {
+  ChunkEvidenceResolver
+};
+//# sourceMappingURL=resolver.js.map

package/dist/text/reader/chunk-batch/parser/resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/text/reader/chunk-batch/parser/resolver.ts"],"sourcesContent":["import {\n  ParsedJsonError,\n  requestGuaranteedJson,\n} from \"../../../../external/guaranteed/index.js\";\nimport type { LLMessage } from \"../../../../external/llm/index.js\";\nimport type { SentenceId } from \"../../../../document/index.js\";\nimport {\n  resolveEvidenceSelectionList,\n  EvidenceResolver,\n  type EvidenceResolutionFailure,\n  type RankedSentenceCandidate,\n} from \"../../../../graph/evidence-selection/index.js\";\nimport type { FragmentProjection } from \"../fragment-projection.js\";\nimport {\n  createEvidenceSelectionList,\n  toEvidenceResolutionFailure,\n} from \"./evidence.js\";\nimport {\n  expectSingleSpan,\n  formatChoiceCandidate,\n  formatError,\n  isParsedJsonValidationFailure,\n  isRecord,\n  toChoiceFieldName,\n} from \"./helpers.js\";\nimport {\n  choiceResponseSchema,\n  type GuaranteedChoiceRequest,\n  type ResolveChunkEvidenceInput,\n  type SelectAmbiguousCandidateInput,\n} from \"./schema.js\";\n\nconst MAX_CHOICE_RETRIES = 3;\n\nexport class ChunkEvidenceResolver {\n  readonly #choiceSystemPrompt: string;\n  readonly #evidenceResolver = new EvidenceResolver();\n  readonly #projection: FragmentProjection;\n  readonly #responseIntentClassifierPrompt: string;\n  readonly #requestChoice: GuaranteedChoiceRequest;\n\n  public constructor(input: {\n    readonly choiceSystemPrompt: string;\n    readonly projection: FragmentProjection;\n    readonly responseIntentClassifierPrompt: string;\n    readonly requestChoice: GuaranteedChoiceRequest;\n  }) {\n    this.#choiceSystemPrompt = input.choiceSystemPrompt;\n    this.#projection = input.projection;\n    this.#responseIntentClassifierPrompt = input.responseIntentClassifierPrompt;\n    this.#requestChoice = input.requestChoice;\n  }\n\n  public async resolve(\n    input: ResolveChunkEvidenceInput,\n  ): Promise<\n    readonly [\n      sentenceIds: readonly SentenceId[],\n      failure: EvidenceResolutionFailure | undefined,\n    ]\n  > {\n    const evidence = input.data.evidence;\n\n    if (evidence === undefined || evidence === null) {\n      return [[], undefined];\n    }\n\n    if (!isRecord(evidence) && !Array.isArray(evidence)) {\n      return [\n        [],\n        {\n          candidates: [],\n          code: \"invalid_evidence\",\n          fieldName: \"evidence\",\n          message: `Chunk #${input.chunkIndex} (\"${input.chunkLabel}\"): evidence must be an object or array`,\n        },\n      ];\n    }\n\n    const projectedSentences = this.#projection.sentences;\n    const candidateSentenceIds = projectedSentences.map(\n      (sentence) => sentence.sentenceId,\n    );\n    const selectionSentences = projectedSentences.map((sentence, index) => ({\n      id: `S${index + 1}`,\n      sentenceId: sentence.sentenceId,\n      text: sentence.projectedText,\n    }));\n    const selectionEvidence = createEvidenceSelectionList(evidence);\n    const [selectionResolution, selectionFailure] =\n      selectionEvidence === undefined\n        ? [undefined, undefined]\n        : resolveEvidenceSelectionList({\n            evidence: selectionEvidence,\n            sentences: selectionSentences,\n          });\n\n    if (selectionResolution !== undefined) {\n      return [selectionResolution.sentenceIds, undefined];\n    }\n\n    const exactMatchSentenceIds = Array.isArray(evidence)\n      ? []\n      : this.#resolveExactProjectionEvidence(evidence);\n\n    if (exactMatchSentenceIds.length > 0) {\n      return [exactMatchSentenceIds, undefined];\n    }\n\n    const candidateTexts = projectedSentences.map(\n      (sentence) => sentence.projectedText,\n    );\n    const [resolution, failure] = Array.isArray(evidence)\n      ? [undefined, undefined]\n      : this.#evidenceResolver.resolve(\n          evidence,\n          candidateSentenceIds,\n          candidateTexts,\n        );\n\n    if (resolution !== undefined) {\n      return [resolution.sentenceIds, undefined];\n    }\n\n    const fallbackFailure =\n      selectionFailure === undefined\n        ? failure\n        : toEvidenceResolutionFailure(selectionFailure, \"evidence\");\n\n    if (fallbackFailure === undefined) {\n      return [[], undefined];\n    }\n\n    const shouldUseChoice =\n      fallbackFailure.code.startsWith(\"ambiguous\") ||\n      (fallbackFailure.code === \"low_confidence\" &&\n        input.isLastGenerationAttempt &&\n        fallbackFailure.candidates.length > 0);\n\n    if (!shouldUseChoice) {\n      return [[], fallbackFailure];\n    }\n\n    const choiceFieldName = toChoiceFieldName(fallbackFailure.fieldName);\n\n    if (choiceFieldName === undefined) {\n      return [[], fallbackFailure];\n    }\n\n    const [choiceCandidate, choiceFailure] =\n      await this.#chooseAmbiguousCandidate({\n        candidates: fallbackFailure.candidates,\n        chunkData: input.data,\n        chunkIndex: input.chunkIndex,\n        chunkLabel: input.chunkLabel,\n        fieldName: choiceFieldName,\n      });\n\n    if (choiceFailure !== undefined) {\n      if (choiceFailure.code === \"choice_parse_failed_full_fragment\") {\n        return [candidateSentenceIds, undefined];\n      }\n\n      return [[], choiceFailure];\n    }\n\n    if (choiceCandidate === undefined) {\n      return [\n        [],\n        {\n          candidates: fallbackFailure.candidates,\n          code: \"choice_failed\",\n          fieldName: fallbackFailure.fieldName,\n          message: `Second-stage choice failed for ${fallbackFailure.fieldName}: no candidate returned.`,\n        },\n      ];\n    }\n\n    if (choiceFieldName === \"evidence\") {\n      return [[choiceCandidate.sentenceId], undefined];\n    }\n\n    if (Array.isArray(evidence)) {\n      return [[], fallbackFailure];\n    }\n\n    if (input.isLastGenerationAttempt) {\n      const [resolved, resolveFailure] =\n        this.#evidenceResolver.resolveWithOverrides({\n          candidateSentenceIds,\n          candidateTexts,\n          evidence,\n          overrides: {\n            [choiceFieldName]: choiceCandidate,\n          },\n        });\n\n      if (resolved !== undefined) {\n        return [resolved.sentenceIds, undefined];\n      }\n\n      return [[], resolveFailure];\n    }\n\n    const repairedEvidence: Record<string, unknown> = {\n      ...evidence,\n      [choiceFieldName]: {\n        mode: \"full\",\n        text: choiceCandidate.text,\n      },\n    };\n    const [resolved, resolveFailure] = this.#evidenceResolver.resolve(\n      repairedEvidence,\n      candidateSentenceIds,\n      candidateTexts,\n    );\n\n    if (resolved !== undefined) {\n      return [resolved.sentenceIds, undefined];\n    }\n\n    return [[], resolveFailure];\n  }\n  #resolveExactProjectionEvidence(\n    evidence: Record<string, unknown>,\n  ): SentenceId[] {\n    const startValue = evidence.start_anchor ?? evidence.start;\n    const [startAnchor, startFailure] = this.#evidenceResolver.parseAnchor(\n      startValue,\n      \"start_anchor\",\n    );\n\n    if (startFailure !== undefined || startAnchor?.text === undefined) {\n      return [];\n    }\n\n    const startMatch = expectSingleSpan(\n      this.#projection.findExactMatches(startAnchor.text),\n    );\n\n    if (startMatch === undefined) {\n      return [];\n    }\n\n    const endValue = evidence.end_anchor ?? evidence.end;\n\n    if (endValue === undefined) {\n      return this.#projection.resolveSentenceIds(startMatch);\n    }\n\n    const [endAnchor, endFailure] = this.#evidenceResolver.parseAnchor(\n      endValue,\n      \"end_anchor\",\n    );\n\n    if (endFailure !== undefined || endAnchor?.text === undefined) {\n      return [];\n    }\n\n    const endMatch = expectSingleSpan(\n      this.#projection.findExactMatches(endAnchor.text),\n    );\n\n    if (endMatch === undefined || endMatch.offset < startMatch.offset) {\n      return [];\n    }\n\n    return this.#projection.resolveSentenceIds({\n      length: endMatch.offset + endMatch.length - startMatch.offset,\n      offset: startMatch.offset,\n    });\n  }\n\n  async #chooseAmbiguousCandidate(\n    input: SelectAmbiguousCandidateInput,\n  ): Promise<\n    readonly [\n      candidate: RankedSentenceCandidate | undefined,\n      failure: EvidenceResolutionFailure | undefined,\n    ]\n  > {\n    const messages = this.#buildChoiceMessages(input);\n    const candidateIds = input.candidates.map(\n      (candidate) => candidate.occurrenceId,\n    );\n\n    try {\n      const choice = await requestGuaranteedJson({\n        maxRetries: MAX_CHOICE_RETRIES,\n        messages,\n        parse: (data) => {\n          const candidate = input.candidates.find(\n            (item) => item.occurrenceId === data.choice,\n          );\n\n          if (candidate === undefined) {\n            throw new ParsedJsonError([\n              `Invalid choice \"${data.choice}\". Expected one of: ${candidateIds.join(\", \")}`,\n            ]);\n          }\n\n          return candidate;\n        },\n        responseIntentClassifierPrompt: this.#responseIntentClassifierPrompt,\n        request: this.#requestChoice,\n        schema: choiceResponseSchema,\n      });\n\n      return [choice, undefined];\n    } catch (error) {\n      if (isParsedJsonValidationFailure(error)) {\n        return [\n          undefined,\n          {\n            candidates: input.candidates,\n            code: \"choice_parse_failed_full_fragment\",\n            fieldName: input.fieldName,\n            message:\n              `Second-stage choice parse validation failed for ${input.fieldName}; ` +\n              \"falling back to the full fragment span.\",\n          },\n        ];\n      }\n\n      return [\n        undefined,\n        {\n          candidates: input.candidates,\n          code: \"choice_failed\",\n          fieldName: input.fieldName,\n          message: `Second-stage choice failed for ${input.fieldName}: ${formatError(error)}`,\n        },\n      ];\n    }\n  }\n\n  #buildChoiceMessages(input: SelectAmbiguousCandidateInput): LLMessage[] {\n    return [\n      {\n        content: this.#choiceSystemPrompt,\n        role: \"system\",\n      },\n      {\n        content:\n          `Previously generated chunk (do NOT rewrite it):\\n` +\n          `\\`\\`\\`json\\n${JSON.stringify(input.chunkData, null, 2)}\\n\\`\\`\\`\\n\\n` +\n          `Resolve only this field: \"${input.fieldName}\" for chunk #${input.chunkIndex} [${input.chunkLabel}].\\n` +\n          \"Choose exactly one candidate occurrence ID from the list below.\\n\\n\" +\n          input.candidates.map(formatChoiceCandidate).join(\"\\n\"),\n        role: \"user\",\n      },\n    ];\n  }\n}\n"],"mappings":"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","names":["resolved","resolveFailure"]}

package/dist/text/reader/chunk-batch/parser/schema.d.ts

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+import { ChunkRetention, ChunkImportance } from '../../../../document/types.js';
+import { RankedSentenceCandidate } from '../../../../graph/evidence-selection/anchor/types.js';
+import { LLMessage } from '../../../../external/llm/types.js';
+import { ChunkBatch } from '../types.js';
+import 'ai';
+import '../../../../runtime/common/language.js';
+import '../../../../external/llm/client/core.js';
+import '../../../../external/llm/context.js';
+import '../../../../external/llm/cache.js';
+
+declare const chunkLinkSchema: z.ZodObject<{
+    from: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    strength: z.ZodOptional<z.ZodString>;
+    to: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+}, z.core.$strip>;
+declare const chunkEvidenceSchema: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodObject<{
+    quote: z.ZodOptional<z.ZodString>;
+    sentence_id: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>>]>;
+declare const userFocusedChunkSchema: z.ZodObject<{
+    content: z.ZodString;
+    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodObject<{
+        quote: z.ZodOptional<z.ZodString>;
+        sentence_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>]>>>;
+    label: z.ZodString;
+    retention: z.ZodEnum<{
+        verbatim: ChunkRetention.Verbatim;
+        detailed: ChunkRetention.Detailed;
+        focused: ChunkRetention.Focused;
+        relevant: ChunkRetention.Relevant;
+    }>;
+    temp_id: z.ZodString;
+}, z.core.$loose>;
+declare const userFocusedResponseSchema: z.ZodObject<{
+    chunks: z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        evidence: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodObject<{
+            quote: z.ZodOptional<z.ZodString>;
+            sentence_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>]>>>;
+        label: z.ZodString;
+        retention: z.ZodEnum<{
+            verbatim: ChunkRetention.Verbatim;
+            detailed: ChunkRetention.Detailed;
+            focused: ChunkRetention.Focused;
+            relevant: ChunkRetention.Relevant;
+        }>;
+        temp_id: z.ZodString;
+    }, z.core.$loose>>;
+    fragment_summary: z.ZodString;
+    links: z.ZodArray<z.ZodObject<{
+        from: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+        strength: z.ZodOptional<z.ZodString>;
+        to: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const bookCoherenceChunkSchema: z.ZodObject<{
+    content: z.ZodString;
+    evidence: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodObject<{
+        quote: z.ZodOptional<z.ZodString>;
+        sentence_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>]>>>;
+    importance: z.ZodEnum<{
+        critical: ChunkImportance.Critical;
+        important: ChunkImportance.Important;
+        helpful: ChunkImportance.Helpful;
+    }>;
+    label: z.ZodString;
+    temp_id: z.ZodString;
+}, z.core.$loose>;
+declare const bookCoherenceResponseSchema: z.ZodObject<{
+    chunks: z.ZodArray<z.ZodObject<{
+        content: z.ZodString;
+        evidence: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodObject<{
+            quote: z.ZodOptional<z.ZodString>;
+            sentence_id: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>]>>>;
+        importance: z.ZodEnum<{
+            critical: ChunkImportance.Critical;
+            important: ChunkImportance.Important;
+            helpful: ChunkImportance.Helpful;
+        }>;
+        label: z.ZodString;
+        temp_id: z.ZodString;
+    }, z.core.$loose>>;
+    importance_annotations: z.ZodArray<z.ZodObject<{
+        chunk_id: z.ZodNumber;
+        importance: z.ZodEnum<{
+            critical: ChunkImportance.Critical;
+            important: ChunkImportance.Important;
+            helpful: ChunkImportance.Helpful;
+        }>;
+    }, z.core.$strip>>;
+    links: z.ZodArray<z.ZodObject<{
+        from: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+        strength: z.ZodOptional<z.ZodString>;
+        to: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const choiceResponseSchema: z.ZodObject<{
+    choice: z.ZodString;
+}, z.core.$strip>;
+type UserFocusedChunkData = z.infer<typeof userFocusedChunkSchema>;
+type BookCoherenceChunkData = z.infer<typeof bookCoherenceChunkSchema>;
+type UserFocusedResponseData = z.infer<typeof userFocusedResponseSchema>;
+type BookCoherenceResponseData = z.infer<typeof bookCoherenceResponseSchema>;
+type ExtractedChunkData = UserFocusedChunkData | BookCoherenceChunkData;
+type RawChunkLink = z.infer<typeof chunkLinkSchema>;
+type RawChunkEvidence = z.infer<typeof chunkEvidenceSchema>;
+type ChoiceFieldName = "evidence" | "start_anchor" | "end_anchor";
+declare enum ChunkMetadataField {
+    Retention = "retention",
+    Importance = "importance"
+}
+interface ExtractChunksResult {
+    readonly chunkBatch: ChunkBatch;
+    readonly fragmentSummary?: string;
+}
+interface ResolveChunkEvidenceInput {
+    readonly data: ExtractedChunkData;
+    readonly chunkIndex: number;
+    readonly chunkLabel: string;
+    readonly isLastGenerationAttempt: boolean;
+}
+interface SelectAmbiguousCandidateInput {
+    readonly candidates: readonly RankedSentenceCandidate[];
+    readonly chunkData: ExtractedChunkData;
+    readonly chunkIndex: number;
+    readonly chunkLabel: string;
+    readonly fieldName: ChoiceFieldName;
+}
+type GuaranteedChoiceRequest = (messages: readonly LLMessage[], index: number, maxRetries: number) => Promise<string>;
+
+export { type BookCoherenceChunkData, type BookCoherenceResponseData, type ChoiceFieldName, ChunkMetadataField, type ExtractChunksResult, type ExtractedChunkData, type GuaranteedChoiceRequest, type RawChunkEvidence, type RawChunkLink, type ResolveChunkEvidenceInput, type SelectAmbiguousCandidateInput, type UserFocusedChunkData, type UserFocusedResponseData, bookCoherenceResponseSchema, choiceResponseSchema, userFocusedResponseSchema };

package/dist/text/reader/chunk-batch/parser/schema.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import { ChunkImportance, ChunkRetention } from "../../../../document/index.js";
+const chunkLinkSchema = z.object({
+  from: z.union([z.number().int(), z.string()]),
+  strength: z.string().optional(),
+  to: z.union([z.number().int(), z.string()])
+});
+const evidenceSelectionItemSchema = z.object({
+  quote: z.string().optional(),
+  sentence_id: z.string().optional()
+}).passthrough();
+const chunkEvidenceSchema = z.union([
+  z.record(z.string(), z.unknown()),
+  z.array(evidenceSelectionItemSchema)
+]);
+const userFocusedChunkSchema = z.object({
+  content: z.string(),
+  evidence: chunkEvidenceSchema.nullish(),
+  label: z.string(),
+  retention: z.enum([
+    ChunkRetention.Verbatim,
+    ChunkRetention.Detailed,
+    ChunkRetention.Focused,
+    ChunkRetention.Relevant
+  ]),
+  temp_id: z.string()
+}).passthrough();
+const userFocusedResponseSchema = z.object({
+  chunks: z.array(userFocusedChunkSchema),
+  fragment_summary: z.string(),
+  links: z.array(chunkLinkSchema)
+});
+const bookCoherenceChunkSchema = z.object({
+  content: z.string(),
+  evidence: chunkEvidenceSchema.nullish(),
+  importance: z.enum([
+    ChunkImportance.Critical,
+    ChunkImportance.Important,
+    ChunkImportance.Helpful
+  ]),
+  label: z.string(),
+  temp_id: z.string()
+}).passthrough();
+const importanceAnnotationSchema = z.object({
+  chunk_id: z.number().int(),
+  importance: z.enum([
+    ChunkImportance.Critical,
+    ChunkImportance.Important,
+    ChunkImportance.Helpful
+  ])
+});
+const bookCoherenceResponseSchema = z.object({
+  chunks: z.array(bookCoherenceChunkSchema),
+  importance_annotations: z.array(importanceAnnotationSchema),
+  links: z.array(chunkLinkSchema)
+});
+const choiceResponseSchema = z.object({
+  choice: z.string()
+});
+var ChunkMetadataField = /* @__PURE__ */ ((ChunkMetadataField2) => {
+  ChunkMetadataField2["Retention"] = "retention";
+  ChunkMetadataField2["Importance"] = "importance";
+  return ChunkMetadataField2;
+})(ChunkMetadataField || {});
+export {
+  ChunkMetadataField,
+  bookCoherenceResponseSchema,
+  choiceResponseSchema,
+  userFocusedResponseSchema
+};
+//# sourceMappingURL=schema.js.map

package/dist/text/reader/chunk-batch/parser/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/text/reader/chunk-batch/parser/schema.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { ChunkImportance, ChunkRetention } from \"../../../../document/index.js\";\nimport type { RankedSentenceCandidate } from \"../../../../graph/evidence-selection/index.js\";\nimport type { LLMessage } from \"../../../../external/llm/index.js\";\nimport type { ChunkBatch } from \"../types.js\";\n\nconst chunkLinkSchema = z.object({\n  from: z.union([z.number().int(), z.string()]),\n  strength: z.string().optional(),\n  to: z.union([z.number().int(), z.string()]),\n});\nconst evidenceSelectionItemSchema = z\n  .object({\n    quote: z.string().optional(),\n    sentence_id: z.string().optional(),\n  })\n  .passthrough();\nconst chunkEvidenceSchema = z.union([\n  z.record(z.string(), z.unknown()),\n  z.array(evidenceSelectionItemSchema),\n]);\n\nconst userFocusedChunkSchema = z\n  .object({\n    content: z.string(),\n    evidence: chunkEvidenceSchema.nullish(),\n    label: z.string(),\n    retention: z.enum([\n      ChunkRetention.Verbatim,\n      ChunkRetention.Detailed,\n      ChunkRetention.Focused,\n      ChunkRetention.Relevant,\n    ]),\n    temp_id: z.string(),\n  })\n  .passthrough();\n\nexport const userFocusedResponseSchema = z.object({\n  chunks: z.array(userFocusedChunkSchema),\n  fragment_summary: z.string(),\n  links: z.array(chunkLinkSchema),\n});\n\nconst bookCoherenceChunkSchema = z\n  .object({\n    content: z.string(),\n    evidence: chunkEvidenceSchema.nullish(),\n    importance: z.enum([\n      ChunkImportance.Critical,\n      ChunkImportance.Important,\n      ChunkImportance.Helpful,\n    ]),\n    label: z.string(),\n    temp_id: z.string(),\n  })\n  .passthrough();\n\nconst importanceAnnotationSchema = z.object({\n  chunk_id: z.number().int(),\n  importance: z.enum([\n    ChunkImportance.Critical,\n    ChunkImportance.Important,\n    ChunkImportance.Helpful,\n  ]),\n});\n\nexport const bookCoherenceResponseSchema = z.object({\n  chunks: z.array(bookCoherenceChunkSchema),\n  importance_annotations: z.array(importanceAnnotationSchema),\n  links: z.array(chunkLinkSchema),\n});\n\nexport const choiceResponseSchema = z.object({\n  choice: z.string(),\n});\n\nexport type UserFocusedChunkData = z.infer<typeof userFocusedChunkSchema>;\nexport type BookCoherenceChunkData = z.infer<typeof bookCoherenceChunkSchema>;\nexport type UserFocusedResponseData = z.infer<typeof userFocusedResponseSchema>;\nexport type BookCoherenceResponseData = z.infer<\n  typeof bookCoherenceResponseSchema\n>;\nexport type ExtractedChunkData = UserFocusedChunkData | BookCoherenceChunkData;\nexport type RawChunkLink = z.infer<typeof chunkLinkSchema>;\nexport type RawChunkEvidence = z.infer<typeof chunkEvidenceSchema>;\nexport type ChoiceFieldName = \"evidence\" | \"start_anchor\" | \"end_anchor\";\n\nexport enum ChunkMetadataField {\n  Retention = \"retention\",\n  Importance = \"importance\",\n}\n\nexport interface ExtractChunksResult {\n  readonly chunkBatch: ChunkBatch;\n  readonly fragmentSummary?: string;\n}\n\nexport interface ResolveChunkEvidenceInput {\n  readonly data: ExtractedChunkData;\n  readonly chunkIndex: number;\n  readonly chunkLabel: string;\n  readonly isLastGenerationAttempt: boolean;\n}\n\nexport interface SelectAmbiguousCandidateInput {\n  readonly candidates: readonly RankedSentenceCandidate[];\n  readonly chunkData: ExtractedChunkData;\n  readonly chunkIndex: number;\n  readonly chunkLabel: string;\n  readonly fieldName: ChoiceFieldName;\n}\n\nexport type GuaranteedChoiceRequest = (\n  messages: readonly LLMessage[],\n  index: number,\n  maxRetries: number,\n) => Promise<string>;\n"],"mappings":"AAAA,SAAS,SAAS;AAElB,SAAS,iBAAiB,sBAAsB;AAKhD,MAAM,kBAAkB,EAAE,OAAO;AAAA,EAC/B,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,GAAG,EAAE,OAAO,CAAC,CAAC;AAAA,EAC5C,UAAU,EAAE,OAAO,EAAE,SAAS;AAAA,EAC9B,IAAI,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,GAAG,EAAE,OAAO,CAAC,CAAC;AAC5C,CAAC;AACD,MAAM,8BAA8B,EACjC,OAAO;AAAA,EACN,OAAO,EAAE,OAAO,EAAE,SAAS;AAAA,EAC3B,aAAa,EAAE,OAAO,EAAE,SAAS;AACnC,CAAC,EACA,YAAY;AACf,MAAM,sBAAsB,EAAE,MAAM;AAAA,EAClC,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC;AAAA,EAChC,EAAE,MAAM,2BAA2B;AACrC,CAAC;AAED,MAAM,yBAAyB,EAC5B,OAAO;AAAA,EACN,SAAS,EAAE,OAAO;AAAA,EAClB,UAAU,oBAAoB,QAAQ;AAAA,EACtC,OAAO,EAAE,OAAO;AAAA,EAChB,WAAW,EAAE,KAAK;AAAA,IAChB,eAAe;AAAA,IACf,eAAe;AAAA,IACf,eAAe;AAAA,IACf,eAAe;AAAA,EACjB,CAAC;AAAA,EACD,SAAS,EAAE,OAAO;AACpB,CAAC,EACA,YAAY;AAER,MAAM,4BAA4B,EAAE,OAAO;AAAA,EAChD,QAAQ,EAAE,MAAM,sBAAsB;AAAA,EACtC,kBAAkB,EAAE,OAAO;AAAA,EAC3B,OAAO,EAAE,MAAM,eAAe;AAChC,CAAC;AAED,MAAM,2BAA2B,EAC9B,OAAO;AAAA,EACN,SAAS,EAAE,OAAO;AAAA,EAClB,UAAU,oBAAoB,QAAQ;AAAA,EACtC,YAAY,EAAE,KAAK;AAAA,IACjB,gBAAgB;AAAA,IAChB,gBAAgB;AAAA,IAChB,gBAAgB;AAAA,EAClB,CAAC;AAAA,EACD,OAAO,EAAE,OAAO;AAAA,EAChB,SAAS,EAAE,OAAO;AACpB,CAAC,EACA,YAAY;AAEf,MAAM,6BAA6B,EAAE,OAAO;AAAA,EAC1C,UAAU,EAAE,OAAO,EAAE,IAAI;AAAA,EACzB,YAAY,EAAE,KAAK;AAAA,IACjB,gBAAgB;AAAA,IAChB,gBAAgB;AAAA,IAChB,gBAAgB;AAAA,EAClB,CAAC;AACH,CAAC;AAEM,MAAM,8BAA8B,EAAE,OAAO;AAAA,EAClD,QAAQ,EAAE,MAAM,wBAAwB;AAAA,EACxC,wBAAwB,EAAE,MAAM,0BAA0B;AAAA,EAC1D,OAAO,EAAE,MAAM,eAAe;AAChC,CAAC;AAEM,MAAM,uBAAuB,EAAE,OAAO;AAAA,EAC3C,QAAQ,EAAE,OAAO;AACnB,CAAC;AAaM,IAAK,qBAAL,kBAAKA,wBAAL;AACL,EAAAA,oBAAA,eAAY;AACZ,EAAAA,oBAAA,gBAAa;AAFH,SAAAA;AAAA,GAAA;","names":["ChunkMetadataField"]}

package/dist/text/reader/chunk-batch/prompt-templates.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/text/reader/chunk-batch/prompt-templates.ts"],"sourcesContent":["export const USER_FOCUSED_PROMPT_TEMPLATE =\n  \"topologization/user_focused_extraction\";\nexport const BOOK_COHERENCE_PROMPT_TEMPLATE =\n  \"topologization/book_coherence_extraction\";\nexport const EVIDENCE_CHOICE_PROMPT_TEMPLATE = \"topologization/evidence_choice\";\nexport const TRANSLATE_CHUNKS_PROMPT_TEMPLATE =\n  \"topologization/translate_chunks\";\n"],"mappings":"AAAO,MAAM,+BACX;AACK,MAAM,iCACX;AACK,MAAM,kCAAkC;AACxC,MAAM,mCACX;","names":[]}

package/dist/text/reader/chunk-batch/types.d.ts

@@ -0,0 +1,85 @@
+import { Language } from '../../../runtime/common/language.js';
+import { LLM } from '../../../external/llm/client/core.js';
+import { SentenceId, ChunkRetention, ChunkImportance } from '../../../document/types.js';
+import '../../../external/llm/context.js';
+import '../../../external/llm/cache.js';
+import '../../../external/llm/types.js';
+import 'ai';
+
+interface ChunkLink {
+    readonly from: number | string;
+    readonly strength?: string;
+    readonly to: number | string;
+}
+interface ChunkImportanceAnnotation {
+    readonly chunkId: number;
+    readonly importance: ChunkImportance;
+}
+interface CognitiveChunk {
+    id: number;
+    generation: number;
+    sentenceId: SentenceId;
+    label: string;
+    content: string;
+    sentenceIds: SentenceId[];
+    links: number[];
+    retention?: ChunkRetention;
+    importance?: ChunkImportance;
+    wordsCount: number;
+}
+interface ChunkBatch {
+    readonly chunks: CognitiveChunk[];
+    readonly tempIds: string[];
+    readonly links: readonly ChunkLink[];
+    readonly orderCorrect: boolean;
+    readonly importanceAnnotations?: readonly ChunkImportanceAnnotation[];
+}
+interface ChunkExtractionScopes<S extends string> {
+    readonly choice: S;
+    readonly extraction: S;
+}
+interface SentenceTextSource {
+    getSentence(sentenceId: SentenceId): Promise<string>;
+}
+interface ChunkTranslationInput {
+    readonly content: string;
+    readonly id: number;
+    readonly label: string;
+    readonly sourceSentences: readonly string[];
+}
+interface ChunkTranslationOutput {
+    readonly content: string;
+    readonly id: number;
+    readonly label: string;
+}
+interface ChunkBatchOptions<S extends string> {
+    readonly extractionGuidance: string;
+    readonly llm: LLM<S>;
+    readonly scopes: ChunkExtractionScopes<S>;
+    readonly sentenceTextSource: SentenceTextSource;
+    readonly userLanguage?: Language;
+}
+interface ChunkExtractionSentence {
+    readonly sentenceId: SentenceId;
+    readonly text: string;
+    readonly wordsCount: number;
+}
+interface ExtractUserFocusedInput {
+    readonly text: string;
+    readonly workingMemoryPrompt: string;
+    readonly visibleChunkIds: readonly number[];
+    readonly sentences: readonly ChunkExtractionSentence[];
+}
+interface ExtractUserFocusedResult {
+    readonly chunkBatch: ChunkBatch;
+    readonly fragmentSummary: string;
+}
+interface ExtractBookCoherenceInput {
+    readonly text: string;
+    readonly workingMemoryPrompt: string;
+    readonly visibleChunkIds: readonly number[];
+    readonly sentences: readonly ChunkExtractionSentence[];
+    readonly userFocusedChunks: readonly CognitiveChunk[];
+}
+
+export type { ChunkBatch, ChunkBatchOptions, ChunkExtractionScopes, ChunkExtractionSentence, ChunkImportanceAnnotation, ChunkLink, ChunkTranslationInput, ChunkTranslationOutput, CognitiveChunk, ExtractBookCoherenceInput, ExtractUserFocusedInput, ExtractUserFocusedResult, SentenceTextSource };

package/dist/text/reader/chunk-batch/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/text/reader/chunk-batch/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}