@wavexzore/sandbox 0.1.0

package/dist/sandbox/plugins/system-transform.js

@@ -0,0 +1,23 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Adds sandbox-specific instructions to the system prompt.
+ */
+export async function systemPromptTransform(ctx, repoPath) {
+    return async (input, output) => {
+        output.system.push([
+            '## Docker Sandbox Integration',
+            'This session is integrated with a Docker sandbox.',
+            `The main project repository is located at: ${repoPath}.`,
+            'Bash commands run inside the Docker sandbox, defaulting to this project directory.',
+            "Prefer the bash tool's workdir parameter over inline 'cd ... && ...' commands.",
+            'Bash output is truncated automatically when large; full output is saved outside the project when available.',
+            'Use read/write/edit/multiedit/apply_patch/glob/grep for file operations and search instead of shelling out to cat/echo/sed/find/grep when a dedicated tool fits.',
+            'Put all projects in the project directory. Do NOT try to use the current working directory of the host system.',
+            "When executing long-running commands, use the 'background' option and manage them with bash_status, bash_output, and bash_stop.",
+            'Before showing a preview URL, ensure the server is running in the sandbox on that port.',
+        ].join('\n'));
+    };
+}

package/dist/sandbox/tools/bash-output.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+export declare const bashOutputTool: (sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput) => {
+    description: string;
+    args: {
+        cmdId: z.ZodString;
+        maxBytes: z.ZodOptional<z.ZodNumber>;
+        maxLines: z.ZodOptional<z.ZodNumber>;
+    };
+    execute(args: {
+        cmdId: string;
+        maxBytes?: number;
+        maxLines?: number;
+    }, ctx: ToolContext): Promise<string>;
+};

package/dist/sandbox/tools/bash-output.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { loadShellToolConfig } from '../core/shell/config.js';
+export const bashOutputTool = (sessionManager, projectId, worktree, pluginCtx) => ({
+    description: 'Reads output from a managed background bash command in the Docker sandbox',
+    args: {
+        cmdId: z.string().min(1),
+        maxBytes: z.number().int().positive().optional().describe('Maximum bytes to read from stdout/stderr tail'),
+        maxLines: z.number().int().positive().optional().describe('Maximum lines to read from stdout/stderr tail'),
+    },
+    async execute(args, ctx) {
+        const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree, pluginCtx);
+        const shellConfig = loadShellToolConfig(worktree);
+        const output = await sandbox.process.readBackgroundCommand(args.cmdId, {
+            maxOutputBytes: args.maxBytes ?? shellConfig.maxOutputBytes,
+            maxOutputLines: args.maxLines ?? shellConfig.maxOutputLines,
+        });
+        if (typeof ctx.metadata === 'function') {
+            ctx.metadata({
+                title: `bash_output ${args.cmdId}`,
+                metadata: {
+                    cmdId: output.cmdId,
+                    stdoutBytes: output.stdoutBytes,
+                    stderrBytes: output.stderrBytes,
+                    stdoutLines: output.stdoutLines,
+                    stderrLines: output.stderrLines,
+                    truncated: output.truncated,
+                    runDir: output.runDir,
+                    sandbox: sandbox.id,
+                },
+            });
+        }
+        const text = output.output || '(no output)';
+        return `${text}\n\n<shell_background_output>\ncmdId: ${output.cmdId}\nstdoutBytes: ${output.stdoutBytes}\nstderrBytes: ${output.stderrBytes}\nstdoutLines: ${output.stdoutLines ?? 0}\nstderrLines: ${output.stderrLines ?? 0}\ntruncated: ${output.truncated}\n${output.runDir ? `runDir: ${output.runDir}\n` : ''}</shell_background_output>`;
+    },
+});

package/dist/sandbox/tools/bash-status.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+export declare const bashStatusTool: (sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput) => {
+    description: string;
+    args: {
+        cmdId: z.ZodString;
+    };
+    execute(args: {
+        cmdId: string;
+    }, ctx: ToolContext): Promise<string>;
+};

package/dist/sandbox/tools/bash-status.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export const bashStatusTool = (sessionManager, projectId, worktree, pluginCtx) => ({
+    description: 'Checks the status of a managed background bash command in the Docker sandbox',
+    args: {
+        cmdId: z.string().min(1),
+    },
+    async execute(args, ctx) {
+        const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree, pluginCtx);
+        const status = await sandbox.process.getBackgroundCommand(args.cmdId);
+        if (typeof ctx.metadata === 'function') {
+            ctx.metadata({
+                title: `bash_status ${args.cmdId}`,
+                metadata: {
+                    ...status,
+                    sandbox: sandbox.id,
+                },
+            });
+        }
+        return [
+            `cmdId: ${status.cmdId}`,
+            `status: ${status.status}`,
+            `exitCode: ${status.exitCode === null ? 'null' : status.exitCode}`,
+            status.pid ? `pid: ${status.pid}` : undefined,
+            status.runDir ? `runDir: ${status.runDir}` : undefined,
+        ]
+            .filter(Boolean)
+            .join('\n');
+    },
+});

package/dist/sandbox/tools/bash-stop.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+export declare const bashStopTool: (sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput) => {
+    description: string;
+    args: {
+        cmdId: z.ZodString;
+    };
+    execute(args: {
+        cmdId: string;
+    }, ctx: ToolContext): Promise<string>;
+};

package/dist/sandbox/tools/bash-stop.js

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export const bashStopTool = (sessionManager, projectId, worktree, pluginCtx) => ({
+    description: 'Stops a managed background bash command in the Docker sandbox',
+    args: {
+        cmdId: z.string().min(1),
+    },
+    async execute(args, ctx) {
+        const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree, pluginCtx);
+        const status = await sandbox.process.stopBackgroundCommand(args.cmdId);
+        if (typeof ctx.metadata === 'function') {
+            ctx.metadata({
+                title: `bash_stop ${args.cmdId}`,
+                metadata: {
+                    ...status,
+                    sandbox: sandbox.id,
+                },
+            });
+        }
+        return [
+            `cmdId: ${status.cmdId}`,
+            `status: ${status.status}`,
+            `exitCode: ${status.exitCode === null ? 'null' : status.exitCode}`,
+            status.runDir ? `runDir: ${status.runDir}` : undefined,
+        ]
+            .filter(Boolean)
+            .join('\n');
+    },
+});

package/dist/sandbox/tools/bash.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+import type { PathMapper } from '../core/path-map.js';
+export declare const bashTool: (sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput, mapPath: PathMapper) => {
+    description: string;
+    args: {
+        command: z.ZodString;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        workdir: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        background: z.ZodOptional<z.ZodBoolean>;
+    };
+    execute(args: {
+        command: string;
+        timeout?: number;
+        workdir?: string;
+        description?: string;
+        background?: boolean;
+    }, ctx: ToolContext): Promise<string>;
+};

package/dist/sandbox/tools/bash.js

@@ -0,0 +1,120 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import { commandDescription, requestBashPermission } from '../core/shell/permissions.js';
+import { previewOutput } from '../core/shell/output.js';
+import { resolveShellWorkdir } from '../core/shell/workdir.js';
+import { loadShellToolConfig } from '../core/shell/config.js';
+export const bashTool = (sessionManager, projectId, worktree, pluginCtx, mapPath) => ({
+    description: 'Executes shell commands in the Docker sandbox with OpenCode-style bash permission, workdir, timeout, metadata, and output truncation. Prefer dedicated read/write/edit/glob/grep tools for file operations.',
+    args: {
+        command: z.string().min(1).describe('The command to execute'),
+        timeout: z.number().int().positive().optional().describe('Optional timeout in milliseconds'),
+        workdir: z
+            .string()
+            .optional()
+            .describe("Working directory. Defaults to the sandbox project root; prefer this over 'cd'."),
+        description: z.string().optional().describe('Clear, concise description of what this command does'),
+        background: z.boolean().optional().describe('Run as a managed long-lived background command'),
+    },
+    async execute(args, ctx) {
+        const sessionId = ctx.sessionID;
+        const sandbox = await sessionManager.getSandbox(sessionId, projectId, worktree, pluginCtx);
+        const shellConfig = loadShellToolConfig(worktree);
+        const cwd = resolveShellWorkdir(args.workdir, mapPath, {
+            allowOutsideProject: shellConfig.allowWorkdirOutsideProject,
+        });
+        const description = commandDescription(args.command, args.description);
+        const timeoutMs = args.timeout ?? shellConfig.defaultTimeoutMs;
+        await requestBashPermission({
+            ctx,
+            command: args.command,
+            description,
+            workdir: cwd,
+            timeoutMs,
+            background: args.background,
+            sandboxId: sandbox.id,
+        });
+        if (args.background) {
+            const result = await sandbox.process.startBackgroundCommand(args.command, {
+                cwd,
+                sessionId,
+            });
+            if (typeof ctx.metadata === 'function') {
+                ctx.metadata({
+                    title: description,
+                    metadata: {
+                        command: args.command,
+                        description,
+                        workdir: cwd,
+                        background: true,
+                        cmdId: result.cmdId,
+                        runDir: result.runDir,
+                        sandbox: sandbox.id,
+                    },
+                });
+            }
+            return [
+                `Command started in background.`,
+                `cmdId: ${result.cmdId}`,
+                `workdir: ${cwd}`,
+                `runDir: ${result.runDir}`,
+                '',
+                'Use bash_status, bash_output, or bash_stop with this cmdId to manage the command.',
+            ].join('\n');
+        }
+        const result = await sandbox.process.executeCommand(args.command, {
+            cwd,
+            timeoutMs,
+            signal: ctx.abort,
+            sessionId,
+            maxOutputBytes: shellConfig.maxOutputBytes,
+            maxOutputLines: shellConfig.maxOutputLines,
+            onUpdate: (update) => {
+                if (typeof ctx.metadata !== 'function')
+                    return;
+                ctx.metadata({
+                    title: description,
+                    metadata: {
+                        command: args.command,
+                        description,
+                        workdir: cwd,
+                        output: previewOutput(update.output || ''),
+                        truncated: update.truncated,
+                        stdoutBytes: update.stdoutBytes,
+                        stderrBytes: update.stderrBytes,
+                        stdoutLines: update.stdoutLines,
+                        stderrLines: update.stderrLines,
+                        durationMs: update.durationMs,
+                        sandbox: sandbox.id,
+                    },
+                });
+            },
+        });
+        if (typeof ctx.metadata === 'function') {
+            ctx.metadata({
+                title: description,
+                metadata: {
+                    command: args.command,
+                    description,
+                    workdir: cwd,
+                    output: previewOutput(result.result || ''),
+                    exit: result.exitCode,
+                    timedOut: result.timedOut,
+                    aborted: result.aborted,
+                    truncated: result.truncated,
+                    outputPath: result.outputPath,
+                    stdoutBytes: result.stdoutBytes,
+                    stderrBytes: result.stderrBytes,
+                    stdoutLines: result.stdoutLines,
+                    stderrLines: result.stderrLines,
+                    durationMs: result.durationMs,
+                    sandbox: sandbox.id,
+                },
+            });
+        }
+        return result.result;
+    },
+});

package/dist/sandbox/tools/edit.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+import type { PathMapper } from '../core/path-map.js';
+export declare const editTool: (sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput, mapPath: PathMapper) => {
+    description: string;
+    args: {
+        filePath: z.ZodString;
+        oldString: z.ZodString;
+        newString: z.ZodString;
+        replaceAll: z.ZodOptional<z.ZodBoolean>;
+    };
+    execute(args: {
+        filePath: string;
+        oldString: string;
+        newString: string;
+        replaceAll?: boolean;
+    }, ctx: ToolContext): Promise<string>;
+};

package/dist/sandbox/tools/edit.js

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import { decodeUtf8, sandboxWriteFile, splitBom } from '../core/write/index.js';
+import { applyOpenCodeEdit, createFileDiff, withFileLock } from '../core/edit/index.js';
+function metadataDiagnostics(diagnostics) {
+    return {
+        current: diagnostics.current,
+        other: diagnostics.other,
+        unavailable: diagnostics.unavailable,
+    };
+}
+export const editTool = (sessionManager, projectId, worktree, pluginCtx, mapPath) => ({
+    description: 'Replaces text in a file in Docker sandbox using OpenCode-like edit permission, fuzzy matching, diff metadata, formatter, and host LSP diagnostics',
+    args: {
+        filePath: z.string(),
+        oldString: z.string(),
+        newString: z.string(),
+        replaceAll: z.boolean().optional().describe('Replace all occurrences of oldString (default false)'),
+    },
+    async execute(args, ctx) {
+        if (args.oldString === args.newString) {
+            throw new Error('No changes to apply: oldString and newString are identical.');
+        }
+        const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree, pluginCtx);
+        const containerPath = mapPath.toContainer(args.filePath);
+        const hostPath = mapPath.toHost(containerPath);
+        return withFileLock(hostPath, async () => {
+            let buffer;
+            let oldExists = false;
+            if (args.oldString !== '') {
+                try {
+                    buffer = await sandbox.fs.downloadFile(containerPath);
+                    oldExists = true;
+                }
+                catch {
+                    throw new Error(`File ${args.filePath} not found`);
+                }
+            }
+            else {
+                buffer = await sandbox.fs.downloadFile(containerPath).catch(() => undefined);
+                oldExists = Boolean(buffer);
+            }
+            const oldContent = buffer ? splitBom(decodeUtf8(buffer)).text : '';
+            const nextContent = args.oldString === ''
+                ? args.newString
+                : applyOpenCodeEdit({
+                    content: oldContent,
+                    oldString: args.oldString,
+                    newString: args.newString,
+                    replaceAll: args.replaceAll,
+                }).content;
+            const result = await sandboxWriteFile({
+                ctx,
+                sandbox,
+                sessionID: ctx.sessionID,
+                worktree,
+                paths: mapPath,
+                filePath: args.filePath,
+                content: nextContent,
+                operation: 'edit',
+                oldContentBuffer: buffer,
+                oldExists,
+                setMetadata: false,
+            });
+            const finalText = splitBom(result.finalContent).text;
+            const filediff = createFileDiff({ file: result.hostPath, oldContent, newContent: finalText });
+            if (typeof ctx.metadata === 'function') {
+                ctx.metadata({
+                    title: result.relativePath,
+                    metadata: {
+                        operation: 'edit',
+                        diagnostics: metadataDiagnostics(result.diagnostics),
+                        filepath: result.hostPath,
+                        containerPath: result.containerPath,
+                        exists: result.exists,
+                        diff: filediff.patch,
+                        filediff,
+                        formatted: result.formatted,
+                    },
+                });
+            }
+            let output = 'Edit applied successfully.';
+            if (result.diagnostics.output)
+                output += '\n\n' + result.diagnostics.output;
+            return output;
+        });
+    },
+});

package/dist/sandbox/tools/get-preview-url.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+export declare const getPreviewURLTool: (sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput) => {
+    description: string;
+    args: {
+        port: z.ZodNumber;
+    };
+    execute(args: {
+        port: number;
+    }, ctx: ToolContext): Promise<string>;
+};

package/dist/sandbox/tools/get-preview-url.js

@@ -0,0 +1,16 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+export const getPreviewURLTool = (sessionManager, projectId, worktree, pluginCtx) => ({
+    description: 'Gets a preview URL for the Docker sandbox',
+    args: {
+        port: z.number(),
+    },
+    async execute(args, ctx) {
+        const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree, pluginCtx);
+        const previewLink = await sandbox.getPreviewLink(args.port);
+        return `Sandbox Preview URL: ${previewLink.url}`;
+    },
+});

package/dist/sandbox/tools/glob.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+export declare const globTool: (sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput, mapPath: (p: string) => string) => {
+    description: string;
+    args: {
+        pattern: z.ZodString;
+    };
+    execute(args: {
+        pattern: string;
+    }, ctx: ToolContext): Promise<string>;
+};

package/dist/sandbox/tools/glob.js

@@ -0,0 +1,23 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+export const globTool = (sessionManager, projectId, worktree, pluginCtx, mapPath) => {
+    void mapPath;
+    return {
+        description: 'Searches for files matching a pattern in Docker sandbox',
+        args: {
+            pattern: z.string(),
+        },
+        async execute(args, ctx) {
+            const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree, pluginCtx);
+            const workDir = await sandbox.getWorkDir();
+            if (!workDir) {
+                throw new Error('Work directory not available');
+            }
+            const result = await sandbox.fs.searchFiles(workDir, args.pattern);
+            return result.files.join('\n');
+        },
+    };
+};

package/dist/sandbox/tools/grep.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+export declare const grepTool: (sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput, mapPath: (p: string) => string) => {
+    description: string;
+    args: {
+        pattern: z.ZodString;
+    };
+    execute(args: {
+        pattern: string;
+    }, ctx: ToolContext): Promise<string>;
+};

package/dist/sandbox/tools/grep.js

@@ -0,0 +1,23 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+export const grepTool = (sessionManager, projectId, worktree, pluginCtx, mapPath) => {
+    void mapPath;
+    return {
+        description: 'Searches for text pattern in files in Docker sandbox',
+        args: {
+            pattern: z.string(),
+        },
+        async execute(args, ctx) {
+            const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree, pluginCtx);
+            const workDir = await sandbox.getWorkDir();
+            if (!workDir) {
+                throw new Error('Work directory not available');
+            }
+            const matches = await sandbox.fs.findFiles(workDir, args.pattern);
+            return matches.map((m) => `${m.file}:${m.line}: ${m.content}`).join('\n');
+        },
+    };
+};

package/dist/sandbox/tools/ls.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+export declare const lsTool: (sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput, mapPath: (p: string) => string) => {
+    description: string;
+    args: {
+        dirPath: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        dirPath?: string;
+    }, ctx: ToolContext): Promise<string>;
+};

package/dist/sandbox/tools/ls.js

@@ -0,0 +1,21 @@
+/**
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+export const lsTool = (sessionManager, projectId, worktree, pluginCtx, mapPath) => ({
+    description: 'Lists files in a directory in Docker sandbox',
+    args: {
+        dirPath: z.string().optional(),
+    },
+    async execute(args, ctx) {
+        const sandbox = await sessionManager.getSandbox(ctx.sessionID, projectId, worktree, pluginCtx);
+        const workDir = await sandbox.getWorkDir();
+        const path = args.dirPath ? mapPath(args.dirPath) : workDir;
+        if (!path) {
+            throw new Error('Work directory not available');
+        }
+        const files = await sandbox.fs.listFiles(path);
+        return files.map((f) => f.name).join('\n');
+    },
+});

package/dist/sandbox/tools/lsp.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { ToolContext } from '@opencode-ai/plugin/tool';
+import type { SandboxSessionManager } from '../core/session-manager.js';
+import type { PathMapper } from '../core/path-map.js';
+declare const operations: readonly ["diagnostics", "hover", "documentSymbol", "workspaceSymbol", "references", "findReferences", "definition", "goToDefinition", "implementation", "goToImplementation", "prepareCallHierarchy", "incomingCalls", "outgoingCalls", "status"];
+type LspOperation = (typeof operations)[number];
+type LspArgs = {
+    operation: LspOperation;
+    filePath?: string;
+    line?: number;
+    character?: number;
+    query?: string;
+};
+export declare const lspTool: (sessionManager: SandboxSessionManager, projectId: string, worktree: string, pluginCtx: PluginInput, mapPath: PathMapper) => {
+    description: string;
+    args: {
+        operation: z.ZodEnum<{
+            status: "status";
+            diagnostics: "diagnostics";
+            hover: "hover";
+            documentSymbol: "documentSymbol";
+            workspaceSymbol: "workspaceSymbol";
+            references: "references";
+            findReferences: "findReferences";
+            definition: "definition";
+            goToDefinition: "goToDefinition";
+            implementation: "implementation";
+            goToImplementation: "goToImplementation";
+            prepareCallHierarchy: "prepareCallHierarchy";
+            incomingCalls: "incomingCalls";
+            outgoingCalls: "outgoingCalls";
+        }>;
+        filePath: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+        character: z.ZodOptional<z.ZodNumber>;
+        query: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: LspArgs, ctx: ToolContext): Promise<string>;
+};
+export {};