qlogicagent 2.13.3 → 2.13.5

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

@@ -0,0 +1,556 @@
+// ============================================================
+// 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 };
+}
+export function extractPatchTargets(input) {
+    const paths = [];
+    const deletes = [];
+    const add = (p) => {
+        const t = p?.trim();
+        if (t)
+            paths.push(t);
+    };
+    const lines = input.split("\n");
+    let sawMarker = false;
+    for (const raw of lines) {
+        const line = raw.trimEnd();
+        if (line.startsWith("*** Add File: ")) {
+            sawMarker = true;
+            add(line.slice("*** Add File: ".length));
+        }
+        else if (line.startsWith("*** Update File: ")) {
+            sawMarker = true;
+            add(line.slice("*** Update File: ".length));
+        }
+        else if (line.startsWith("*** Delete File: ")) {
+            sawMarker = true;
+            const p = line.slice("*** Delete File: ".length).trim();
+            if (p) {
+                paths.push(p);
+                deletes.push(p);
+            }
+        }
+        else if (line.startsWith("*** Move to: ")) {
+            // V4A: rename destination of the current Update op.
+            sawMarker = true;
+            add(line.slice("*** Move to: ".length));
+        }
+        else if (line.startsWith("*** Move File: ")) {
+            // patch-tool: "*** Move File: <src> -> <dest>".
+            sawMarker = true;
+            const rest = line.slice("*** Move File: ".length).trim();
+            const [src, dest] = rest.split(" -> ");
+            add(src);
+            add(dest);
+        }
+    }
+    // Simple find-replace format: the file path is the first non-empty line
+    // before the first `<<<< SEARCH` block (see parseSimpleFormat).
+    if (!sawMarker && input.includes("<<<< SEARCH")) {
+        const before = input.split(/^(<<<< SEARCH)$/m)[0] ?? "";
+        const pathLine = before.trim().split("\n").pop()?.trim();
+        add(pathLine);
+    }
+    return { paths, deletes };
+}
+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 (model-habit compatibility)
+                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/petdex-create-tool.d.ts

@@ -0,0 +1,47 @@
+import type { PortableTool } from "../portable-tool.js";
+import type { GeneratePetdexImage, UploadPetdexReferenceImage } from "@xiaozhiclaw/pet-core";
+export declare const PETDEX_CREATE_TOOL_NAME: "petdex_create";
+export interface PetdexCreateToolParams {
+    name?: string;
+    description: string;
+    prompt?: string;
+    reference_image_url?: string;
+    base_spritesheet_path?: string;
+    output_dir?: string;
+}
+export interface PetdexCreateToolDeps {
+    generateImage: GeneratePetdexImage;
+    uploadReferenceImage?: UploadPetdexReferenceImage;
+    resolveOutputDir(outputDir?: string): string;
+}
+export declare const PETDEX_CREATE_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly name: {
+            readonly type: "string";
+            readonly description: "Short display name for the generated desktop pet. Defaults to a short name derived from description.";
+        };
+        readonly description: {
+            readonly type: "string";
+            readonly description: "Canonical character description for the Petdex desktop pet.";
+        };
+        readonly prompt: {
+            readonly type: "string";
+            readonly description: "Optional extra visual direction. The tool will embed it into a strict Petdex 8x9 atlas prompt.";
+        };
+        readonly reference_image_url: {
+            readonly type: "string";
+            readonly description: "Optional publicly accessible HTTP/HTTPS reference image URL for image-to-image generation.";
+        };
+        readonly base_spritesheet_path: {
+            readonly type: "string";
+            readonly description: "Optional existing spritesheet.webp path; used as the identity reference to regenerate the whole atlas while keeping the same character.";
+        };
+        readonly output_dir: {
+            readonly type: "string";
+            readonly description: "Optional output directory. Defaults to the workspace Petdex asset output directory.";
+        };
+    };
+    readonly required: readonly ["description"];
+};
+export declare function createPetdexCreateTool(deps: PetdexCreateToolDeps): PortableTool<PetdexCreateToolParams>;