@orkg/scidquest 1.0.5 → 1.1.4

package/dist/semanticChunker-CNi7GgV8.js

@@ -0,0 +1,84 @@
+var u = Object.defineProperty;
+var p = (a, t, n) => t in a ? u(a, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : a[t] = n;
+var h = (a, t, n) => p(a, typeof t != "symbol" ? t + "" : t, n);
+import { pipeline as g } from "@huggingface/transformers";
+class f {
+  constructor() {
+    h(this, "model", null);
+    h(this, "modelLoading", null);
+  }
+  async initialize() {
+    if (!this.model) {
+      if (this.modelLoading) return this.modelLoading;
+      this.modelLoading = (async () => {
+        try {
+          this.model = await g(
+            "feature-extraction",
+            "Xenova/all-MiniLM-L6-v2",
+            { dtype: "q8" }
+          );
+        } catch (t) {
+          throw console.error("[FrontendSemanticChunker] Model initialization failed:", t), this.modelLoading = null, t;
+        }
+      })(), await this.modelLoading;
+    }
+  }
+  splitIntoChunks(t) {
+    const n = [];
+    for (const r of t) {
+      if (!r.text || r.text.trim().length === 0) continue;
+      const o = r.text.split(new RegExp("(?<=[.!?])(?=\\s)"));
+      let e = "", s = 0;
+      for (const d of o) {
+        const i = d.trim();
+        i && (e && e.length + i.length + 1 > 2e3 ? (n.push({
+          text: e.trim(),
+          pageNumber: r.pageNumber,
+          startIndex: s,
+          endIndex: s + e.length,
+          tokenEstimate: Math.ceil(e.length / 4)
+        }), e = e.trim().split(/\s+/).slice(-Math.ceil(400 / 5)).join(" ") + " " + i, s += e.length - 400) : e += (e ? " " : "") + i);
+      }
+      e.trim() && (n.push({
+        text: e.trim(),
+        pageNumber: r.pageNumber,
+        startIndex: s,
+        endIndex: s + e.length,
+        tokenEstimate: Math.ceil(e.length / 4)
+      }), e = "", s = 0);
+    }
+    return n;
+  }
+  async embed(t) {
+    const n = await this.model(t, { pooling: "mean", normalize: !0 });
+    return Array.from(n.data);
+  }
+  cosineSimilarity(t, n) {
+    let c = 0, l = 0, r = 0;
+    for (let o = 0; o < t.length; o++)
+      c += t[o] * n[o], l += t[o] * t[o], r += n[o] * n[o];
+    return c / (Math.sqrt(l) * Math.sqrt(r));
+  }
+  async findRelevantChunks(t, n, c = 4e3) {
+    await this.initialize();
+    const l = this.splitIntoChunks(n), r = await Promise.all(
+      l.map((i) => this.embed(i.text))
+    ), o = await this.embed(t), e = l.map((i, m) => ({
+      ...i,
+      similarity: this.cosineSimilarity(o, r[m])
+    }));
+    e.sort((i, m) => m.similarity - i.similarity);
+    const s = [];
+    let d = 0;
+    for (const i of e)
+      d + i.tokenEstimate <= c && (s.push(i), d += i.tokenEstimate);
+    return s.sort((i, m) => i.pageNumber - m.pageNumber), s;
+  }
+  isInitialized() {
+    return this.model !== null;
+  }
+}
+const S = new f();
+export {
+  S as frontendSemanticChunker
+};

package/dist/services/aiService.d.ts

@@ -0,0 +1,39 @@
+import type { AIProvider, OpenAIModel, GroqModel, MistralModel } from '../store/slices/aiSlice';
+export interface AIConfig {
+    provider: AIProvider;
+    openaiModel: OpenAIModel;
+    groqModel: GroqModel;
+    mistralModel: MistralModel;
+    openaiApiKey: string;
+    groqApiKey: string;
+    mistralApiKey: string;
+    useEnvironmentKeys: boolean;
+}
+export declare class AIService {
+    private config;
+    constructor(config: AIConfig);
+    private getApiKey;
+    private createProvider;
+    private getModel;
+    getEnhancedModel(provider?: AIProvider, modelName?: string): any;
+    generateText(prompt: string, options?: {
+        temperature?: number;
+        maxTokens?: number;
+        provider?: AIProvider;
+        model?: string;
+        systemContext?: string;
+    }): Promise<{
+        text: string;
+        reasoning?: string;
+        usage?: any;
+    }>;
+    isConfigured(): boolean;
+    getCurrentConfig(): {
+        provider: AIProvider;
+        model: string;
+        apiKeyConfigured: boolean;
+    };
+    generateSuggestions(request: any): Promise<any>;
+}
+export declare const useAIService: () => AIService;
+export declare const createDefaultAIService: () => AIService;

package/dist/services/backendAIService.d.ts

@@ -0,0 +1,191 @@
+import type { AIProvider, OpenAIModel, GroqModel, MistralModel } from '../store/slices/aiSlice';
+import { type GenerateSuggestionsRequest, type GenerateSuggestionsResponse } from '../utils/suggestions';
+export interface BackendAIConfig {
+    provider: AIProvider;
+    openaiModel: OpenAIModel;
+    groqModel: GroqModel;
+    mistralModel: MistralModel;
+    useEnvironmentKeys: boolean;
+}
+export interface GenerateTextRequest {
+    prompt: string;
+    provider?: AIProvider;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemContext?: string;
+}
+export interface GenerateTextResponse {
+    text: string;
+    reasoning?: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+export interface AIConfigResponse {
+    provider: AIProvider;
+    model: string;
+    apiKeyConfigured: boolean;
+}
+export interface VerificationEvidence {
+    pageNumber: number;
+    excerpt: string;
+    supportsAnswer: boolean;
+}
+export interface AIVerificationResult {
+    questionId: string;
+    status: 'verified' | 'needs_improvement' | 'error';
+    feedback?: string;
+    suggestions?: string[];
+    confidence: number;
+    qualityScore?: number;
+    evidence?: VerificationEvidence[];
+    /** Optional model chain-of-thought / rationale from the host `LLMService`. */
+    reasoning?: string;
+}
+export interface VerifyAnswerRequest {
+    questionId: string;
+    questionText: string;
+    currentAnswer: string;
+    questionType?: string;
+    /** Allowed labels for select / multi_select style questions (optional). */
+    questionOptions?: string[];
+    context?: string;
+    pdfContent?: string;
+}
+export interface VerifyAnswerResponse {
+    result: AIVerificationResult;
+}
+export interface BatchVerifyRequest {
+    verifications: VerifyAnswerRequest[];
+}
+export interface BatchVerifyResponse {
+    results: AIVerificationResult[];
+}
+export declare class BackendAIService {
+    private baseUrl;
+    private config;
+    constructor(config: BackendAIConfig);
+    private makeRequest;
+    generateText(prompt: string, options?: {
+        temperature?: number;
+        maxTokens?: number;
+        provider?: AIProvider;
+        model?: string;
+        systemContext?: string;
+    }): Promise<{
+        text: string;
+        reasoning?: string;
+    }>;
+    getConfiguration(): Promise<AIConfigResponse>;
+    checkHealth(): Promise<{
+        status: string;
+        timestamp: string;
+        aiConfigured: boolean;
+    }>;
+    /**
+     * Verify a single answer for quality and completeness
+     */
+    verifyAnswer(request: VerifyAnswerRequest): Promise<AIVerificationResult>;
+    /**
+     * Verify multiple answers in batch
+     */
+    verifyAnswersBatch(requests: VerifyAnswerRequest[]): Promise<AIVerificationResult[]>;
+    /**
+     * Get relevant PDF chunks using transformer-based semantic chunking (in-browser)
+     * Uses Xenova/all-MiniLM-L6-v2 for embedding + cosine similarity
+     */
+    getSemanticChunks(question: string, pages: Array<{
+        pageNumber: number;
+        text: string;
+        wordCount: number;
+    }>, maxTokens?: number): Promise<{
+        chunks: Array<{
+            text: string;
+            pageNumber: number;
+            similarity: number;
+            tokenEstimate: number;
+        }>;
+        totalTokens: number;
+        totalChunks: number;
+    }>;
+    generateSuggestions(request: GenerateSuggestionsRequest): Promise<GenerateSuggestionsResponse>;
+    isConfigured(): boolean;
+    getCurrentConfig(): {
+        provider: AIProvider;
+        model: string;
+        apiKeyConfigured: boolean;
+    };
+}
+/**
+ * Unified AI Service that automatically chooses between frontend and backend
+ * - Uses frontend service when user provides their own API keys (privacy-first)
+ * - Uses backend service when using shared/environment keys
+ */
+export declare class UnifiedAIService {
+    private frontendService;
+    private backendService;
+    private config;
+    constructor(config: {
+        provider: AIProvider;
+        openaiModel: OpenAIModel;
+        groqModel: GroqModel;
+        mistralModel: MistralModel;
+        openaiApiKey: string;
+        groqApiKey: string;
+        mistralApiKey: string;
+        useEnvironmentKeys: boolean;
+    });
+    /**
+     * Determines if we should use frontend service (user's own API keys)
+     * Returns true if user has provided their own API keys and is not using environment keys
+     */
+    private shouldUseFrontend;
+    private getFrontendService;
+    private getBackendService;
+    generateText(prompt: string, options?: {
+        temperature?: number;
+        maxTokens?: number;
+        provider?: AIProvider;
+        model?: string;
+        systemContext?: string;
+    }): Promise<{
+        text: string;
+        reasoning?: string;
+    }>;
+    generateSuggestions(request: GenerateSuggestionsRequest): Promise<GenerateSuggestionsResponse>;
+    getSemanticChunks(question: string, pages: Array<{
+        pageNumber: number;
+        text: string;
+        wordCount: number;
+    }>, maxTokens?: number): Promise<{
+        chunks: Array<{
+            text: string;
+            pageNumber: number;
+            similarity: number;
+            tokenEstimate: number;
+        }>;
+        totalTokens: number;
+        totalChunks: number;
+    }>;
+    getConfiguration(): Promise<AIConfigResponse>;
+    checkHealth(): Promise<{
+        status: string;
+        timestamp: string;
+        aiConfigured: boolean;
+    }>;
+    isConfigured(): boolean;
+    getCurrentConfig(): {
+        provider: AIProvider;
+        model: string;
+        apiKeyConfigured: boolean;
+    };
+    verifyAnswer(request: VerifyAnswerRequest): Promise<AIVerificationResult>;
+    verifyAnswersBatch(requests: VerifyAnswerRequest[]): Promise<AIVerificationResult[]>;
+}
+export declare const useBackendAIService: () => BackendAIService;
+export declare const useAIService: () => UnifiedAIService;
+export declare const createDefaultBackendAIService: () => BackendAIService;
+export declare const createDefaultAIService: () => UnifiedAIService;

package/dist/store/hooks.d.ts

@@ -0,0 +1,4 @@
+import { TypedUseSelectorHook } from 'react-redux';
+import type { RootState, AppDispatch } from './store';
+export declare const useAppDispatch: () => AppDispatch;
+export declare const useAppSelector: TypedUseSelectorHook<RootState>;

package/dist/store/slices/aiSlice.d.ts

@@ -0,0 +1,21 @@
+export declare const OPENAI_MODELS: readonly ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-4", "gpt-3.5-turbo"];
+export declare const GROQ_MODELS: readonly ["llama-3.1-8b-instant", "llama-3.1-70b-versatile", "llama-3.1-405b-reasoning", "mixtral-8x7b-32768", "gemma-7b-it", "deepseek-r1-distill-llama-70b"];
+export declare const MISTRAL_MODELS: readonly ["mistral-large-latest", "mistral-medium-latest", "mistral-small-latest", "pixtral-large-latest", "open-mistral-nemo"];
+export type OpenAIModel = (typeof OPENAI_MODELS)[number];
+export type GroqModel = (typeof GROQ_MODELS)[number];
+export type MistralModel = (typeof MISTRAL_MODELS)[number];
+export type AIProvider = 'openai' | 'groq' | 'mistral';
+export interface InitialState {
+    provider: AIProvider;
+    openaiModel: OpenAIModel;
+    groqModel: GroqModel;
+    mistralModel: MistralModel;
+    openaiApiKey: string;
+    groqApiKey: string;
+    mistralApiKey: string;
+    isConfigured: boolean;
+    useEnvironmentKeys: boolean;
+}
+export declare const setProvider: import("@reduxjs/toolkit").ActionCreatorWithPayload<AIProvider, "ai/setProvider">, setOpenAIModel: import("@reduxjs/toolkit").ActionCreatorWithPayload<"gpt-4o" | "gpt-4o-mini" | "gpt-4-turbo" | "gpt-4" | "gpt-3.5-turbo", "ai/setOpenAIModel">, setGroqModel: import("@reduxjs/toolkit").ActionCreatorWithPayload<"llama-3.1-8b-instant" | "llama-3.1-70b-versatile" | "llama-3.1-405b-reasoning" | "mixtral-8x7b-32768" | "gemma-7b-it" | "deepseek-r1-distill-llama-70b", "ai/setGroqModel">, setMistralModel: import("@reduxjs/toolkit").ActionCreatorWithPayload<"mistral-large-latest" | "mistral-medium-latest" | "mistral-small-latest" | "pixtral-large-latest" | "open-mistral-nemo", "ai/setMistralModel">, setOpenAIApiKey: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "ai/setOpenAIApiKey">, setGroqApiKey: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "ai/setGroqApiKey">, setMistralApiKey: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "ai/setMistralApiKey">, setIsConfigured: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, "ai/setIsConfigured">, setUseEnvironmentKeys: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, "ai/setUseEnvironmentKeys">, resetConfiguration: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"ai/resetConfiguration">, clearStoredConfiguration: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"ai/clearStoredConfiguration">;
+declare const _default: import("redux").Reducer<InitialState>;
+export default _default;

package/dist/store/store.d.ts

@@ -0,0 +1,9 @@
+export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
+    ai: import("./slices/aiSlice").InitialState;
+}, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        ai: import("./slices/aiSlice").InitialState;
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;

package/dist/types/context.d.ts

@@ -0,0 +1,39 @@
+export interface ParentContext {
+    questionText: string;
+    answer: string | object;
+    questionId: string;
+    questionType?: string;
+    parentChain?: ParentContext[];
+}
+export interface SiblingContext {
+    questionText: string;
+    answer: string | object;
+    questionId: string;
+    answeredAt: number;
+}
+export interface PreviousEntryContext {
+    entryNumber: number;
+    questions: Array<{
+        questionText: string;
+        answer: string | object;
+        questionId: string;
+    }>;
+}
+export interface ContextGatheringConfig {
+    includeParent: boolean;
+    includeSiblings: boolean;
+    maxSiblings: number;
+    includePreviousEntries: boolean;
+    maxPreviousEntries: number;
+    maxAnswerLength: number;
+    tokenLimits?: Partial<TokenLimits>;
+}
+export interface TokenLimits {
+    parentContext: number;
+    siblingContext: number;
+    previousEntryContext: number;
+    perSibling: number;
+    perPreviousEntry: number;
+}
+export declare const DEFAULT_TOKEN_LIMITS: TokenLimits;
+export declare const DEFAULT_CONTEXT_CONFIG: ContextGatheringConfig;

package/dist/utils/contextGatherer.d.ts

@@ -0,0 +1,39 @@
+import type { SiblingContext, PreviousEntryContext, ContextGatheringConfig, ParentContext, TokenLimits } from '../types/context';
+import { TokenEstimator } from './tokenEstimator';
+interface QuestionDefinition {
+    id: string;
+    label?: string;
+    [key: string]: any;
+}
+export declare class ContextGatherer {
+    private config;
+    private tokenEstimator;
+    private visitedQuestions;
+    constructor(config?: Partial<ContextGatheringConfig>, tokenLimits?: Partial<TokenLimits>);
+    gatherSiblingContext(currentQuestionId: string, siblingQuestionIds: string[], allAnswers: Record<string, any>, questionDefinitions: Record<string, QuestionDefinition>): SiblingContext[];
+    gatherPreviousEntryContext(currentEntryIndex: number, allEntries: any[], questionDefinitions: QuestionDefinition[]): PreviousEntryContext[];
+    private formatAnswer;
+    private isAnswerValid;
+    private getAnswerTimestamp;
+    updateConfig(config: Partial<ContextGatheringConfig>): void;
+    getConfig(): ContextGatheringConfig;
+    truncateSiblingContext(siblingContext: SiblingContext[], maxTokens: number): SiblingContext[];
+    truncatePreviousEntryContext(previousEntryContext: PreviousEntryContext[], maxTokens: number): PreviousEntryContext[];
+    private truncateEntryQuestions;
+    applyTokenLimits(contexts: {
+        parentContext?: ParentContext;
+        siblingContext?: SiblingContext[];
+        previousEntryContext?: PreviousEntryContext[];
+    }): {
+        truncated: boolean;
+        parentContext?: ParentContext;
+        siblingContext?: SiblingContext[];
+        previousEntryContext?: PreviousEntryContext[];
+    };
+    getTokenEstimator(): TokenEstimator;
+    private resetVisitedQuestions;
+    private hasVisitedQuestion;
+    private markQuestionVisited;
+}
+export declare const contextGatherer: ContextGatherer;
+export {};

package/dist/utils/fuzzyPdfMatcher.d.ts

@@ -0,0 +1,15 @@
+export interface FuzzyMatchResult {
+    found: boolean;
+    startIndex: number;
+    endIndex: number;
+    similarity: number;
+    matchedText: string;
+}
+export declare function normalizeForMatching(text: string): string;
+export declare function aggressiveNormalize(text: string): string;
+export declare function findFuzzyMatch(pdfText: string, searchText: string, options?: {
+    similarityThreshold?: number;
+    useAggressiveNormalization?: boolean;
+    windowSizeMultiplier?: number;
+}): FuzzyMatchResult;
+export declare function findAllFuzzyMatches(pdfText: string, searchText: string, options?: Parameters<typeof findFuzzyMatch>[2]): FuzzyMatchResult[];

package/dist/utils/pdf.d.ts

@@ -0,0 +1,25 @@
+import type { PDFDocumentProxy } from 'pdfjs-dist/types/src/display/api';
+import type { Evidence, EvidenceHighlight, HighlightRect } from './suggestions';
+export declare class PDFTextExtractor {
+    private fullTextCache;
+    private pageTextCache;
+    private documentCache;
+    extractFullText(pdfUrl: string): Promise<string>;
+    extractPageText(pdfUrl: string, pageNumber: number): Promise<string>;
+    extractPageRange(pdfUrl: string, startPage: number, endPage: number): Promise<string>;
+    clearCache(): void;
+    clearDocumentCache(pdfUrl: string): void;
+    private loadDocument;
+    private extractPageTextInternal;
+    getDocumentInfo(pdfUrl: string): Promise<{
+        numPages: number;
+        filename: string;
+    }>;
+}
+export declare const pdfTextExtractor: PDFTextExtractor;
+export declare function loadPDFDocument(pdfUrl: string): Promise<PDFDocumentProxy>;
+export declare function getCachedDocument(pdfUrl: string): PDFDocumentProxy | null;
+export declare function generateEvidenceHighlight(pdfDoc: PDFDocumentProxy, pageWidth: number, evidence: Evidence, suggestionId: string): Promise<EvidenceHighlight | null>;
+export declare function generateEvidenceHighlights(pdfDoc: PDFDocumentProxy, pageWidth: number, evidenceList: Evidence[], suggestionId: string): Promise<EvidenceHighlight[]>;
+export declare function evidenceHighlightsToPageMap(highlights: EvidenceHighlight[]): Record<number, HighlightRect[]>;
+export declare function generateSingleEvidenceHighlightMap(pdfDoc: PDFDocumentProxy, pageWidth: number, evidence: Evidence, suggestionId: string): Promise<Record<number, HighlightRect[]>>;

package/dist/utils/pdfWorker.d.ts

@@ -0,0 +1,10 @@
+export declare function defaultPdfWorkerSrc(): string;
+type PdfJsWorkerHost = {
+    GlobalWorkerOptions: {
+        workerSrc: string;
+    };
+};
+export declare function configurePdfWorker(workerSrc?: string): void;
+/** Configure worker on react-pdf's pdfjs instance (must run after `react-pdf` import). */
+export declare function configureReactPdfWorker(reactPdfJs: PdfJsWorkerHost, workerSrc?: string): void;
+export {};

package/dist/utils/robustPdfMatcher.d.ts

@@ -0,0 +1,22 @@
+export interface RobustMatchResult {
+    found: boolean;
+    startIndex: number;
+    endIndex: number;
+    confidence: number;
+    matchedText: string;
+    strategy: 'exact' | 'normalized' | 'aggressive' | 'fuzzy' | 'token' | 'partial';
+    metadata?: {
+        skippedReferences?: string[];
+        similarity?: number;
+    };
+}
+export interface RobustMatchOptions {
+    similarityThreshold?: number;
+    allowSkipReferences?: boolean;
+    minTokenMatch?: number;
+    tryAllStrategies?: boolean;
+    enablePartialMatch?: boolean;
+}
+export declare function findRobustMatch(pdfText: string, searchText: string, options?: RobustMatchOptions): RobustMatchResult;
+export declare function preprocessSearchText(text: string): string;
+export declare function findAllRobustMatches(pdfText: string, searchTexts: string[], options?: RobustMatchOptions): RobustMatchResult[];

package/dist/utils/semanticChunker.d.ts

@@ -0,0 +1,27 @@
+interface PageContent {
+    pageNumber: number;
+    text: string;
+    wordCount: number;
+}
+interface SemanticChunk {
+    text: string;
+    pageNumber: number;
+    startIndex: number;
+    endIndex: number;
+    tokenEstimate: number;
+}
+interface SemanticChunkWithScore extends SemanticChunk {
+    similarity: number;
+}
+declare class FrontendSemanticChunker {
+    private model;
+    private modelLoading;
+    initialize(): Promise<void>;
+    private splitIntoChunks;
+    private embed;
+    private cosineSimilarity;
+    findRelevantChunks(question: string, pages: PageContent[], maxTokens?: number): Promise<SemanticChunkWithScore[]>;
+    isInitialized(): boolean;
+}
+export declare const frontendSemanticChunker: FrontendSemanticChunker;
+export {};

package/dist/utils/simplePdfMatcher.d.ts

@@ -0,0 +1,13 @@
+export interface SimpleMatchResult {
+    found: boolean;
+    startIndex: number;
+    endIndex: number;
+    confidence: number;
+    strategy: 'exact' | 'normalized' | 'none';
+    matchedText: string;
+}
+export declare function normalizeText(text: string): string;
+export declare function findSimpleMatch(pdfText: string, searchText: string, options?: {
+    maxSearchTime?: number;
+}): SimpleMatchResult;
+export declare function preprocessSearchText(text: string): string;

package/dist/utils/structuredPdfExtractor.d.ts

@@ -0,0 +1,34 @@
+export interface PageContent {
+    pageNumber: number;
+    text: string;
+    wordCount: number;
+}
+export interface DocumentMetadata {
+    filename: string;
+    totalPages: number;
+    totalWords: number;
+    extractedAt: number;
+}
+export interface StructuredDocument {
+    metadata: DocumentMetadata;
+    pages: PageContent[];
+    fullText: string;
+}
+export interface RetrievalResult {
+    content: string;
+    pages: number[];
+    tokenEstimate: number;
+}
+export declare class StructuredPDFExtractor {
+    private documentCache;
+    private pdfDocCache;
+    private loadDocument;
+    private extractPageText;
+    extractStructuredDocument(pdfUrl: string, filename?: string): Promise<StructuredDocument>;
+    getPageContent(document: StructuredDocument, pageNumbers: number[]): RetrievalResult;
+    getFullContent(document: StructuredDocument): RetrievalResult;
+    formatFullDocumentWithPageMarkers(document: StructuredDocument): string;
+    clearCache(pdfUrl: string): void;
+    clearAllCaches(): void;
+}
+export declare const structuredPdfExtractor: StructuredPDFExtractor;

package/dist/utils/suggestions.d.ts

@@ -0,0 +1,88 @@
+export interface AppError extends Error {
+    status?: number;
+    requiresAuth?: boolean;
+    resetIn?: number;
+    resetAt?: string;
+}
+export interface Evidence {
+    pageNumber: number;
+    excerpt: string;
+    context?: string;
+    startIndex?: number;
+    endIndex?: number;
+}
+export interface HighlightRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface EvidenceHighlight {
+    evidence: Evidence;
+    suggestionId: string;
+    rects: HighlightRect[];
+}
+export interface Suggestion {
+    id: string;
+    rank: number;
+    text: string | string[];
+    confidence: number;
+    evidence: Evidence[];
+    createdAt: number;
+}
+export declare function suggestionTextToString(text: string | string[] | any): string;
+export interface FeedbackData {
+    suggestionId: string;
+    questionId: string;
+    rating: 'positive' | 'negative';
+    comment?: string;
+    timestamp: number;
+    userId?: string;
+    suggestionText?: string;
+    suggestionRank?: number;
+}
+export interface GenerateSuggestionsRequest {
+    questionText: string;
+    questionType: string;
+    questionOptions?: string[];
+    pdfContent: string;
+    pdfMetadata?: {
+        filename: string;
+        totalPages: number;
+    };
+    provider?: string;
+    model?: string;
+    previousFeedback?: FeedbackData[];
+    contextHistory?: Array<{
+        id: string;
+        type: string;
+        content: string;
+        timestamp: number;
+        metadata?: any;
+    }>;
+    parentContext?: import('../types/context').ParentContext;
+    siblingContext?: import('../types/context').SiblingContext[];
+    previousEntryContext?: import('../types/context').PreviousEntryContext[];
+}
+export interface GenerateSuggestionsResponse {
+    suggestions: Suggestion[];
+    reasoning?: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+export declare const isAuthError: (error: unknown) => boolean;
+export declare const isRateLimitError: (error: unknown) => boolean;
+export declare const isConfigError: (error: unknown) => boolean;
+export declare const formatErrorMessage: (error: unknown, context?: string) => string;
+export declare class FeedbackService {
+    static saveFeedback(feedback: FeedbackData): void;
+    static getAllFeedback(): FeedbackData[];
+    static getFeedbackForQuestion(questionId: string): FeedbackData[];
+    static clearFeedbackForQuestion(questionId: string): void;
+    static deleteFeedbackBySuggestionId(suggestionId: string): void;
+    static deleteFeedbackBySuggestionIds(suggestionIds: string[]): void;
+    static clearAllFeedback(): void;
+}