qlogicagent 0.2.1 → 0.4.0

package/dist/skills/tools/patch-tool.js

@@ -1,505 +0,0 @@
-// ============================================================
-// Patch Tool — fuzzy-match file editing with 9-strategy degradation.
-// Reference: hermes-agent-main/tools/fuzzy_match.py (9-strategy chain)
-//            hermes-agent-main/tools/patch_parser.py (V4A format)
-// Category: coding
-// ============================================================
-export const PATCH_TOOL_NAME = "patch";
-export const PATCH_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        input: {
-            type: "string",
-            description: "Patch content. Supports two formats:\n" +
-                "1) V4A unified diff (*** Begin Patch / *** End Patch markers)\n" +
-                "2) Simple find-replace: first line is file path, then <<<< SEARCH / ==== / >>>> REPLACE blocks.\n" +
-                "Fuzzy matching automatically handles whitespace/indent/unicode drift in the search text.",
-        },
-        replaceAll: {
-            type: "boolean",
-            description: "Replace all occurrences instead of first only (default: false).",
-        },
-    },
-    required: ["input"],
-};
-function escapeNormalize(s) {
-    return s.replace(/\\n/g, "\n").replace(/\\t/g, "\t").replace(/\\'/g, "'").replace(/\\"/g, '"');
-}
-function unicodeNormalize(s) {
-    return s
-        .replace(/[\u201c\u201d\u201e\u201f]/g, '"')
-        .replace(/[\u2018\u2019\u201a\u201b]/g, "'")
-        .replace(/\u2014/g, "--")
-        .replace(/\u2013/g, "-")
-        .replace(/\u2026/g, "...")
-        .replace(/\u00a0/g, " ");
-}
-function lineSimilarity(a, b) {
-    if (a === b)
-        return 1;
-    const longer = Math.max(a.length, b.length);
-    if (longer === 0)
-        return 1;
-    let dist = 0;
-    const la = a.length;
-    const lb = b.length;
-    const maxLen = Math.max(la, lb);
-    // Simplified: character-level distance ratio
-    for (let i = 0; i < Math.min(la, lb); i++) {
-        if (a[i] !== b[i])
-            dist++;
-    }
-    dist += Math.abs(la - lb);
-    return 1 - dist / maxLen;
-}
-function fuzzyFind(content, search, replaceAll) {
-    const results = [];
-    // Strategy 1: exact
-    let idx = content.indexOf(search);
-    if (idx !== -1) {
-        if (replaceAll) {
-            let pos = 0;
-            while ((idx = content.indexOf(search, pos)) !== -1) {
-                results.push({ start: idx, end: idx + search.length, strategy: "exact" });
-                pos = idx + search.length;
-            }
-        }
-        else {
-            results.push({ start: idx, end: idx + search.length, strategy: "exact" });
-        }
-        return results;
-    }
-    // Strategy 2: line_trimmed
-    const searchLines = search.split("\n").map((l) => l.trim());
-    const contentLines = content.split("\n");
-    const trimmedMatch = findLineBlock(contentLines, searchLines, (a, b) => a.trim() === b);
-    if (trimmedMatch) {
-        return [{ ...lineBlockToRange(content, contentLines, trimmedMatch), strategy: "line_trimmed" }];
-    }
-    // Strategy 3: whitespace_normalized
-    const normSearch = search.replace(/[ \t]+/g, " ");
-    const normContent = content.replace(/[ \t]+/g, " ");
-    idx = normContent.indexOf(normSearch);
-    if (idx !== -1) {
-        const mapped = mapNormalizedPos(content, normContent, idx, normSearch.length);
-        if (mapped)
-            return [{ ...mapped, strategy: "whitespace_normalized" }];
-    }
-    // Strategy 4: indentation_flexible
-    const flexMatch = findLineBlock(contentLines, searchLines, (a, b) => a.trimStart() === b.trimStart());
-    if (flexMatch) {
-        return [{ ...lineBlockToRange(content, contentLines, flexMatch), strategy: "indentation_flexible" }];
-    }
-    // Strategy 5: escape_normalized
-    const escSearch = escapeNormalize(search);
-    if (escSearch !== search) {
-        idx = content.indexOf(escSearch);
-        if (idx !== -1) {
-            return [{ start: idx, end: idx + escSearch.length, strategy: "escape_normalized" }];
-        }
-    }
-    // Strategy 6: trimmed_boundary
-    const sLines = search.split("\n");
-    if (sLines.length >= 3) {
-        const innerSearch = sLines.slice(1, -1).join("\n");
-        const firstTrimmed = sLines[0].trim();
-        const lastTrimmed = sLines[sLines.length - 1].trim();
-        for (let i = 0; i < contentLines.length; i++) {
-            if (contentLines[i].trim() === firstTrimmed) {
-                const innerStart = contentLines.slice(0, i + 1).join("\n").length + 1;
-                const innerIdx = content.indexOf(innerSearch, innerStart);
-                if (innerIdx !== -1) {
-                    const afterInner = innerIdx + innerSearch.length;
-                    const nextNewline = content.indexOf("\n", afterInner);
-                    const lastLine = nextNewline === -1 ? content.slice(afterInner) : content.slice(afterInner, nextNewline);
-                    if (lastLine.trim() === lastTrimmed || (nextNewline !== -1 && content.slice(afterInner + 1, content.indexOf("\n", afterInner + 1) === -1 ? undefined : content.indexOf("\n", afterInner + 1)).trim() === lastTrimmed)) {
-                        const rangeStart = contentLines.slice(0, i).join("\n").length + (i > 0 ? 1 : 0);
-                        // Find end after last line
-                        let endI = i;
-                        const needed = sLines.length;
-                        if (i + needed <= contentLines.length) {
-                            endI = i + needed;
-                            const rangeEnd = contentLines.slice(0, endI).join("\n").length;
-                            return [{ start: rangeStart, end: rangeEnd, strategy: "trimmed_boundary" }];
-                        }
-                    }
-                }
-            }
-        }
-    }
-    // Strategy 7: unicode_normalized
-    const uniSearch = unicodeNormalize(search);
-    const uniContent = unicodeNormalize(content);
-    if (uniSearch !== search || uniContent !== content) {
-        idx = uniContent.indexOf(uniSearch);
-        if (idx !== -1) {
-            const mapped = mapNormalizedPos(content, uniContent, idx, uniSearch.length);
-            if (mapped)
-                return [{ ...mapped, strategy: "unicode_normalized" }];
-        }
-    }
-    // Strategy 8: block_anchor
-    if (sLines.length >= 3) {
-        const firstLine = sLines[0];
-        const lastLine = sLines[sLines.length - 1];
-        for (let i = 0; i < contentLines.length; i++) {
-            if (contentLines[i] === firstLine) {
-                for (let j = i + sLines.length - 1; j < Math.min(i + sLines.length + 2, contentLines.length); j++) {
-                    if (contentLines[j] === lastLine) {
-                        const blockLen = j - i + 1;
-                        const middleLines = contentLines.slice(i + 1, j);
-                        const searchMiddle = sLines.slice(1, -1);
-                        const matchCount = searchMiddle.filter((sl) => middleLines.some((cl) => lineSimilarity(cl, sl) >= 0.7)).length;
-                        const ratio = searchMiddle.length > 0 ? matchCount / searchMiddle.length : 1;
-                        if (ratio >= 0.5 && blockLen <= sLines.length + 2) {
-                            const rangeStart = contentLines.slice(0, i).join("\n").length + (i > 0 ? 1 : 0);
-                            const rangeEnd = contentLines.slice(0, j + 1).join("\n").length;
-                            return [{ start: rangeStart, end: rangeEnd, strategy: "block_anchor" }];
-                        }
-                    }
-                }
-            }
-        }
-    }
-    // Strategy 9: context_aware
-    if (sLines.length >= 2) {
-        for (let i = 0; i <= contentLines.length - sLines.length; i++) {
-            const candidateLines = contentLines.slice(i, i + sLines.length);
-            const similarities = sLines.map((sl, k) => lineSimilarity(sl, candidateLines[k]));
-            const goodLines = similarities.filter((s) => s >= 0.8).length;
-            if (goodLines / sLines.length >= 0.5) {
-                const rangeStart = contentLines.slice(0, i).join("\n").length + (i > 0 ? 1 : 0);
-                const rangeEnd = contentLines.slice(0, i + sLines.length).join("\n").length;
-                return [{ start: rangeStart, end: rangeEnd, strategy: "context_aware" }];
-            }
-        }
-    }
-    return [];
-}
-function findLineBlock(contentLines, searchLines, compareFn) {
-    for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
-        let match = true;
-        for (let j = 0; j < searchLines.length; j++) {
-            if (!compareFn(contentLines[i + j], searchLines[j])) {
-                match = false;
-                break;
-            }
-        }
-        if (match)
-            return { startIdx: i, endIdx: i + searchLines.length };
-    }
-    return null;
-}
-function lineBlockToRange(content, contentLines, block) {
-    const start = contentLines.slice(0, block.startIdx).join("\n").length + (block.startIdx > 0 ? 1 : 0);
-    const end = contentLines.slice(0, block.endIdx).join("\n").length;
-    return { start, end };
-}
-function mapNormalizedPos(original, normalized, normStart, normLen) {
-    // Simple character-length mapping (works for whitespace collapse and unicode transforms)
-    // Walk both strings in sync to find positional correspondence
-    let oi = 0;
-    let ni = 0;
-    let origStart = -1;
-    let origEnd = -1;
-    while (oi <= original.length && ni <= normalized.length) {
-        if (ni === normStart && origStart === -1)
-            origStart = oi;
-        if (ni === normStart + normLen) {
-            origEnd = oi;
-            break;
-        }
-        if (ni >= normalized.length)
-            break;
-        if (oi >= original.length)
-            break;
-        ni++;
-        oi++;
-        // Skip extra chars in original that were collapsed
-        while (oi < original.length && ni < normalized.length && original[oi] !== normalized[ni]) {
-            oi++;
-        }
-    }
-    if (origStart !== -1 && origEnd === -1)
-        origEnd = original.length;
-    if (origStart === -1)
-        return null;
-    return { start: origStart, end: origEnd };
-}
-function parseV4A(input) {
-    const lines = input.split("\n");
-    const ops = [];
-    let current = null;
-    let currentHunk = null;
-    let inPatch = false;
-    for (const line of lines) {
-        if (line.startsWith("*** Begin Patch")) {
-            inPatch = true;
-            continue;
-        }
-        if (line.startsWith("*** End Patch"))
-            break;
-        if (!inPatch)
-            continue;
-        if (line.startsWith("*** Add File: ")) {
-            if (current)
-                ops.push(current);
-            current = { type: "add", path: line.slice(14).trim(), hunks: [] };
-            currentHunk = { lines: [] };
-            current.hunks.push(currentHunk);
-        }
-        else if (line.startsWith("*** Update File: ")) {
-            if (current)
-                ops.push(current);
-            current = { type: "update", path: line.slice(17).trim(), hunks: [] };
-            currentHunk = null;
-        }
-        else if (line.startsWith("*** Delete File: ")) {
-            if (current)
-                ops.push(current);
-            current = { type: "delete", path: line.slice(17).trim(), hunks: [] };
-            currentHunk = null;
-        }
-        else if (line.startsWith("*** Move File: ")) {
-            if (current)
-                ops.push(current);
-            const parts = line.slice(15).trim().split(" -> ");
-            current = { type: "move", path: parts[0].trim(), newPath: parts[1]?.trim(), hunks: [] };
-            currentHunk = null;
-        }
-        else if (line.startsWith("@@ ") && current) {
-            currentHunk = { contextHint: line.slice(3).replace(/ @@$/, "").trim() || undefined, lines: [] };
-            current.hunks.push(currentHunk);
-        }
-        else if (currentHunk) {
-            if (line.startsWith("+")) {
-                currentHunk.lines.push({ prefix: "+", content: line.slice(1) });
-            }
-            else if (line.startsWith("-")) {
-                currentHunk.lines.push({ prefix: "-", content: line.slice(1) });
-            }
-            else {
-                currentHunk.lines.push({ prefix: " ", content: line.startsWith(" ") ? line.slice(1) : line });
-            }
-        }
-    }
-    if (current)
-        ops.push(current);
-    return ops;
-}
-function parseSimpleFormat(input) {
-    const ops = [];
-    const blocks = input.split(/^(<<<< SEARCH)$/m);
-    if (blocks.length < 2)
-        return [];
-    // First element before first <<<< SEARCH is the file path
-    const pathLine = blocks[0].trim().split("\n").pop()?.trim();
-    if (!pathLine)
-        return [];
-    for (let i = 1; i < blocks.length; i += 2) {
-        const rest = blocks[i + 1] || "";
-        const sepIdx = rest.indexOf("\n====\n");
-        if (sepIdx === -1)
-            continue;
-        const search = rest.slice(0, sepIdx).replace(/^\n/, "");
-        const afterSep = rest.slice(sepIdx + 6);
-        const replaceEnd = afterSep.indexOf("\n>>>> REPLACE");
-        const replace = replaceEnd === -1 ? afterSep : afterSep.slice(0, replaceEnd);
-        ops.push({ path: pathLine, search, replace });
-    }
-    return ops;
-}
-// ── Main tool function ──────────────────────────────────────
-function applyV4AHunk(content, hunk, replaceAll) {
-    const contextLines = hunk.lines.filter((l) => l.prefix === " ").map((l) => l.content);
-    const removeLines = hunk.lines.filter((l) => l.prefix === "-").map((l) => l.content);
-    const addLines = hunk.lines.filter((l) => l.prefix === "+").map((l) => l.content);
-    // Build the search text from context + removals (what should exist in file)
-    const searchParts = [];
-    let phase = "context";
-    for (const line of hunk.lines) {
-        if (line.prefix === " " || line.prefix === "-") {
-            searchParts.push(line.content);
-        }
-        // Skip additions in search
-    }
-    const searchText = searchParts.join("\n");
-    if (!searchText) {
-        // Pure addition — append at end or after context hint
-        return { content: content + "\n" + addLines.join("\n"), strategy: "exact" };
-    }
-    const matches = fuzzyFind(content, searchText, replaceAll);
-    if (matches.length === 0)
-        return null;
-    // Build replacement: context lines + additions (removals excluded)
-    const replaceParts = [];
-    for (const line of hunk.lines) {
-        if (line.prefix === " " || line.prefix === "+") {
-            replaceParts.push(line.content);
-        }
-    }
-    const replaceText = replaceParts.join("\n");
-    // Apply first match
-    const m = matches[0];
-    const newContent = content.slice(0, m.start) + replaceText + content.slice(m.end);
-    return { content: newContent, strategy: m.strategy };
-}
-export function createPatchTool(deps) {
-    return {
-        name: PATCH_TOOL_NAME,
-        label: "Patch",
-        description: "Apply edits to files using fuzzy matching. Supports V4A unified diff format " +
-            "(*** Begin Patch / *** End Patch) for multi-file operations, and simple search/replace " +
-            "blocks. The fuzzy matcher handles whitespace, indentation, unicode, and escape drift " +
-            "— LLM output with minor formatting differences will still match correctly.",
-        parameters: PATCH_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            const replaceAll = params.replaceAll ?? false;
-            const result = { filesModified: [], filesAdded: [], filesDeleted: [], strategies: {}, errors: [] };
-            // Detect format: V4A or simple
-            const isV4A = params.input.includes("*** Begin Patch");
-            const isSimple = params.input.includes("<<<< SEARCH");
-            if (isV4A) {
-                const ops = parseV4A(params.input);
-                if (ops.length === 0) {
-                    return {
-                        content: [{ type: "text", text: "Error: No valid V4A operations found. Ensure *** Begin Patch / *** End Patch markers are present." }],
-                        details: { type: "patch", error: "parse_failed" },
-                    };
-                }
-                for (const op of ops) {
-                    const resolved = deps.resolvePath(op.path);
-                    try {
-                        switch (op.type) {
-                            case "add": {
-                                const addContent = op.hunks.flatMap((h) => h.lines.filter((l) => l.prefix === "+").map((l) => l.content)).join("\n");
-                                await deps.writeFile(resolved, addContent);
-                                result.filesAdded.push(op.path);
-                                result.strategies[op.path] = "exact";
-                                break;
-                            }
-                            case "delete": {
-                                await deps.deleteFile(resolved);
-                                result.filesDeleted.push(op.path);
-                                break;
-                            }
-                            case "move": {
-                                const existing = await deps.readFile(resolved);
-                                if (op.newPath) {
-                                    const dest = deps.resolvePath(op.newPath);
-                                    let content = existing;
-                                    for (const hunk of op.hunks) {
-                                        const hr = applyV4AHunk(content, hunk, replaceAll);
-                                        if (hr) {
-                                            content = hr.content;
-                                            result.strategies[op.path] = hr.strategy;
-                                        }
-                                    }
-                                    await deps.writeFile(dest, content);
-                                    await deps.deleteFile(resolved);
-                                    result.filesModified.push(`${op.path} → ${op.newPath}`);
-                                }
-                                break;
-                            }
-                            case "update": {
-                                let content = await deps.readFile(resolved);
-                                let lastStrategy = "exact";
-                                let allSuccess = true;
-                                for (const hunk of op.hunks) {
-                                    const hr = applyV4AHunk(content, hunk, replaceAll);
-                                    if (hr) {
-                                        content = hr.content;
-                                        lastStrategy = hr.strategy;
-                                    }
-                                    else {
-                                        allSuccess = false;
-                                        // Build readable error
-                                        const searchSnippet = hunk.lines
-                                            .filter((l) => l.prefix === " " || l.prefix === "-")
-                                            .map((l) => l.content)
-                                            .slice(0, 5)
-                                            .join("\n");
-                                        result.errors.push(`${op.path}: hunk not matched. Search begins with:\n${searchSnippet}`);
-                                    }
-                                }
-                                if (allSuccess || content !== await deps.readFile(resolved)) {
-                                    await deps.writeFile(resolved, content);
-                                    result.filesModified.push(op.path);
-                                    result.strategies[op.path] = lastStrategy;
-                                }
-                                break;
-                            }
-                        }
-                    }
-                    catch (err) {
-                        result.errors.push(`${op.type} ${op.path}: ${err instanceof Error ? err.message : String(err)}`);
-                    }
-                }
-            }
-            else if (isSimple) {
-                const ops = parseSimpleFormat(params.input);
-                if (ops.length === 0) {
-                    return {
-                        content: [{ type: "text", text: "Error: Invalid search/replace format. Use <<<< SEARCH / ==== / >>>> REPLACE blocks." }],
-                        details: { type: "patch", error: "parse_failed" },
-                    };
-                }
-                for (const op of ops) {
-                    const resolved = deps.resolvePath(op.path);
-                    try {
-                        let content = await deps.readFile(resolved);
-                        const matches = fuzzyFind(content, op.search, replaceAll);
-                        if (matches.length === 0) {
-                            result.errors.push(`${op.path}: search text not matched (tried all 9 strategies)`);
-                            continue;
-                        }
-                        // Apply in reverse order to preserve positions
-                        const sorted = [...matches].sort((a, b) => b.start - a.start);
-                        for (const m of sorted) {
-                            content = content.slice(0, m.start) + op.replace + content.slice(m.end);
-                        }
-                        await deps.writeFile(resolved, content);
-                        result.filesModified.push(op.path);
-                        result.strategies[op.path] = matches[0].strategy;
-                    }
-                    catch (err) {
-                        result.errors.push(`${op.path}: ${err instanceof Error ? err.message : String(err)}`);
-                    }
-                }
-            }
-            else {
-                // Try parsing as a plain old/new pair in V4A-like format (backwards compat with apply_patch)
-                const ops = parseV4A("*** Begin Patch\n" + params.input + "\n*** End Patch");
-                if (ops.length > 0) {
-                    // Re-run through V4A path
-                    return createPatchTool(deps).execute(_toolCallId, { input: "*** Begin Patch\n" + params.input + "\n*** End Patch", replaceAll });
-                }
-                return {
-                    content: [{ type: "text", text: "Error: Unrecognized patch format. Use V4A (*** Begin Patch) or search/replace (<<<< SEARCH / ==== / >>>> REPLACE)." }],
-                    details: { type: "patch", error: "unknown_format" },
-                };
-            }
-            // Format output
-            const parts = [];
-            if (result.filesAdded.length)
-                parts.push(`Added: ${result.filesAdded.join(", ")}`);
-            if (result.filesModified.length) {
-                const strategyInfo = result.filesModified
-                    .map((f) => `${f} (${result.strategies[f] || "exact"})`)
-                    .join(", ");
-                parts.push(`Modified: ${strategyInfo}`);
-            }
-            if (result.filesDeleted.length)
-                parts.push(`Deleted: ${result.filesDeleted.join(", ")}`);
-            if (result.errors.length)
-                parts.push(`\nErrors:\n${result.errors.join("\n")}`);
-            const success = result.errors.length === 0;
-            return {
-                content: [{ type: "text", text: parts.join("\n") || "No changes applied." }],
-                details: { type: "patch", ...result, success },
-            };
-        },
-    };
-}
-// Export the fuzzy engine for unit testing
-export { fuzzyFind };

package/dist/skills/tools/pdf-tool.d.ts

@@ -1,66 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const PDF_TOOL_NAME: "pdf";
-export interface PdfToolParams {
-    prompt?: string;
-    pdf?: string;
-    pdfs?: string[];
-    pages?: string;
-}
-export declare const PDF_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly prompt: {
-            readonly type: "string";
-            readonly description: "Describe what to analyze or extract from the PDF(s).";
-        };
-        readonly pdf: {
-            readonly type: "string";
-            readonly description: "Single PDF path or URL.";
-        };
-        readonly pdfs: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-            };
-            readonly description: "Multiple PDF paths or URLs (up to 10).";
-        };
-        readonly pages: {
-            readonly type: "string";
-            readonly description: "Page range to process, e.g. \"1-5\", \"1,3,5-7\". Defaults to all pages.";
-        };
-    };
-    readonly required: readonly [];
-};
-/** Deps injected by the host runtime for PDF analysis. */
-export interface PdfToolDeps {
-    /**
-     * Extract text and/or page images from a PDF.
-     * The host decides how to load (local FS, HTTP, etc.).
-     */
-    extractPdf(source: string, options?: {
-        pages?: string;
-    }): Promise<{
-        text: string;
-        pageImages?: Array<{
-            page: number;
-            base64: string;
-            mimeType: string;
-        }>;
-    }>;
-    /**
-     * Optional: analyze extracted content via LLM.
-     * If not provided, the tool returns raw extracted text.
-     */
-    analyzePdfContent?(prompt: string, content: {
-        text: string;
-        images?: Array<{
-            base64: string;
-            mimeType: string;
-        }>;
-    }): Promise<{
-        text: string;
-        model?: string;
-        provider?: string;
-    }>;
-}
-export declare function createPdfTool(deps: PdfToolDeps): PortableTool<PdfToolParams>;

package/dist/skills/tools/pdf-tool.js

@@ -1,88 +0,0 @@
-// ============================================================
-// PDF Tool — analyze PDF documents via relay/backend pipeline.
-// Category: document
-// ============================================================
-export const PDF_TOOL_NAME = "pdf";
-export const PDF_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        prompt: {
-            type: "string",
-            description: "Describe what to analyze or extract from the PDF(s).",
-        },
-        pdf: {
-            type: "string",
-            description: "Single PDF path or URL.",
-        },
-        pdfs: {
-            type: "array",
-            items: { type: "string" },
-            description: "Multiple PDF paths or URLs (up to 10).",
-        },
-        pages: {
-            type: "string",
-            description: 'Page range to process, e.g. "1-5", "1,3,5-7". Defaults to all pages.',
-        },
-    },
-    required: [],
-};
-const MAX_PDF_COUNT = 10;
-export function createPdfTool(deps) {
-    return {
-        name: PDF_TOOL_NAME,
-        label: "PDF",
-        description: "Analyze one or more PDF documents. Use `pdf` for a single path/URL, or `pdfs` for multiple (up to 10). " +
-            "Provide a `prompt` describing what to analyze. Use `pages` to limit which pages to process.",
-        parameters: PDF_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            // Normalize sources
-            const sources = [];
-            if (params.pdf)
-                sources.push(params.pdf);
-            if (params.pdfs)
-                sources.push(...params.pdfs);
-            // Deduplicate
-            const unique = [...new Set(sources)];
-            if (unique.length === 0) {
-                return { content: [{ type: "text", text: "Error: provide at least one PDF via `pdf` or `pdfs`." }] };
-            }
-            if (unique.length > MAX_PDF_COUNT) {
-                return { content: [{ type: "text", text: `Error: maximum ${MAX_PDF_COUNT} PDFs per call.` }] };
-            }
-            const allTexts = [];
-            const allImages = [];
-            const errors = [];
-            for (const src of unique) {
-                try {
-                    const result = await deps.extractPdf(src, { pages: params.pages });
-                    allTexts.push(result.text);
-                    if (result.pageImages) {
-                        for (const img of result.pageImages) {
-                            allImages.push({ base64: img.base64, mimeType: img.mimeType });
-                        }
-                    }
-                }
-                catch (err) {
-                    errors.push(`${src}: ${err instanceof Error ? err.message : String(err)}`);
-                }
-            }
-            if (allTexts.length === 0) {
-                return { content: [{ type: "text", text: `Failed to extract any PDFs: ${errors.join("; ")}` }] };
-            }
-            const combinedText = allTexts.join("\n\n---\n\n");
-            // If LLM analysis is available and prompt given, use it
-            if (deps.analyzePdfContent && params.prompt) {
-                const analysis = await deps.analyzePdfContent(params.prompt, { text: combinedText, images: allImages });
-                return {
-                    content: [{ type: "text", text: analysis.text }],
-                    details: { type: "pdf", model: analysis.model, provider: analysis.provider, pdfCount: unique.length, errors },
-                };
-            }
-            // Otherwise return raw extracted text
-            return {
-                content: [{ type: "text", text: combinedText }],
-                details: { type: "pdf", pdfCount: unique.length, errors },
-            };
-        },
-    };
-}