@townco/agent 0.1.84 → 0.1.87

package/dist/runner/hooks/predefined/document-context-extractor/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Document Context Extractor
+ *
+ * Main orchestration for extracting relevant information from large tool responses.
+ *
+ * Two-phase approach:
+ * 1. Score all chunks for relevance (0-10)
+ * 2. Extract only from high-scoring chunks
+ *
+ * Falls back to truncation if extraction fails.
+ */
+import type { HookStorageInterface } from "../../types.js";
+import type { ExtractorResult } from "./types.js";
+/**
+ * Main extraction function
+ *
+ * Extracts relevant information from a large tool response using a two-phase approach:
+ * 1. Score all chunks for relevance
+ * 2. Extract from high-scoring chunks
+ */
+export declare function extractDocumentContext(rawOutput: Record<string, unknown>, toolName: string, toolCallId: string, toolInput: Record<string, unknown>, conversationContext: string, targetTokens: number, sessionId: string, storage?: HookStorageInterface): Promise<ExtractorResult>;
+export type { ChunkInfo, ExtractionState, ExtractorConfig, ExtractorResult, } from "./types.js";

package/dist/runner/hooks/predefined/document-context-extractor/index.js

@@ -0,0 +1,338 @@
+/**
+ * Document Context Extractor
+ *
+ * Main orchestration for extracting relevant information from large tool responses.
+ *
+ * Two-phase approach:
+ * 1. Score all chunks for relevance (0-10)
+ * 2. Extract only from high-scoring chunks
+ *
+ * Falls back to truncation if extraction fails.
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import { createLogger } from "../../../../logger.js";
+import { telemetry } from "../../../../telemetry/index.js";
+import { countTokens, countToolResultTokens, } from "../../../../utils/token-counter.js";
+import { calculateChunkSize, calculateMaxIterations, createChunks, getChunkStats, } from "./chunk-manager.js";
+import { extractFromChunks, mergeExtractions } from "./content-extractor.js";
+import { addExtractedContent, createExtractionState, recordError, saveExtractionState, updateChunkScore, updateStatePhase, } from "./extraction-state.js";
+import { filterRelevantChunks, scoreChunks } from "./relevance-scorer.js";
+const logger = createLogger("document-context-extractor");
+// Haiku 4.5 for extraction (fast and cost-effective)
+const EXTRACTION_MODEL = "claude-haiku-4-5-20251001";
+const EXTRACTION_MODEL_CONTEXT = 200000;
+// Default configuration values
+const DEFAULT_RELEVANCE_THRESHOLD = 5;
+const DEFAULT_CHUNK_OVERLAP = 200;
+const DEFAULT_SYSTEM_PROMPT_TOKENS = 500;
+// Create Anthropic client directly (not using LangChain)
+const anthropic = new Anthropic({
+    apiKey: process.env.ANTHROPIC_API_KEY,
+});
+/**
+ * Analyze what information needs to be extracted
+ */
+async function analyzeExtractionRequirements(toolName, toolInput, conversationContext) {
+    const analysisPrompt = `You are helping to extract relevant information from a large tool response.
+
+A tool was just called with these parameters:
+Tool: ${toolName}
+Input: ${JSON.stringify(toolInput, null, 2)}
+
+Recent conversation context:
+${conversationContext}
+
+Based on the tool input and conversation context, what key information is the user looking for from this tool response?
+
+Provide a concise list (3-5 bullet points) of the most important elements to extract.`;
+    const span = telemetry.startSpan("extractor.analysis", {
+        "gen_ai.operation.name": "chat",
+        "gen_ai.provider.name": "anthropic",
+        "gen_ai.request.model": EXTRACTION_MODEL,
+        "gen_ai.system_instructions": "You are a helpful assistant analyzing information needs.",
+    });
+    try {
+        const response = await telemetry.withActiveSpanAsync(span, () => anthropic.messages.create({
+            model: EXTRACTION_MODEL,
+            max_tokens: 1024,
+            temperature: 0,
+            system: "You are a helpful assistant analyzing information needs.",
+            messages: [{ role: "user", content: analysisPrompt }],
+        }));
+        telemetry.recordTokenUsage(response.usage.input_tokens, response.usage.output_tokens, span);
+        telemetry.endSpan(span);
+        const firstContent = response.content[0];
+        return firstContent && firstContent.type === "text"
+            ? firstContent.text
+            : "Extract relevant information";
+    }
+    catch (error) {
+        telemetry.endSpan(span, error);
+        throw error;
+    }
+}
+/**
+ * Perform final compaction of merged extractions if still too large
+ */
+async function compactFinalResult(mergedContent, keyFacts, keyRequirements, targetTokens) {
+    const currentTokens = countTokens(mergedContent);
+    // If already under target, return as structured result
+    if (currentTokens <= targetTokens) {
+        return {
+            extracted_content: mergedContent,
+            key_facts: keyFacts,
+            _extraction_notice: "Content extracted from large tool response",
+        };
+    }
+    // Need to compact further
+    const span = telemetry.startSpan("extractor.final_compaction", {
+        "gen_ai.operation.name": "chat",
+        "gen_ai.provider.name": "anthropic",
+        "gen_ai.request.model": EXTRACTION_MODEL,
+        "extractor.phase": "merging",
+        "extractor.current_tokens": currentTokens,
+        "extractor.target_tokens": targetTokens,
+    });
+    try {
+        const compactionPrompt = `You are condensing extracted information to fit within a token limit.
+
+Key information needed:
+${keyRequirements}
+
+Current extracted content (${currentTokens.toLocaleString()} tokens):
+${mergedContent}
+
+Key facts identified:
+${keyFacts.map((f) => `- ${f}`).join("\n")}
+
+Target size: ${targetTokens.toLocaleString()} tokens (reduce by ${Math.round(((currentTokens - targetTokens) / currentTokens) * 100)}%)
+
+Your task: Create a more concise version that:
+1. Retains all key facts and critical information
+2. Removes redundancy and verbose explanations
+3. Preserves technical details, values, and identifiers
+4. Meets the target token limit
+
+Return ONLY the condensed content (no JSON wrapper needed).`;
+        const response = await telemetry.withActiveSpanAsync(span, () => anthropic.messages.create({
+            model: EXTRACTION_MODEL,
+            max_tokens: Math.min(targetTokens * 2, 8000),
+            temperature: 0,
+            system: "You are a helpful assistant condensing information while preserving key details.",
+            messages: [{ role: "user", content: compactionPrompt }],
+        }));
+        telemetry.recordTokenUsage(response.usage.input_tokens, response.usage.output_tokens, span);
+        telemetry.endSpan(span);
+        const firstContent = response.content[0];
+        const compactedContent = firstContent && firstContent.type === "text"
+            ? firstContent.text
+            : mergedContent;
+        return {
+            extracted_content: compactedContent,
+            key_facts: keyFacts,
+            _extraction_notice: "Content extracted and compacted from large tool response",
+        };
+    }
+    catch (error) {
+        telemetry.endSpan(span, error);
+        // On error, return original content
+        return {
+            extracted_content: mergedContent,
+            key_facts: keyFacts,
+            _extraction_notice: "Content extracted from large tool response (compaction skipped)",
+        };
+    }
+}
+/**
+ * Main extraction function
+ *
+ * Extracts relevant information from a large tool response using a two-phase approach:
+ * 1. Score all chunks for relevance
+ * 2. Extract from high-scoring chunks
+ */
+export async function extractDocumentContext(rawOutput, toolName, toolCallId, toolInput, conversationContext, targetTokens, sessionId, storage) {
+    const startTime = Date.now();
+    // Convert output to string for processing
+    const outputString = JSON.stringify(rawOutput, null, 2);
+    const originalTokens = countToolResultTokens(rawOutput);
+    logger.info("Starting document context extraction", {
+        toolName,
+        toolCallId,
+        originalTokens,
+        targetTokens,
+        sessionId,
+    });
+    // Build configuration
+    const config = {
+        model: EXTRACTION_MODEL,
+        modelContextSize: EXTRACTION_MODEL_CONTEXT,
+        targetTokens,
+        maxIterations: 0, // Will be calculated after chunking
+        systemPromptTokens: DEFAULT_SYSTEM_PROMPT_TOKENS,
+        relevanceThreshold: DEFAULT_RELEVANCE_THRESHOLD,
+        chunkOverlapTokens: DEFAULT_CHUNK_OVERLAP,
+    };
+    // Calculate chunk size and create chunks
+    const chunkSizeTokens = calculateChunkSize(config);
+    const chunks = createChunks(outputString, chunkSizeTokens, config.chunkOverlapTokens);
+    const chunkStats = getChunkStats(chunks);
+    // Update max iterations based on actual chunk count
+    config.maxIterations = calculateMaxIterations(originalTokens, chunkSizeTokens);
+    logger.info("Chunks created", {
+        ...chunkStats,
+        chunkSizeTokens,
+        maxIterations: config.maxIterations,
+    });
+    try {
+        // Step 1: Analyze what to extract
+        const keyRequirements = await analyzeExtractionRequirements(toolName, toolInput, conversationContext);
+        logger.info("Identified extraction requirements", {
+            requirements: keyRequirements.substring(0, 200),
+        });
+        // Initialize state for persistence
+        let state = createExtractionState({
+            sessionId,
+            toolCallId,
+            toolName,
+            originalTokenCount: originalTokens,
+            targetTokens,
+            keyRequirements,
+            chunks,
+            maxIterations: config.maxIterations,
+        });
+        // Save initial state
+        if (storage) {
+            saveExtractionState(storage, state);
+        }
+        // Step 2: Score all chunks (Phase 1)
+        state = updateStatePhase(state, "scoring");
+        if (storage) {
+            saveExtractionState(storage, state);
+        }
+        const scoredChunks = await scoreChunks(chunks, keyRequirements, config, (scored, total) => {
+            // Progress callback - just log progress
+            logger.debug("Scoring progress", { scored, total });
+        });
+        // Update state with all scores after scoring completes
+        for (const scoredChunk of scoredChunks) {
+            if (scoredChunk.relevanceScore !== undefined) {
+                state = updateChunkScore(state, scoredChunk.index, scoredChunk.relevanceScore, scoredChunk.scoreReason ?? "");
+            }
+        }
+        state = {
+            ...state,
+            chunks: scoredChunks,
+        };
+        if (storage) {
+            saveExtractionState(storage, state);
+        }
+        // Check if we have any relevant chunks
+        const relevantChunks = filterRelevantChunks(scoredChunks, config.relevanceThreshold);
+        if (relevantChunks.length === 0) {
+            logger.warn("No chunks met relevance threshold", {
+                threshold: config.relevanceThreshold,
+                avgScore: scoredChunks.reduce((s, c) => s + (c.relevanceScore ?? 0), 0) /
+                    scoredChunks.length,
+            });
+            // Fall back to using top 3 chunks regardless of score
+            const topChunks = scoredChunks.slice(0, 3);
+            relevantChunks.push(...topChunks);
+        }
+        // Step 3: Extract from relevant chunks (Phase 2)
+        state = updateStatePhase(state, "extracting");
+        if (storage) {
+            saveExtractionState(storage, state);
+        }
+        const extractions = await extractFromChunks(scoredChunks, keyRequirements, config, (extracted, _total) => {
+            state = {
+                ...state,
+                currentIteration: extracted,
+            };
+            if (storage) {
+                saveExtractionState(storage, state);
+            }
+        });
+        // Update state with extractions
+        for (const [chunkIndex, result] of extractions) {
+            state = addExtractedContent(state, chunkIndex, result.extracted);
+        }
+        // Step 4: Merge extractions
+        state = updateStatePhase(state, "merging");
+        if (storage) {
+            saveExtractionState(storage, state);
+        }
+        const { content: mergedContent, keyFacts } = mergeExtractions(extractions, scoredChunks);
+        logger.info("Extractions merged", {
+            mergedContentTokens: countTokens(mergedContent),
+            keyFactsCount: keyFacts.length,
+        });
+        // Step 5: Final compaction if needed
+        const result = await compactFinalResult(mergedContent, keyFacts, keyRequirements, targetTokens);
+        const finalTokens = countToolResultTokens(result);
+        // Mark state as complete
+        state = updateStatePhase(state, "complete");
+        if (storage) {
+            saveExtractionState(storage, state);
+        }
+        const duration = Date.now() - startTime;
+        logger.info("Document context extraction complete", {
+            originalTokens,
+            finalTokens,
+            targetTokens,
+            chunksProcessed: chunks.length,
+            chunksExtractedFrom: extractions.size,
+            durationMs: duration,
+        });
+        return {
+            success: true,
+            extractedData: result,
+            extractedTokens: finalTokens,
+            metadata: {
+                originalTokens,
+                targetTokens,
+                chunksProcessed: chunks.length,
+                chunksExtractedFrom: extractions.size,
+                iterationsUsed: state.currentIteration,
+                phase: "complete",
+                averageRelevanceScore: scoredChunks.reduce((s, c) => s + (c.relevanceScore ?? 0), 0) /
+                    scoredChunks.length,
+            },
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error("Document context extraction failed", {
+            toolName,
+            toolCallId,
+            error: errorMessage,
+        });
+        // Update state with error
+        if (storage) {
+            let state = createExtractionState({
+                sessionId,
+                toolCallId,
+                toolName,
+                originalTokenCount: originalTokens,
+                targetTokens,
+                keyRequirements: "",
+                chunks,
+                maxIterations: config.maxIterations,
+            });
+            state = recordError(state, errorMessage);
+            state = updateStatePhase(state, "failed");
+            saveExtractionState(storage, state);
+        }
+        return {
+            success: false,
+            metadata: {
+                originalTokens,
+                targetTokens,
+                chunksProcessed: chunks.length,
+                chunksExtractedFrom: 0,
+                iterationsUsed: 0,
+                phase: "failed",
+            },
+            error: errorMessage,
+        };
+    }
+}

package/dist/runner/hooks/predefined/document-context-extractor/relevance-scorer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Relevance scorer for document chunks
+ *
+ * Phase 1 of extraction: Score each chunk for relevance (0-10)
+ * to determine which chunks should be processed for extraction.
+ */
+import type { ChunkInfo, ExtractorConfig } from "./types.js";
+/**
+ * Score all chunks for relevance
+ *
+ * This is Phase 1 of the extraction process.
+ * Each chunk gets a relevance score (0-10) which determines
+ * whether it will be processed in Phase 2.
+ */
+export declare function scoreChunks(chunks: ChunkInfo[], keyRequirements: string, config: ExtractorConfig, onProgress?: (scored: number, total: number) => void): Promise<ChunkInfo[]>;
+/**
+ * Filter chunks by relevance threshold
+ */
+export declare function filterRelevantChunks(chunks: ChunkInfo[], threshold: number): ChunkInfo[];

package/dist/runner/hooks/predefined/document-context-extractor/relevance-scorer.js

@@ -0,0 +1,156 @@
+/**
+ * Relevance scorer for document chunks
+ *
+ * Phase 1 of extraction: Score each chunk for relevance (0-10)
+ * to determine which chunks should be processed for extraction.
+ */
+import Anthropic from "@anthropic-ai/sdk";
+import { createLogger } from "../../../../logger.js";
+import { telemetry } from "../../../../telemetry/index.js";
+const logger = createLogger("relevance-scorer");
+// Create Anthropic client directly (not using LangChain)
+// This ensures scoring LLM calls don't get captured by LangGraph's streaming
+const anthropic = new Anthropic({
+    apiKey: process.env.ANTHROPIC_API_KEY,
+});
+const SCORING_SYSTEM_PROMPT = `You are evaluating content relevance for information extraction.
+
+Score the following content chunk from 0-10 based on how relevant it is to the extraction requirements.
+
+Scoring guide:
+- 0-2: Not relevant, can be skipped entirely
+- 3-4: Low relevance, minimal useful information
+- 5-6: Moderate relevance, contains some useful context
+- 7-8: Relevant, contains important information
+- 9-10: Highly relevant, contains critical information
+
+Respond with ONLY a JSON object in this exact format:
+{"score": N, "reason": "brief explanation (max 50 words)"}
+
+Do not include any other text before or after the JSON.`;
+/**
+ * Build the scoring prompt for a chunk
+ */
+function buildScoringPrompt(chunkContent, keyRequirements, chunkIndex, totalChunks) {
+    return `## Extraction Requirements
+${keyRequirements}
+
+## Content Chunk (${chunkIndex + 1}/${totalChunks})
+${chunkContent}
+
+## Task
+Score this chunk's relevance to the extraction requirements (0-10).`;
+}
+/**
+ * Parse scoring result from LLM response
+ */
+function parseScoringResult(responseText) {
+    try {
+        // Try to extract JSON from the response
+        const jsonMatch = responseText.match(/\{[\s\S]*?\}/);
+        if (jsonMatch) {
+            const parsed = JSON.parse(jsonMatch[0]);
+            return {
+                score: Math.min(10, Math.max(0, Number(parsed.score) || 5)),
+                reason: String(parsed.reason || "No reason provided"),
+            };
+        }
+    }
+    catch {
+        // Fall through to default
+    }
+    // Try to extract just a number if JSON parsing failed
+    const numberMatch = responseText.match(/\b(\d+)\b/);
+    if (numberMatch) {
+        const score = Math.min(10, Math.max(0, Number(numberMatch[1])));
+        return { score, reason: "Score extracted from response" };
+    }
+    // Default to medium relevance if parsing fails
+    return { score: 5, reason: "Failed to parse scoring response" };
+}
+/**
+ * Score a single chunk for relevance
+ */
+async function scoreChunk(chunk, keyRequirements, totalChunks, config) {
+    const span = telemetry.startSpan("extractor.score_chunk", {
+        "gen_ai.operation.name": "chat",
+        "gen_ai.provider.name": "anthropic",
+        "gen_ai.request.model": config.model,
+        "extractor.phase": "scoring",
+        "extractor.chunk_index": chunk.index,
+        "extractor.chunk_tokens": chunk.tokenCount,
+    });
+    try {
+        const prompt = buildScoringPrompt(chunk.content, keyRequirements, chunk.index, totalChunks);
+        const response = await telemetry.withActiveSpanAsync(span, () => anthropic.messages.create({
+            model: config.model,
+            max_tokens: 256,
+            temperature: 0,
+            system: SCORING_SYSTEM_PROMPT,
+            messages: [{ role: "user", content: prompt }],
+        }));
+        telemetry.recordTokenUsage(response.usage.input_tokens, response.usage.output_tokens, span);
+        telemetry.endSpan(span);
+        const firstContent = response.content[0];
+        const responseText = firstContent && firstContent.type === "text" ? firstContent.text : "";
+        return parseScoringResult(responseText);
+    }
+    catch (error) {
+        telemetry.endSpan(span, error);
+        logger.error("Failed to score chunk", {
+            chunkIndex: chunk.index,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        // Return medium relevance on error to be safe
+        return {
+            score: 5,
+            reason: `Scoring error: ${error instanceof Error ? error.message : "Unknown"}`,
+        };
+    }
+}
+/**
+ * Score all chunks for relevance
+ *
+ * This is Phase 1 of the extraction process.
+ * Each chunk gets a relevance score (0-10) which determines
+ * whether it will be processed in Phase 2.
+ */
+export async function scoreChunks(chunks, keyRequirements, config, onProgress) {
+    logger.info("Starting chunk scoring phase", {
+        totalChunks: chunks.length,
+        relevanceThreshold: config.relevanceThreshold,
+    });
+    const scoredChunks = [];
+    for (const chunk of chunks) {
+        const result = await scoreChunk(chunk, keyRequirements, chunks.length, config);
+        const scoredChunk = {
+            ...chunk,
+            relevanceScore: result.score,
+            scoreReason: result.reason,
+        };
+        scoredChunks.push(scoredChunk);
+        logger.debug("Chunk scored", {
+            chunkIndex: chunk.index,
+            score: result.score,
+            reason: result.reason.substring(0, 100),
+        });
+        onProgress?.(scoredChunks.length, chunks.length);
+    }
+    // Sort by relevance score (highest first)
+    scoredChunks.sort((a, b) => (b.relevanceScore ?? 0) - (a.relevanceScore ?? 0));
+    const relevantCount = scoredChunks.filter((c) => (c.relevanceScore ?? 0) >= config.relevanceThreshold).length;
+    logger.info("Chunk scoring complete", {
+        totalChunks: chunks.length,
+        relevantChunks: relevantCount,
+        threshold: config.relevanceThreshold,
+        averageScore: scoredChunks.reduce((sum, c) => sum + (c.relevanceScore ?? 0), 0) /
+            scoredChunks.length,
+    });
+    return scoredChunks;
+}
+/**
+ * Filter chunks by relevance threshold
+ */
+export function filterRelevantChunks(chunks, threshold) {
+    return chunks.filter((c) => (c.relevanceScore ?? 0) >= threshold);
+}

package/dist/runner/hooks/predefined/document-context-extractor/types.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Types for the document context extractor
+ *
+ * The extractor uses a two-phase approach:
+ * 1. Score all chunks for relevance (0-10)
+ * 2. Extract only from high-scoring chunks
+ */
+/**
+ * Configuration for the document context extractor
+ */
+export interface ExtractorConfig {
+    /** LLM model to use for extraction (e.g., claude-haiku-4-5-20251001) */
+    model: string;
+    /** Model's context window size in tokens */
+    modelContextSize: number;
+    /** Target output size in tokens */
+    targetTokens: number;
+    /** Maximum iterations for the extraction process */
+    maxIterations: number;
+    /** Estimated tokens for system prompt overhead */
+    systemPromptTokens: number;
+    /** Minimum relevance score (0-10) to extract from a chunk */
+    relevanceThreshold: number;
+    /** Token overlap between chunks to maintain context continuity */
+    chunkOverlapTokens: number;
+}
+/**
+ * Information about a single chunk of the document
+ */
+export interface ChunkInfo {
+    /** Index of this chunk in the document (0-based) */
+    index: number;
+    /** Character offset where this chunk starts in the original document */
+    startOffset: number;
+    /** Character offset where this chunk ends in the original document */
+    endOffset: number;
+    /** Estimated token count of this chunk */
+    tokenCount: number;
+    /** The actual content of this chunk */
+    content: string;
+    /** Relevance score (0-10) assigned during scoring phase */
+    relevanceScore?: number;
+    /** Brief reason for the relevance score */
+    scoreReason?: string;
+}
+/**
+ * Extraction phase states
+ */
+export type ExtractionPhase = "initializing" | "scoring" | "extracting" | "merging" | "complete" | "failed";
+/**
+ * State of the extraction process (persisted to artifacts)
+ */
+export interface ExtractionState {
+    /** Session ID for this extraction */
+    sessionId: string;
+    /** Tool call ID that triggered this extraction */
+    toolCallId: string;
+    /** Name of the tool that produced the large response */
+    toolName: string;
+    /** Original token count of the tool response */
+    originalTokenCount: number;
+    /** Target token count for the extracted result */
+    targetTokens: number;
+    /** Key requirements identified for extraction */
+    keyRequirements: string;
+    /** All chunks of the document */
+    chunks: ChunkInfo[];
+    /** Current phase of extraction */
+    phase: ExtractionPhase;
+    /** Extracted content mapped by chunk index */
+    extractedContent: Record<number, string>;
+    /** Current iteration number */
+    currentIteration: number;
+    /** Maximum allowed iterations */
+    maxIterations: number;
+    /** Any errors encountered during extraction */
+    errors: string[];
+    /** Timestamp when extraction started */
+    startedAt: string;
+    /** Timestamp of last update */
+    updatedAt: string;
+}
+/**
+ * Result of the extraction process
+ */
+export interface ExtractorResult {
+    /** Whether extraction completed successfully */
+    success: boolean;
+    /** The extracted data (if successful) */
+    extractedData?: Record<string, unknown>;
+    /** Token count of the extracted data */
+    extractedTokens?: number;
+    /** Metadata about the extraction process */
+    metadata: {
+        /** Original token count */
+        originalTokens: number;
+        /** Target token count */
+        targetTokens: number;
+        /** Number of chunks processed */
+        chunksProcessed: number;
+        /** Number of chunks that had content extracted */
+        chunksExtractedFrom: number;
+        /** Number of iterations used */
+        iterationsUsed: number;
+        /** Final phase of the extraction */
+        phase: ExtractionPhase;
+        /** Average relevance score across all chunks */
+        averageRelevanceScore?: number;
+    };
+    /** Error message if extraction failed */
+    error?: string;
+}
+/**
+ * Progress callback for extraction phases
+ */
+export type OnProgress = (phase: ExtractionPhase, current: number, total: number, message?: string) => void;
+/**
+ * Scoring result from the LLM
+ */
+export interface ScoringResult {
+    score: number;
+    reason: string;
+}
+/**
+ * Extraction result from the LLM for a single chunk
+ */
+export interface ChunkExtractionResult {
+    extracted: string;
+    keyFacts: string[];
+}

package/dist/runner/hooks/predefined/document-context-extractor/types.js

@@ -0,0 +1,8 @@
+/**
+ * Types for the document context extractor
+ *
+ * The extractor uses a two-phase approach:
+ * 1. Score all chunks for relevance (0-10)
+ * 2. Extract only from high-scoring chunks
+ */
+export {};