opencode-froggy 0.1.0 → 0.3.0

package/dist/tools/blockchain/tools.test.js

@@ -0,0 +1,208 @@
+import { describe, it, expect } from "vitest";
+import { formatTransactionReceipt, formatTransactionList, formatBalance, formatTokenTransferList, } from "./formatters";
+describe("Blockchain Formatters", () => {
+    describe("formatTransactionReceipt", () => {
+        it("should format successful transaction receipt", () => {
+            const receipt = {
+                status: "0x1",
+                blockNumber: "0xf4240",
+                from: "0x1111111111111111111111111111111111111111",
+                to: "0x2222222222222222222222222222222222222222",
+                gasUsed: "0x5208",
+                effectiveGasPrice: "0x3b9aca00",
+                logs: [],
+            };
+            const result = formatTransactionReceipt("0xabc123", receipt);
+            expect(result).toContain("## Transaction Details");
+            expect(result).toContain("**Hash:** 0xabc123");
+            expect(result).toContain("**Status:** Success");
+            expect(result).toContain("**Block:** 1000000");
+            expect(result).toContain("**From:** 0x1111111111111111111111111111111111111111");
+            expect(result).toContain("**To:** 0x2222222222222222222222222222222222222222");
+            expect(result).toContain("**Gas Used:** 21000");
+            expect(result).toContain("**Log Count:** 0");
+        });
+        it("should format failed transaction receipt", () => {
+            const receipt = {
+                status: "0x0",
+                blockNumber: "0xf4240",
+                from: "0x1111111111111111111111111111111111111111",
+                to: "0x2222222222222222222222222222222222222222",
+                gasUsed: "0x5208",
+                effectiveGasPrice: "0x3b9aca00",
+                logs: [],
+            };
+            const result = formatTransactionReceipt("0xabc123", receipt);
+            expect(result).toContain("**Status:** Failed");
+        });
+        it("should handle contract creation", () => {
+            const receipt = {
+                status: "0x1",
+                blockNumber: "0xf4240",
+                from: "0x1111111111111111111111111111111111111111",
+                to: null,
+                contractAddress: "0x3333333333333333333333333333333333333333",
+                gasUsed: "0x5208",
+                effectiveGasPrice: "0x3b9aca00",
+                logs: [],
+            };
+            const result = formatTransactionReceipt("0xabc123", receipt);
+            expect(result).toContain("**To:** Contract Creation");
+            expect(result).toContain("**Contract Created:** 0x3333333333333333333333333333333333333333");
+        });
+    });
+    describe("formatTransactionList", () => {
+        it("should format transaction list with in and out", () => {
+            const address = "0x1234567890123456789012345678901234567890";
+            const transactions = [
+                {
+                    hash: "0xabc123",
+                    blockNumber: "1000000",
+                    blockHash: "0x...",
+                    timeStamp: "1640000000",
+                    from: address,
+                    to: "0x2222222222222222222222222222222222222222",
+                    value: "1000000000000000000",
+                    gas: "21000",
+                    gasPrice: "1000000000",
+                    gasUsed: "21000",
+                    nonce: "1",
+                    transactionIndex: "0",
+                    input: "0x",
+                    isError: "0",
+                    txreceipt_status: "1",
+                    contractAddress: "",
+                    cumulativeGasUsed: "21000",
+                    confirmations: "100",
+                    methodId: "0x",
+                    functionName: "transfer(address,uint256)",
+                },
+                {
+                    hash: "0xdef456",
+                    blockNumber: "999999",
+                    blockHash: "0x...",
+                    timeStamp: "1639999000",
+                    from: "0x3333333333333333333333333333333333333333",
+                    to: address,
+                    value: "500000000000000000",
+                    gas: "21000",
+                    gasPrice: "1000000000",
+                    gasUsed: "21000",
+                    nonce: "1",
+                    transactionIndex: "0",
+                    input: "0x",
+                    isError: "0",
+                    txreceipt_status: "1",
+                    contractAddress: "",
+                    cumulativeGasUsed: "21000",
+                    confirmations: "100",
+                    methodId: "0x",
+                    functionName: "",
+                },
+            ];
+            const result = formatTransactionList(address, transactions);
+            expect(result).toContain("## Transactions for 0x1234...7890");
+            expect(result).toContain("**Total:** 2 (1 incoming, 1 outgoing)");
+            expect(result).toContain("[OUT]");
+            expect(result).toContain("[IN]");
+            expect(result).toContain("Value: 1 ETH");
+            expect(result).toContain("Value: 0.5 ETH");
+            expect(result).toContain("Function: transfer(address,uint256)");
+        });
+        it("should return no transactions message for empty list", () => {
+            const result = formatTransactionList("0x1234567890123456789012345678901234567890", []);
+            expect(result).toContain("No transactions found");
+        });
+    });
+    describe("formatBalance", () => {
+        it("should format balance in ETH and Wei", () => {
+            const result = formatBalance("0x1234567890123456789012345678901234567890", "1500000000000000000");
+            expect(result).toContain("## Balance for 0x1234567890123456789012345678901234567890");
+            expect(result).toContain("**ETH:** 1.5");
+            expect(result).toContain("**Wei:** 1500000000000000000");
+        });
+        it("should handle zero balance", () => {
+            const result = formatBalance("0x1234567890123456789012345678901234567890", "0");
+            expect(result).toContain("**ETH:** 0");
+            expect(result).toContain("**Wei:** 0");
+        });
+    });
+    describe("formatTokenTransferList", () => {
+        it("should format token transfer list", () => {
+            const address = "0x1234567890123456789012345678901234567890";
+            const transfers = [
+                {
+                    hash: "0xtoken123",
+                    blockNumber: "1000000",
+                    timeStamp: "1640000000",
+                    from: address,
+                    to: "0x2222222222222222222222222222222222222222",
+                    value: "1000000000000000000",
+                    contractAddress: "0x4444444444444444444444444444444444444444",
+                    tokenName: "Test Token",
+                    tokenSymbol: "TST",
+                    tokenDecimal: "18",
+                    gas: "60000",
+                    gasPrice: "1000000000",
+                    gasUsed: "55000",
+                    nonce: "1",
+                    transactionIndex: "0",
+                },
+            ];
+            const result = formatTokenTransferList(address, transfers);
+            expect(result).toContain("## ERC-20 Token Transfers for 0x1234...7890");
+            expect(result).toContain("**Total:** 1 transfers");
+            expect(result).toContain("**Unique Tokens:** 1");
+            expect(result).toContain("Token: Test Token (TST)");
+            expect(result).toContain("[OUT]");
+            expect(result).toContain("Value: 1 TST");
+        });
+        it("should return no transfers message for empty list", () => {
+            const result = formatTokenTransferList("0x1234567890123456789012345678901234567890", []);
+            expect(result).toContain("No ERC-20 token transfers found");
+        });
+        it("should show token summary with multiple tokens", () => {
+            const address = "0x1234567890123456789012345678901234567890";
+            const transfers = [
+                {
+                    hash: "0xtoken1",
+                    blockNumber: "1000000",
+                    timeStamp: "1640000000",
+                    from: address,
+                    to: "0x2222222222222222222222222222222222222222",
+                    value: "1000000000000000000",
+                    contractAddress: "0x4444444444444444444444444444444444444444",
+                    tokenName: "Token A",
+                    tokenSymbol: "TKA",
+                    tokenDecimal: "18",
+                    gas: "60000",
+                    gasPrice: "1000000000",
+                    gasUsed: "55000",
+                    nonce: "1",
+                    transactionIndex: "0",
+                },
+                {
+                    hash: "0xtoken2",
+                    blockNumber: "1000001",
+                    timeStamp: "1640001000",
+                    from: "0x3333333333333333333333333333333333333333",
+                    to: address,
+                    value: "2000000000000000000",
+                    contractAddress: "0x5555555555555555555555555555555555555555",
+                    tokenName: "Token B",
+                    tokenSymbol: "TKB",
+                    tokenDecimal: "18",
+                    gas: "60000",
+                    gasPrice: "1000000000",
+                    gasUsed: "55000",
+                    nonce: "1",
+                    transactionIndex: "0",
+                },
+            ];
+            const result = formatTokenTransferList(address, transfers);
+            expect(result).toContain("**Unique Tokens:** 2");
+            expect(result).toContain("TKA: 0 in, 1 out");
+            expect(result).toContain("TKB: 1 in, 0 out");
+        });
+    });
+});

package/dist/tools/blockchain/types.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Etherscan API types for Ethereum blockchain tools
+ */
+export interface EtherscanResponse<T> {
+    status: "0" | "1";
+    message: string;
+    result: T;
+}
+export interface EthTransaction {
+    hash: string;
+    blockNumber: string;
+    blockHash: string;
+    timeStamp: string;
+    from: string;
+    to: string;
+    value: string;
+    gas: string;
+    gasPrice: string;
+    gasUsed: string;
+    nonce: string;
+    transactionIndex: string;
+    input: string;
+    isError: string;
+    txreceipt_status: string;
+    contractAddress: string;
+    cumulativeGasUsed: string;
+    confirmations: string;
+    methodId: string;
+    functionName: string;
+}
+export interface EthTokenTransfer {
+    hash: string;
+    blockNumber: string;
+    timeStamp: string;
+    from: string;
+    to: string;
+    value: string;
+    contractAddress: string;
+    tokenName: string;
+    tokenSymbol: string;
+    tokenDecimal: string;
+    gas: string;
+    gasPrice: string;
+    gasUsed: string;
+    nonce: string;
+    transactionIndex: string;
+}
+export interface EthInternalTransaction {
+    hash: string;
+    blockNumber: string;
+    timeStamp: string;
+    from: string;
+    to: string;
+    value: string;
+    contractAddress: string;
+    input: string;
+    type: string;
+    gas: string;
+    gasUsed: string;
+    isError: string;
+    errCode: string;
+}
+export interface TransactionReceipt {
+    status: string;
+    blockHash: string;
+    blockNumber: string;
+    transactionHash: string;
+    transactionIndex: string;
+    from: string;
+    to: string;
+    contractAddress: string | null;
+    cumulativeGasUsed: string;
+    gasUsed: string;
+    effectiveGasPrice: string;
+    logs: TransactionLog[];
+}
+export interface TransactionLog {
+    address: string;
+    topics: string[];
+    data: string;
+    blockNumber: string;
+    transactionHash: string;
+    transactionIndex: string;
+    blockHash: string;
+    logIndex: string;
+    removed: boolean;
+}
+export declare const DEFAULT_TRANSACTION_LIMIT = 20;
+export declare const DEFAULT_CHAIN_ID = "1";
+export declare const CHAIN_ID_DESCRIPTION: string;

package/dist/tools/blockchain/types.js

@@ -0,0 +1,8 @@
+/**
+ * Etherscan API types for Ethereum blockchain tools
+ */
+export const DEFAULT_TRANSACTION_LIMIT = 20;
+export const DEFAULT_CHAIN_ID = "1";
+export const CHAIN_ID_DESCRIPTION = "Chain ID (default: 1 for Ethereum). " +
+    "Examples: 1=Ethereum, 137=Polygon, 56=BSC, 42161=Arbitrum, " +
+    "10=Optimism, 8453=Base, 43114=Avalanche, 250=Fantom, 324=zkSync";

package/dist/tools/diff-summary.d.ts

@@ -0,0 +1,20 @@
+import { type ToolContext } from "@opencode-ai/plugin";
+export interface DiffSummaryArgs {
+    source?: string;
+    target?: string;
+    remote?: string;
+}
+export declare function diffSummary(args: DiffSummaryArgs, cwd: string): Promise<string>;
+export declare function createDiffSummaryTool(directory: string): {
+    description: string;
+    args: {
+        source: import("zod").ZodOptional<import("zod").ZodString>;
+        target: import("zod").ZodOptional<import("zod").ZodString>;
+        remote: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        source?: string | undefined;
+        target?: string | undefined;
+        remote?: string | undefined;
+    }, context: ToolContext): Promise<string>;
+};

package/dist/tools/diff-summary.js

@@ -0,0 +1,111 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { tool } from "@opencode-ai/plugin";
+import { log } from "../logger";
+const execFileAsync = promisify(execFile);
+const DIFF_CONTEXT_LINES = 5;
+async function git(args, cwd) {
+    try {
+        const result = await execFileAsync("git", args, { cwd, maxBuffer: 10 * 1024 * 1024 });
+        return result.stdout;
+    }
+    catch (error) {
+        const execError = error;
+        if (execError.stdout)
+            return execError.stdout;
+        throw error;
+    }
+}
+async function getDiffSet(cwd, extraArgs = []) {
+    const [stats, files, diff] = await Promise.all([
+        git(["diff", ...extraArgs, "--stat"], cwd),
+        git(["diff", ...extraArgs, "--name-status"], cwd),
+        git(["diff", ...extraArgs, `-U${DIFF_CONTEXT_LINES}`, "--function-context"], cwd),
+    ]);
+    return { stats, files, diff };
+}
+async function getBranchesDiff(source, target, remote, cwd) {
+    const refSource = remote ? `${remote}/${source}` : source;
+    const refTarget = remote ? `${remote}/${target}` : target;
+    const range = `${refTarget}...${refSource}`;
+    const rangeLog = `${refTarget}..${refSource}`;
+    if (remote) {
+        await git(["fetch", remote, source, target, "--prune"], cwd);
+    }
+    const [stats, commits, files, diff] = await Promise.all([
+        git(["diff", "--stat", range], cwd),
+        git(["log", "--oneline", "--no-merges", rangeLog], cwd),
+        git(["diff", "--name-only", range], cwd),
+        git(["diff", `-U${DIFF_CONTEXT_LINES}`, "--function-context", range], cwd),
+    ]);
+    return [
+        "## Stats Overview", "```", stats.trim(), "```",
+        "",
+        "## Commits to Review", "```", commits.trim(), "```",
+        "",
+        "## Files Changed", "```", files.trim(), "```",
+        "",
+        "## Full Diff", "```diff", diff.trim(), "```",
+    ].join("\n\n");
+}
+async function getWorkingTreeDiff(cwd) {
+    const sections = [];
+    const [status, staged, unstaged, untrackedList] = await Promise.all([
+        git(["status", "--porcelain=v1", "-uall"], cwd),
+        getDiffSet(cwd, ["--cached"]),
+        getDiffSet(cwd),
+        git(["ls-files", "--others", "--exclude-standard"], cwd),
+    ]);
+    sections.push("## Status Overview", "```", status.trim() || "(no changes)", "```");
+    if (staged.stats.trim() || staged.files.trim()) {
+        sections.push("## Staged Changes", "### Stats", "```", staged.stats.trim() || "(none)", "```", "### Files", "```", staged.files.trim() || "(none)", "```", "### Diff", "```diff", staged.diff.trim() || "(none)", "```");
+    }
+    if (unstaged.stats.trim() || unstaged.files.trim()) {
+        sections.push("## Unstaged Changes", "### Stats", "```", unstaged.stats.trim() || "(none)", "```", "### Files", "```", unstaged.files.trim() || "(none)", "```", "### Diff", "```diff", unstaged.diff.trim() || "(none)", "```");
+    }
+    const untrackedFiles = untrackedList.trim().split("\n").filter(Boolean);
+    if (untrackedFiles.length > 0) {
+        const untrackedDiffs = [];
+        for (const file of untrackedFiles) {
+            try {
+                const fileDiff = await git(["diff", "--no-index", `-U${DIFF_CONTEXT_LINES}`, "--function-context", "--", "/dev/null", file], cwd);
+                untrackedDiffs.push(`=== NEW: ${file} ===\n${fileDiff.trim()}`);
+            }
+            catch (error) {
+                log("[diff-summary] failed to diff untracked file", { file, error: String(error) });
+                untrackedDiffs.push(`=== NEW: ${file} === (could not diff)`);
+            }
+        }
+        sections.push("## Untracked Files", "```", untrackedFiles.join("\n"), "```", "### Diffs", "```diff", untrackedDiffs.join("\n\n"), "```");
+    }
+    return sections.join("\n\n");
+}
+export async function diffSummary(args, cwd) {
+    const { source, target = "main", remote = "origin" } = args;
+    if (source) {
+        return getBranchesDiff(source, target, remote, cwd);
+    }
+    return getWorkingTreeDiff(cwd);
+}
+export function createDiffSummaryTool(directory) {
+    return tool({
+        description: "Generate a structured summary of git diffs. Use for reviewing branches comparison or working tree changes. Returns stats, commits, files changed, and full diff.",
+        args: {
+            source: tool.schema
+                .string()
+                .optional()
+                .describe("Source branch to compare (e.g., 'feature-branch'). If omitted, analyzes working tree changes."),
+            target: tool.schema
+                .string()
+                .optional()
+                .describe("Target branch to compare against (default: 'main')"),
+            remote: tool.schema
+                .string()
+                .optional()
+                .describe("Git remote name (default: 'origin')"),
+        },
+        async execute(args, _context) {
+            return diffSummary(args, directory);
+        },
+    });
+}

package/dist/tools/gitingest.d.ts

@@ -0,0 +1,26 @@
+import { type ToolContext } from "@opencode-ai/plugin";
+export interface GitingestArgs {
+    url: string;
+    maxFileSize?: number;
+    pattern?: string;
+    patternType?: "include" | "exclude";
+}
+export declare function fetchGitingest(args: GitingestArgs): Promise<string>;
+export declare const gitingestTool: {
+    description: string;
+    args: {
+        url: import("zod").ZodString;
+        maxFileSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+        pattern: import("zod").ZodOptional<import("zod").ZodString>;
+        patternType: import("zod").ZodOptional<import("zod").ZodEnum<{
+            include: "include";
+            exclude: "exclude";
+        }>>;
+    };
+    execute(args: {
+        url: string;
+        maxFileSize?: number | undefined;
+        pattern?: string | undefined;
+        patternType?: "include" | "exclude" | undefined;
+    }, context: ToolContext): Promise<string>;
+};

package/dist/tools/gitingest.js

@@ -0,0 +1,41 @@
+import { tool } from "@opencode-ai/plugin";
+export async function fetchGitingest(args) {
+    const response = await fetch("https://gitingest.com/api/ingest", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            input_text: args.url,
+            max_file_size: args.maxFileSize ?? 50000,
+            pattern: args.pattern ?? "",
+            pattern_type: args.patternType ?? "exclude",
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`gitingest API error: ${response.status} ${response.statusText}`);
+    }
+    const data = (await response.json());
+    return `${data.summary}\n\n${data.tree}\n\n${data.content}`;
+}
+export const gitingestTool = tool({
+    description: "Fetch a GitHub repository's full content via gitingest.com. Returns summary, directory tree, and file contents optimized for LLM analysis. Use when you need to understand an external repository's structure or code.",
+    args: {
+        url: tool.schema
+            .string()
+            .describe("GitHub repository URL (e.g., https://github.com/owner/repo)"),
+        maxFileSize: tool.schema
+            .number()
+            .optional()
+            .describe("Maximum file size in bytes to include (default: 50000)"),
+        pattern: tool.schema
+            .string()
+            .optional()
+            .describe("Glob pattern to filter files (e.g., '*.py' or 'src/*')"),
+        patternType: tool.schema
+            .enum(["include", "exclude"])
+            .optional()
+            .describe("Whether pattern includes or excludes matching files (default: exclude)"),
+    },
+    async execute(args, _context) {
+        return fetchGitingest(args);
+    },
+});

package/dist/tools/index.d.ts

@@ -0,0 +1,5 @@
+export { gitingestTool, fetchGitingest, type GitingestArgs } from "./gitingest";
+export { createDiffSummaryTool, diffSummary, type DiffSummaryArgs } from "./diff-summary";
+export { createPromptSessionTool, type PromptSessionArgs } from "./prompt-session";
+export { createListChildSessionsTool } from "./list-child-sessions";
+export { ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, EtherscanClient, EtherscanClientError, weiToEth, formatTimestamp, shortenAddress, type EthTransactionArgs, type EthAddressTxsArgs, type EthAddressBalanceArgs, type EthTokenTransfersArgs, } from "./blockchain";

package/dist/tools/index.js

@@ -0,0 +1,5 @@
+export { gitingestTool, fetchGitingest } from "./gitingest";
+export { createDiffSummaryTool, diffSummary } from "./diff-summary";
+export { createPromptSessionTool } from "./prompt-session";
+export { createListChildSessionsTool } from "./list-child-sessions";
+export { ethTransactionTool, ethAddressTxsTool, ethAddressBalanceTool, ethTokenTransfersTool, EtherscanClient, EtherscanClientError, weiToEth, formatTimestamp, shortenAddress, } from "./blockchain";

package/dist/tools/list-child-sessions.d.ts

@@ -0,0 +1,9 @@
+import { type ToolContext } from "@opencode-ai/plugin";
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+type Client = ReturnType<typeof createOpencodeClient>;
+export declare function createListChildSessionsTool(client: Client): {
+    description: string;
+    args: {};
+    execute(args: Record<string, never>, context: ToolContext): Promise<string>;
+};
+export {};

package/dist/tools/list-child-sessions.js

@@ -0,0 +1,24 @@
+import { tool } from "@opencode-ai/plugin";
+import { log } from "../logger";
+export function createListChildSessionsTool(client) {
+    return tool({
+        description: "List all child sessions (subagents) of the current session",
+        args: {},
+        async execute(_args, context) {
+            const children = await client.session.children({
+                path: { id: context.sessionID },
+            });
+            const childList = children.data ?? [];
+            if (childList.length === 0) {
+                return "No child sessions found";
+            }
+            log("[list-child-sessions] Found child sessions", { count: childList.length });
+            const formatted = childList.map((child, index) => {
+                const created = new Date(child.time.created).toISOString();
+                const updated = new Date(child.time.updated).toISOString();
+                return `${index + 1}. [${child.id}] ${child.title}\n   Created: ${created} | Updated: ${updated}`;
+            }).join("\n\n");
+            return `Child sessions (${childList.length}):\n\n${formatted}`;
+        },
+    });
+}

package/dist/tools/prompt-session.d.ts

@@ -0,0 +1,19 @@
+import { type ToolContext } from "@opencode-ai/plugin";
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+type Client = ReturnType<typeof createOpencodeClient>;
+export interface PromptSessionArgs {
+    message: string;
+    sessionId?: string;
+}
+export declare function createPromptSessionTool(client: Client): {
+    description: string;
+    args: {
+        message: import("zod").ZodString;
+        sessionId: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        message: string;
+        sessionId?: string | undefined;
+    }, context: ToolContext): Promise<string>;
+};
+export {};

package/dist/tools/prompt-session.js

@@ -0,0 +1,39 @@
+import { tool } from "@opencode-ai/plugin";
+import { log } from "../logger";
+export function createPromptSessionTool(client) {
+    return tool({
+        description: "Send a message to a child session (subagent) to continue the conversation",
+        args: {
+            message: tool.schema.string().describe("The message to send to the child session"),
+            sessionId: tool.schema.string().optional().describe("The child session ID to target (optional - uses last child if not provided)"),
+        },
+        async execute(args, context) {
+            let targetSessionId = args.sessionId;
+            if (!targetSessionId) {
+                const children = await client.session.children({
+                    path: { id: context.sessionID },
+                });
+                const lastChild = (children.data ?? []).at(-1);
+                if (!lastChild) {
+                    return "Error: No child session found for current session";
+                }
+                targetSessionId = lastChild.id;
+            }
+            log("[prompt-session] Sending message to child session", {
+                parentSessionID: context.sessionID,
+                childSessionID: targetSessionId,
+                messagePreview: args.message.slice(0, 100),
+            });
+            const response = await client.session.prompt({
+                path: { id: targetSessionId },
+                body: { parts: [{ type: "text", text: args.message }] },
+            });
+            const parts = response.data?.parts ?? [];
+            const textContent = parts
+                .filter((p) => p.type === "text" && p.text)
+                .map((p) => p.text)
+                .join("\n");
+            return textContent || "Message sent to child session";
+        },
+    });
+}

package/dist/tools/reply-child.d.ts

@@ -0,0 +1,19 @@
+import { type ToolContext } from "@opencode-ai/plugin";
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+type Client = ReturnType<typeof createOpencodeClient>;
+export interface ReplyChildArgs {
+    message: string;
+    sessionId?: string;
+}
+export declare function createReplyChildTool(client: Client): {
+    description: string;
+    args: {
+        message: import("zod").ZodString;
+        sessionId: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        message: string;
+        sessionId?: string | undefined;
+    }, context: ToolContext): Promise<string>;
+};
+export {};