toolsProvider.js
"use strict";
/**
* High-Performance Tools — toolsProvider
*
* 40 tools across 6 categories:
* Filesystem · Execution · Python Dev · C++ Dev · Research · Git
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.toolsProvider = void 0;
const sdk_1 = require("@lmstudio/sdk");
const promises_1 = require("fs/promises");
const fs_1 = require("fs");
const path_1 = require("path");
const os_1 = require("os");
const duckDuckScrape = __importStar(require("duck-duck-scrape"));
const zod_1 = require("zod");
const config_1 = require("./config");
const sandbox_1 = require("./sandbox");
const memory_1 = require("./agents/memory");
const subagent_1 = require("./agents/subagent");
const dynamicTools_1 = require("./agents/dynamicTools");
// ---------------------------------------------------------------------------
// Internal helpers
// ---------------------------------------------------------------------------
function json(obj) {
return JSON.stringify(obj, null, 2);
}
function disabled(toolName) {
return `Tool '${toolName}' is disabled in plugin settings. Enable it under Settings → Plugins → high-perf-tools.`;
}
function stripHtml(html) {
return html
.replace(/<(script|style)[^>]*>[\s\S]*?<\/\1>/gi, " ")
.replace(/<[^>]+>/g, " ")
.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">")
.replace(/ /g, " ").replace(/"/g, '"').replace(/'/g, "'")
.replace(/[ \t]+/g, " ")
.replace(/\n{3,}/g, "\n\n")
.trim();
}
async function fileExists(p) {
try {
await (0, promises_1.stat)(p);
return true;
}
catch {
return false;
}
}
/**
* Wrap a tool implementation so any thrown error is returned as a structured
* message the model can read and act on, instead of silently failing.
*/
function safe_impl(name, fn) {
return async (params) => {
try {
return await fn(params);
}
catch (err) {
const msg = err instanceof Error ? err.message : String(err);
// Return a structured error the model can parse and self-correct from
return JSON.stringify({
tool_error: true,
tool: name,
error: msg,
hint: "Read the error above, fix the parameter causing the issue, and retry the tool call.",
}, null, 2);
}
};
}
// Shorthand coerced primitive schemas — more lenient than strict zBool(false)/z.number()
const zBool = (def) => zod_1.z.coerce.boolean().default(def);
const zInt = (def) => zod_1.z.coerce.number().int().default(def);
const zNum = (def) => zod_1.z.coerce.number().default(def);
// ---------------------------------------------------------------------------
// Tools Provider
// ---------------------------------------------------------------------------
const toolsProvider = async (ctl) => {
const cfg = ctl.getPluginConfig(config_1.pluginConfigSchematics);
const ws = () => (0, sandbox_1.getWorkspace)(cfg.get("workspacePath"));
const timeout = () => cfg.get("commandTimeoutSeconds");
// Resolve the Python interpreter once (cached per provider instantiation).
// Re-reads config each call so switching envs in settings takes effect on next chat.
const py = async () => (0, sandbox_1.resolvePython)(cfg.get("pythonInterpreter"));
// Permission helpers
const canShell = () => cfg.get("allowShellCommands");
const canPython = () => cfg.get("allowPythonExecution");
const canCpp = () => cfg.get("allowCppCompilation");
const canPip = () => cfg.get("allowPipInstall");
const canGitWrite = () => cfg.get("allowGitWrite");
const preferClang = () => cfg.get("preferClang");
const tools = [
// =========================================================================
// FILESYSTEM
// =========================================================================
(0, sdk_1.tool)({
name: "read_file",
description: (0, sdk_1.text) `
Read a file from the workspace and return its contents.
For large files, use start_line and end_line to read a range.
Binary files return a hex summary.
`,
parameters: {
path: zod_1.z.string().describe("Relative path inside the workspace"),
start_line: zod_1.z.coerce.number().int().min(1).default(1).describe("First line to return (1-indexed)"),
end_line: zInt(0).describe("Last line to return (0 = EOF)"),
},
implementation: safe_impl("read_file", async ({ path, start_line, end_line }) => {
const p = (0, sandbox_1.safe)(ws(), path);
if (!await fileExists(p))
return `File not found: ${path}`;
const s = (0, fs_1.statSync)(p);
if (s.size > 100 * 1024 * 1024)
return `File too large (${(s.size / 1e6).toFixed(1)} MB). Use start_line/end_line.`;
try {
const text = await (0, promises_1.readFile)(p, "utf-8");
const lines = text.split("\n");
const total = lines.length;
const from = start_line - 1;
const to = end_line > 0 ? end_line : total;
return `[Lines ${from + 1}–${Math.min(to, total)} of ${total} | ${(0, path_1.relative)(ws(), p)}]\n` + lines.slice(from, to).join("\n");
}
catch {
const raw = await (0, promises_1.readFile)(p);
return `[Binary — ${s.size} bytes]\n${raw.slice(0, 512).toString("hex").replace(/(.{2})/g, "$1 ")}`;
}
}),
}),
(0, sdk_1.tool)({
name: "write_file",
description: (0, sdk_1.text) `
Write content to a file in the workspace, creating parent directories as needed.
Set append=true to append instead of overwrite.
`,
parameters: {
path: zod_1.z.string().describe("Relative path inside the workspace"),
content: zod_1.z.string().describe("Text content to write"),
append: zBool(false).describe("Append instead of overwrite"),
},
implementation: safe_impl("write_file", async ({ path, content, append }) => {
const p = (0, sandbox_1.safe)(ws(), path);
await (0, promises_1.mkdir)((0, path_1.dirname)(p), { recursive: true });
if (append) {
await (0, promises_1.appendFile)(p, content, "utf-8");
}
else {
await (0, promises_1.writeFile)(p, content, "utf-8");
}
const s = (0, fs_1.statSync)(p);
return `${append ? "Appended" : "Wrote"} ${content.length} chars → ${(0, path_1.relative)(ws(), p)} (${s.size} bytes on disk)`;
}),
}),
(0, sdk_1.tool)({
name: "replace_in_file",
description: (0, sdk_1.text) `
Surgically replace text in a file without rewriting the whole thing.
Set regex=true to use a JavaScript regular expression as the search string.
Set count to limit the number of replacements (0 = all).
`,
parameters: {
path: zod_1.z.string().describe("Relative path inside the workspace"),
search: zod_1.z.string().describe("Exact string or regex pattern to find"),
replacement: zod_1.z.string().describe("Replacement text"),
regex: zBool(false).describe("Treat search as a JS regex"),
count: zod_1.z.coerce.number().int().min(0).default(0).describe("Max replacements (0 = all)"),
},
implementation: safe_impl("replace_in_file", async ({ path, search, replacement, regex, count }) => {
const p = (0, sandbox_1.safe)(ws(), path);
if (!await fileExists(p))
return `File not found: ${path}`;
let original = await (0, promises_1.readFile)(p, "utf-8");
let n = 0;
let result;
if (regex) {
const re = new RegExp(search, "g");
let replaced = 0;
result = original.replace(re, (match, ...args) => {
if (count > 0 && replaced >= count)
return match;
replaced++;
n++;
return replacement;
});
}
else {
// Literal replacement — count all occurrences manually
const idx = original.indexOf(search);
if (idx === -1)
return `No matches for: ${search}`;
let pos = 0;
result = "";
let found = 0;
while (true) {
const i = original.indexOf(search, pos);
if (i === -1 || (count > 0 && found >= count)) {
result += original.slice(pos);
break;
}
result += original.slice(pos, i) + replacement;
pos = i + search.length;
found++;
n++;
}
}
if (n === 0)
return `No matches found for: ${search}`;
await (0, promises_1.writeFile)(p, result, "utf-8");
return `Made ${n} replacement(s) in ${(0, path_1.relative)(ws(), p)}`;
}),
}),
(0, sdk_1.tool)({
name: "delete_path",
description: (0, sdk_1.text) `
Delete a file or directory from the workspace.
Directories require recursive=true unless empty.
`,
parameters: {
path: zod_1.z.string().describe("Relative path to delete"),
recursive: zBool(false).describe("Required for non-empty directories"),
},
implementation: safe_impl("delete_path", async ({ path, recursive }) => {
const p = (0, sandbox_1.safe)(ws(), path);
if (!await fileExists(p))
return `Not found: ${path}`;
const s = (0, fs_1.statSync)(p);
if (s.isDirectory()) {
await (0, promises_1.rm)(p, { recursive, force: false });
return `Deleted directory ${(0, path_1.relative)(ws(), p)}`;
}
await (0, promises_1.unlink)(p);
return `Deleted file ${(0, path_1.relative)(ws(), p)}`;
}),
}),
(0, sdk_1.tool)({
name: "move_path",
description: (0, sdk_1.text) `Move or rename a file/directory within the workspace.`,
parameters: {
src: zod_1.z.string().describe("Source path (relative)"),
dst: zod_1.z.string().describe("Destination path (relative)"),
},
implementation: safe_impl("move_path", async ({ src, dst }) => {
const s = (0, sandbox_1.safe)(ws(), src);
const d = (0, sandbox_1.safe)(ws(), dst);
if (!await fileExists(s))
return `Not found: ${src}`;
await (0, promises_1.mkdir)((0, path_1.dirname)(d), { recursive: true });
await (0, promises_1.rename)(s, d);
return `Moved ${(0, path_1.relative)(ws(), s)} → ${(0, path_1.relative)(ws(), d)}`;
}),
}),
(0, sdk_1.tool)({
name: "copy_path",
description: (0, sdk_1.text) `Copy a file within the workspace.`,
parameters: {
src: zod_1.z.string().describe("Source file path (relative)"),
dst: zod_1.z.string().describe("Destination path (relative)"),
},
implementation: safe_impl("copy_path", async ({ src, dst }) => {
const s = (0, sandbox_1.safe)(ws(), src);
const d = (0, sandbox_1.safe)(ws(), dst);
if (!await fileExists(s))
return `Not found: ${src}`;
await (0, promises_1.mkdir)((0, path_1.dirname)(d), { recursive: true });
await (0, promises_1.copyFile)(s, d);
return `Copied ${(0, path_1.relative)(ws(), s)} → ${(0, path_1.relative)(ws(), d)}`;
}),
}),
(0, sdk_1.tool)({
name: "list_directory",
description: (0, sdk_1.text) `
List files and directories with metadata.
Use pattern like "*.py" to filter by extension.
Use recursive=true to walk subdirectories (capped at max_entries).
`,
parameters: {
path: zod_1.z.string().default(".").describe("Directory to list (default: workspace root)"),
pattern: zod_1.z.string().default("").describe("Filter: extension like '.py' or partial name"),
recursive: zBool(false).describe("Walk subdirectories"),
show_hidden: zBool(false).describe("Include dot-files"),
max_entries: zod_1.z.coerce.number().int().min(1).max(10000).default(2000).describe("Entry limit"),
},
implementation: safe_impl("list_directory", async ({ path, pattern, recursive, show_hidden, max_entries }) => {
const p = (0, sandbox_1.safe)(ws(), path);
if (!await fileExists(p))
return `Directory not found: ${path}`;
const entries = [];
let truncated = false;
async function walk(dir) {
if (entries.length >= max_entries) {
truncated = true;
return;
}
const items = await (0, promises_1.readdir)(dir, { withFileTypes: true });
for (const item of items) {
if (!show_hidden && item.name.startsWith("."))
continue;
if (pattern && !item.name.includes(pattern) && !item.name.endsWith(pattern))
continue;
if (entries.length >= max_entries) {
truncated = true;
return;
}
const full = (0, path_1.join)(dir, item.name);
const rel = (0, path_1.relative)(ws(), full);
if (item.isDirectory()) {
entries.push({ name: rel, type: "dir" });
if (recursive)
await walk(full);
}
else {
try {
const st = (0, fs_1.statSync)(full);
entries.push({ name: rel, type: "file", size: st.size });
}
catch { /* skip */ }
}
}
}
await walk(p);
return json({ entries, count: entries.length, truncated });
}),
}),
(0, sdk_1.tool)({
name: "create_directory",
description: (0, sdk_1.text) `Create a directory (and all missing parents) inside the workspace.`,
parameters: {
path: zod_1.z.string().describe("Relative path to create"),
},
implementation: safe_impl("create_directory", async ({ path }) => {
const p = (0, sandbox_1.safe)(ws(), path);
await (0, promises_1.mkdir)(p, { recursive: true });
return `Directory ready: ${(0, path_1.relative)(ws(), p)}`;
}),
}),
(0, sdk_1.tool)({
name: "file_info",
description: (0, sdk_1.text) `Return metadata about a file: size, line count, permissions, MIME type.`,
parameters: {
path: zod_1.z.string().describe("Relative path to inspect"),
},
implementation: safe_impl("file_info", async ({ path }) => {
const p = (0, sandbox_1.safe)(ws(), path);
if (!await fileExists(p))
return `Not found: ${path}`;
const s = (0, fs_1.statSync)(p);
const info = {
path: (0, path_1.relative)(ws(), p),
type: s.isDirectory() ? "directory" : "file",
size_bytes: s.size,
modified: s.mtime.toISOString(),
mode: (s.mode & 0o777).toString(8),
};
if (s.isFile()) {
try {
const content = await (0, promises_1.readFile)(p, "utf-8");
info.line_count = content.split("\n").length;
info.encoding = "utf-8";
}
catch {
info.encoding = "binary";
}
}
return json(info);
}),
}),
(0, sdk_1.tool)({
name: "search_in_files",
description: (0, sdk_1.text) `
Search for a string or regex across files in the workspace (like grep).
Returns matching lines with surrounding context.
`,
parameters: {
pattern: zod_1.z.string().describe("Text or regex to search for"),
directory: zod_1.z.string().default(".").describe("Directory to search (default: workspace root)"),
file_extension: zod_1.z.string().default("").describe('Restrict to files with this extension (e.g. ".py")'),
regex: zBool(false).describe("Treat pattern as a JS regex"),
case_sensitive: zBool(true).describe("Case-sensitive matching"),
context_lines: zod_1.z.coerce.number().int().min(0).max(10).default(2).describe("Lines of context around each match"),
max_matches: zod_1.z.coerce.number().int().min(1).max(500).default(200).describe("Stop after this many matches"),
},
implementation: safe_impl("search_in_files", async ({ pattern, directory, file_extension, regex, case_sensitive, context_lines, max_matches }) => {
const base = (0, sandbox_1.safe)(ws(), directory);
const flags = case_sensitive ? "" : "i";
let re;
try {
re = new RegExp(regex ? pattern : pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags);
}
catch (e) {
return `Invalid regex: ${e.message}`;
}
const results = [];
let total = 0;
async function walk(dir) {
const items = await (0, promises_1.readdir)(dir, { withFileTypes: true });
for (const item of items) {
if (item.name.startsWith("."))
continue;
const full = (0, path_1.join)(dir, item.name);
if (item.isDirectory()) {
await walk(full);
continue;
}
if (file_extension && !item.name.endsWith(file_extension))
continue;
try {
const st = (0, fs_1.statSync)(full);
if (st.size > 20 * 1024 * 1024) {
results.push(`[skipped ${(0, path_1.relative)(ws(), full)}: ${(st.size / 1e6).toFixed(0)} MB]`);
continue;
}
const content = await (0, promises_1.readFile)(full, "utf-8");
const lines = content.split("\n");
for (let i = 0; i < lines.length; i++) {
if (re.test(lines[i])) {
if (++total > max_matches)
return;
const from = Math.max(0, i - context_lines);
const to = Math.min(lines.length - 1, i + context_lines);
const block = [`${(0, path_1.relative)(ws(), full)}:${i + 1}: ${lines[i]}`];
for (let c = from; c <= to; c++) {
if (c !== i)
block.push(` ${c + 1}: ${lines[c]}`);
}
results.push(block.join("\n"));
}
}
}
catch { /* skip binary/unreadable */ }
}
}
await walk(base);
if (total === 0)
return `No matches for ${pattern} in ${directory}`;
const header = total > max_matches
? `Found ${max_matches}+ matches (stopped at limit):\n\n`
: `Found ${total} match(es):\n\n`;
return header + results.join("\n---\n");
}),
}),
// =========================================================================
// EXECUTION
// =========================================================================
(0, sdk_1.tool)({
name: "run_command",
description: (0, sdk_1.text) `
Run a shell command inside the workspace.
WARNING: This executes arbitrary commands — the cwd sandbox only sets the starting
directory. Enable in Settings → Plugins → high-perf-tools → Allow Shell Commands.
`,
parameters: {
command: zod_1.z.string().describe("Shell command string"),
cwd: zod_1.z.string().default(".").describe("Working directory relative to workspace"),
stdin: zod_1.z.string().default("").describe("Text piped to stdin"),
},
implementation: safe_impl("run_command", async ({ command, cwd, stdin }) => {
if (!canShell())
return disabled("run_command");
const dir = (0, sandbox_1.safe)(ws(), cwd);
const r = await (0, sandbox_1.runShell)(command, { cwd: dir, stdin: stdin || undefined, timeout: timeout() });
return json({ returncode: r.code, stdout: r.stdout, stderr: r.stderr, success: r.success });
}),
}),
(0, sdk_1.tool)({
name: "run_python_code",
description: (0, sdk_1.text) `
Execute a Python code snippet. Creates a temp file and runs it with the system Python.
Enable in Settings → Allow Python Execution.
`,
parameters: {
code: zod_1.z.string().describe("Python source code"),
stdin: zod_1.z.string().default("").describe("Text piped to stdin"),
},
implementation: safe_impl("run_python_code", async ({ code, stdin }) => {
if (!canPython())
return disabled("run_python_code");
const tmp = (0, path_1.join)((0, os_1.tmpdir)(), `lms_py_${Date.now()}.py`);
try {
await (0, promises_1.writeFile)(tmp, code, "utf-8");
const r = await (0, sandbox_1.run)(await py(), [tmp], { stdin: stdin || undefined, timeout: timeout() });
return json({ returncode: r.code, stdout: r.stdout, stderr: r.stderr, success: r.success });
}
finally {
(0, promises_1.unlink)(tmp).catch(() => { });
}
}),
}),
(0, sdk_1.tool)({
name: "run_python_file",
description: (0, sdk_1.text) `
Run a Python script that already exists in the workspace.
Enable in Settings → Allow Python Execution.
`,
parameters: {
path: zod_1.z.string().describe("Relative path to the .py file"),
args: zod_1.z.string().default("").describe("Space-separated arguments"),
stdin: zod_1.z.string().default("").describe("Text piped to stdin"),
},
implementation: safe_impl("run_python_file", async ({ path, args, stdin }) => {
if (!canPython())
return disabled("run_python_file");
const p = (0, sandbox_1.safe)(ws(), path);
if (!await fileExists(p))
return `File not found: ${path}`;
const argv = args.trim() ? args.split(/\s+/) : [];
const r = await (0, sandbox_1.run)(await py(), [p, ...argv], {
cwd: ws(), stdin: stdin || undefined, timeout: timeout(),
});
return json({ returncode: r.code, stdout: r.stdout, stderr: r.stderr, success: r.success });
}),
}),
(0, sdk_1.tool)({
name: "get_environment",
description: (0, sdk_1.text) `
Return key runtime information: Python version, PATH, compiler availability,
and which development tools are installed.
`,
parameters: {},
implementation: safe_impl("get_environment", async () => {
const checks = [
"python3", "pip3", "gcc", "g++", "clang", "clang++",
"cmake", "make", "ninja", "ruff", "black", "mypy",
"pytest", "clang-format", "clang-tidy", "git",
];
const info = {};
await Promise.all(checks.map(async (t) => {
const r = await (0, sandbox_1.run)("which", [t], { timeout: 3 });
info[t] = r.success ? r.stdout.trim() : "not found";
}));
const pyVer = await (0, sandbox_1.run)(await py(), ["--version"], { timeout: 5 });
return json({
workspace: ws(),
platform: process.platform,
node: process.version,
python: pyVer.stdout.trim() || pyVer.stderr.trim(),
tools: info,
});
}),
}),
// =========================================================================
// PYTHON DEV
// =========================================================================
(0, sdk_1.tool)({
name: "analyze_python",
description: (0, sdk_1.text) `
Parse a Python file with the AST and return its full structure:
imports, classes (with methods), functions (with signatures and docstrings),
and top-level globals.
`,
parameters: {
path: zod_1.z.string().describe("Relative path to the .py file"),
},
implementation: safe_impl("analyze_python", async ({ path }) => {
if (!canPython())
return disabled("analyze_python");
const p = (0, sandbox_1.safe)(ws(), path);
if (!await fileExists(p))
return `File not found: ${path}`;
const script = `
import ast, json, sys
src = open(${JSON.stringify(p)}).read()
try:
tree = ast.parse(src, filename=${JSON.stringify(p)})
except SyntaxError as e:
print(json.dumps({"syntax_error": str(e)})); sys.exit(0)
result = {"imports": [], "classes": [], "functions": [], "globals": []}
def get_args(f):
a = f.args
pos = [f"{x.arg}/" for x in (a.posonlyargs or [])]
reg = [x.arg for x in a.args]
var = [f"*{a.vararg.arg}"] if a.vararg else []
kwo = [x.arg for x in a.kwonlyargs]
kw = [f"**{a.kwarg.arg}"] if a.kwarg else []
return pos + reg + var + kwo + kw
for node in tree.body:
if isinstance(node, (ast.Import, ast.ImportFrom)):
if isinstance(node, ast.Import):
result["imports"] += [a.asname or a.name for a in node.names]
else:
m = node.module or ""
result["imports"] += [f"{m}.{a.asname or a.name}" for a in node.names]
elif isinstance(node, ast.ClassDef):
methods = []
for item in node.body:
if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
methods.append({"name": item.name, "async": isinstance(item, ast.AsyncFunctionDef),
"args": get_args(item), "returns": ast.unparse(item.returns) if item.returns else None,
"doc": ast.get_docstring(item), "line": item.lineno})
result["classes"].append({"name": node.name,
"bases": [ast.unparse(b) for b in node.bases],
"methods": methods, "doc": ast.get_docstring(node), "line": node.lineno})
elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
result["functions"].append({"name": node.name, "async": isinstance(node, ast.AsyncFunctionDef),
"args": get_args(node), "returns": ast.unparse(node.returns) if node.returns else None,
"doc": ast.get_docstring(node), "line": node.lineno,
"decorators": [ast.unparse(d) for d in node.decorator_list]})
elif isinstance(node, ast.Assign):
for t in node.targets:
if isinstance(t, ast.Name): result["globals"].append(t.id)
print(json.dumps(result))
`;
const r = await (0, sandbox_1.run)(await py(), ["-c", script], { timeout: 30 });
return r.success ? r.stdout.trim() : `Analysis failed:\n${r.stderr}`;
}),
}),
(0, sdk_1.tool)({
name: "format_python",
description: (0, sdk_1.text) `
Format a Python file in-place using ruff (preferred) or black.
Set check_only=true to report if formatting is needed without changing the file.
`,
parameters: {
path: zod_1.z.string().describe("Relative path to the .py file or directory"),
tool: zod_1.z.enum(["auto", "ruff", "black"]).default("auto").describe("Formatter to use"),
check_only: zBool(false).describe("Report only, do not modify"),
},
implementation: safe_impl("format_python", async ({ path, tool: fmt, check_only }) => {
const p = (0, sandbox_1.safe)(ws(), path);
if (!await fileExists(p))
return `Not found: ${path}`;
const hasRuff = (await (0, sandbox_1.run)("which", ["ruff"], { timeout: 3 })).success;
const hasBlack = (await (0, sandbox_1.run)("which", ["black"], { timeout: 3 })).success;
const useRuff = fmt === "auto" ? hasRuff : fmt === "ruff";
if (useRuff && !hasRuff)
return "ruff not found. Install with: pip install ruff";
if (!useRuff && !hasBlack)
return "black not found. Install with: pip install black";
let cmd;
let args;
if (useRuff) {
cmd = "ruff";
args = ["format", ...(check_only ? ["--check"] : []), p];
}
else {
cmd = "black";
args = [...(check_only ? ["--check"] : []), p];
}
const r = await (0, sandbox_1.run)(cmd, args, { timeout: 30 });
return (r.stdout + r.stderr).trim() || `Formatted with ${useRuff ? "ruff" : "black"}`;
}),
}),
(0, sdk_1.tool)({
name: "lint_python",
description: (0, sdk_1.text) `
Lint a Python file and return diagnostics (ruff or pylint).
Set fix=true to auto-fix safe violations (ruff only).
`,
parameters: {
path: zod_1.z.string().describe("Relative path to .py file or directory"),
tool: zod_1.z.enum(["auto", "ruff", "pylint"]).default("auto").describe("Linter to use"),
fix: zBool(false).describe("Auto-fix safe violations (ruff only)"),
},
implementation: safe_impl("lint_python", async ({ path, tool: linter, fix }) => {
const p = (0, sandbox_1.safe)(ws(), path);
if (!await fileExists(p))
return `Not found: ${path}`;
const hasRuff = (await (0, sandbox_1.run)("which", ["ruff"], { timeout: 3 })).success;
const useRuff = linter === "auto" ? hasRuff : linter === "ruff";
let cmd;
let args;
if (useRuff) {
cmd = "ruff";
args = ["check", ...(fix ? ["--fix"] : []), "--output-format", "text", p];
}
else {
cmd = "pylint";
args = [p];
}
const r = await (0, sandbox_1.run)(cmd, args, { timeout: 60 });
return (r.stdout + r.stderr).trim() || "No issues found.";
}),
}),
(0, sdk_1.tool)({
name: "run_tests",
description: (0, sdk_1.text) `
Run pytest on a path and return the test report.
Use pattern to filter tests by name (passed as -k).
`,
parameters: {
path: zod_1.z.string().default(".").describe("Path to test file or directory"),
pattern: zod_1.z.string().default("").describe("pytest -k pattern to filter tests"),
verbose: zBool(true).describe("Show individual test outcomes"),
extra_args: zod_1.z.string().default("").describe("Additional pytest arguments"),
},
implementation: safe_impl("run_tests", async ({ path, pattern, verbose, extra_args }) => {
if (!canPython())
return disabled("run_tests");
const p = (0, sandbox_1.safe)(ws(), path);
const python = await py();
// Use the env's own pytest if available, otherwise fall back to python -m pytest
const envPytest = python.replace(/\/python[^/]*$/, "/pytest");
const hasPytest = (await (0, sandbox_1.run)(envPytest, ["--version"], { timeout: 3 })).success;
const extraFlags = [
...(verbose ? ["-v"] : []),
...(pattern ? ["-k", pattern] : []),
...(extra_args.trim() ? extra_args.split(/\s+/) : []),
p,
];
const cmd = hasPytest ? envPytest : python;
const args = hasPytest ? extraFlags : ["-m", "pytest", ...extraFlags];
const r = await (0, sandbox_1.run)(cmd, args, { cwd: ws(), timeout: timeout() });
return (r.stdout + r.stderr).trim();
}),
}),
(0, sdk_1.tool)({
name: "pip_install",
description: (0, sdk_1.text) `
Install Python packages with pip.
Enable in Settings → Allow pip install.
`,
parameters: {
packages: zod_1.z.string().describe("Space-separated package names (e.g. 'requests numpy')"),
upgrade: zBool(false).describe("Pass --upgrade flag"),
},
implementation: safe_impl("pip_install", async ({ packages, upgrade }) => {
if (!canPip())
return disabled("pip_install");
const pkgs = packages.trim().split(/\s+/).filter(Boolean);
if (!pkgs.length)
return "No packages specified.";
const args = ["-m", "pip", "install", ...(upgrade ? ["--upgrade"] : []), ...pkgs];
const r = await (0, sandbox_1.run)(await py(), args, { timeout: 180 });
return (r.stdout + r.stderr).trim();
}),
}),
(0, sdk_1.tool)({
name: "pip_list",
description: (0, sdk_1.text) `List installed Python packages. Set outdated=true to show only outdated packages.`,
parameters: {
outdated: zBool(false).describe("Show only outdated packages"),
},
implementation: safe_impl("pip_list", async ({ outdated }) => {
const args = ["-m", "pip", "list", "--format", "json", ...(outdated ? ["--outdated"] : [])];
const r = await (0, sandbox_1.run)(await py(), args, { timeout: 30 });
return r.success ? r.stdout.trim() : r.stderr;
}),
}),
(0, sdk_1.tool)({
name: "type_check_python",
description: (0, sdk_1.text) `Run mypy type-checker on a Python file or package.`,
parameters: {
path: zod_1.z.string().describe("Relative path to check"),
strict: zBool(false).describe("Enable --strict mode"),
},
implementation: safe_impl("type_check_python", async ({ path, strict }) => {
const hasMypy = (await (0, sandbox_1.run)("which", ["mypy"], { timeout: 3 })).success;
if (!hasMypy)
return "mypy not found. Install with: pip install mypy";
const p = (0, sandbox_1.safe)(ws(), path);
const r = await (0, sandbox_1.run)("mypy", [...(strict ? ["--strict"] : []), p], { cwd: ws(), timeout: 120 });
return (r.stdout + r.stderr).trim() || "No type errors found.";
}),
}),
// =========================================================================
// C++ DEV
// =========================================================================
(0, sdk_1.tool)({
name: "compile_cpp",
description: (0, sdk_1.text) `
Compile a C++ source file with the best available compiler (clang++ or g++).
Supports AddressSanitizer, UBSan, and custom compiler flags.
Enable in Settings → Allow C++ Compilation.
`,
parameters: {
path: zod_1.z.string().describe("Relative path to the .cpp source file"),
output: zod_1.z.string().default("").describe("Output binary name (default: source stem)"),
standard: zod_1.z.enum(["c++11", "c++14", "c++17", "c++20", "c++23"]).default("c++17").describe("C++ standard"),
flags: zod_1.z.string().default("-Wall -Wextra").describe("Extra compiler flags"),
sanitizers: zod_1.z.string().default("").describe("Comma-separated: address, undefined, thread"),
optimisation: zod_1.z.enum(["0", "1", "2", "3", "s", "fast"]).default("0").describe("Optimisation level"),
},
implementation: safe_impl("compile_cpp", async ({ path, output, standard, flags, sanitizers, optimisation }) => {
if (!canCpp())
return disabled("compile_cpp");
const cxx = await (0, sandbox_1.detectCxx)(preferClang());
if (!cxx)
return "No C++ compiler found. Install g++ or clang++.";
const src = (0, sandbox_1.safe)(ws(), path);
if (!await fileExists(src))
return `File not found: ${path}`;
const outName = output || (0, path_1.basename)(src, (0, path_1.extname)(src));
const outPath = (0, sandbox_1.safe)(ws(), outName);
const args = [src, `-std=${standard}`, `-O${optimisation}`, "-o", outPath];
if (flags.trim())
args.push(...flags.split(/\s+/));
const sanMap = {
address: "-fsanitize=address",
undefined: "-fsanitize=undefined",
thread: "-fsanitize=thread",
};
for (const s of sanitizers.split(",").map(s => s.trim()).filter(Boolean)) {
if (!sanMap[s])
return `Unknown sanitizer: '${s}'. Choose from: ${Object.keys(sanMap).join(", ")}`;
args.push(sanMap[s]);
}
const r = await (0, sandbox_1.run)(cxx, args, { cwd: ws(), timeout: 120 });
return json({ compiler: cxx, command: [cxx, ...args].join(" "), output_binary: r.success ? (0, path_1.relative)(ws(), outPath) : null, ...r });
}),
}),
(0, sdk_1.tool)({
name: "run_binary",
description: (0, sdk_1.text) `
Execute a compiled binary that lives inside the workspace.
Enable in Settings → Allow C++ Compilation.
`,
parameters: {
path: zod_1.z.string().describe("Relative path to the binary"),
args: zod_1.z.string().default("").describe("Space-separated arguments"),
stdin: zod_1.z.string().default("").describe("Text piped to stdin"),
},
implementation: safe_impl("run_binary", async ({ path, args, stdin }) => {
if (!canCpp())
return disabled("run_binary");
const p = (0, sandbox_1.safe)(ws(), path);
if (!await fileExists(p))
return `Binary not found: ${path}`;
const argv = args.trim() ? args.split(/\s+/) : [];
const r = await (0, sandbox_1.run)(p, argv, { cwd: ws(), stdin: stdin || undefined, timeout: timeout() });
return json({ returncode: r.code, stdout: r.stdout, stderr: r.stderr, success: r.success });
}),
}),
(0, sdk_1.tool)({
name: "compile_and_run",
description: (0, sdk_1.text) `
Compile C++ source code and immediately run it — ideal for quick snippets.
If is_file=false, source_or_path is treated as raw C++ source code.
Enable in Settings → Allow C++ Compilation.
`,
parameters: {
source_or_path: zod_1.z.string().describe("Raw C++ source code OR relative file path (see is_file)"),
stdin: zod_1.z.string().default("").describe("Input piped to the program"),
standard: zod_1.z.enum(["c++11", "c++14", "c++17", "c++20", "c++23"]).default("c++17"),
flags: zod_1.z.string().default("-Wall -Wextra").describe("Extra compile flags"),
sanitizers: zod_1.z.string().default("address,undefined").describe("Comma-separated sanitizers"),
is_file: zBool(false).describe("Treat source_or_path as a file path"),
},
implementation: safe_impl("compile_and_run", async ({ source_or_path, stdin, standard, flags, sanitizers, is_file }) => {
if (!canCpp())
return disabled("compile_and_run");
const cxx = await (0, sandbox_1.detectCxx)(preferClang());
if (!cxx)
return "No C++ compiler found.";
let srcPath;
let cleanup = false;
if (is_file) {
srcPath = (0, sandbox_1.safe)(ws(), source_or_path);
if (!await fileExists(srcPath))
return `File not found: ${source_or_path}`;
}
else {
srcPath = (0, path_1.join)((0, os_1.tmpdir)(), `lms_cpp_${Date.now()}.cpp`);
await (0, promises_1.writeFile)(srcPath, source_or_path, "utf-8");
cleanup = true;
}
const binPath = srcPath.replace(/\.cpp$/, "").replace(/\.cc$/, "") + "_bin";
try {
// Compile
const compileArgs = [srcPath, `-std=${standard}`, "-O0", "-o", binPath];
if (flags.trim())
compileArgs.push(...flags.split(/\s+/));
const sanMap = {
address: "-fsanitize=address",
undefined: "-fsanitize=undefined",
thread: "-fsanitize=thread",
};
for (const s of sanitizers.split(",").map(s => s.trim()).filter(Boolean)) {
if (sanMap[s])
compileArgs.push(sanMap[s]);
}
const comp = await (0, sandbox_1.run)(cxx, compileArgs, { timeout: 120 });
if (!comp.success) {
return json({ phase: "compile", returncode: comp.code, error: comp.stderr, success: false });
}
// Run
const execResult = await (0, sandbox_1.run)(binPath, [], {
stdin: stdin || undefined, timeout: timeout(),
});
return json({
compile: { returncode: comp.code, warnings: comp.stderr },
run: { returncode: execResult.code, stdout: execResult.stdout, stderr: execResult.stderr, success: execResult.success },
});
}
finally {
if (cleanup)
(0, promises_1.unlink)(srcPath).catch(() => { });
(0, promises_1.unlink)(binPath).catch(() => { });
}
}),
}),
(0, sdk_1.tool)({
name: "format_cpp",
description: (0, sdk_1.text) `
Format a C/C++ source file with clang-format.
style can be: LLVM, Google, Mozilla, WebKit, Microsoft, or "file" (uses .clang-format).
`,
parameters: {
path: zod_1.z.string().describe("Relative path to the source file"),
style: zod_1.z.string().default("LLVM").describe("clang-format style preset or 'file'"),
check_only: zBool(false).describe("Report only, do not modify"),
},
implementation: safe_impl("format_cpp", async ({ path, style, check_only }) => {
const hasClangFmt = (await (0, sandbox_1.run)("which", ["clang-format"], { timeout: 3 })).success;
if (!hasClangFmt)
return "clang-format not found. Install LLVM/Clang tools.";
const p = (0, sandbox_1.safe)(ws(), path);
if (!await fileExists(p))
return `Not found: ${path}`;
const args = [`-style=${style}`, ...(check_only ? ["--dry-run", "--Werror"] : ["-i"]), p];
const r = await (0, sandbox_1.run)("clang-format", args, { timeout: 30 });
if (check_only)
return r.success ? "Already formatted." : `Formatting needed:\n${r.stderr}`;
return r.success ? `Formatted ${(0, path_1.relative)(ws(), p)}` : `clang-format error:\n${r.stderr}`;
}),
}),
(0, sdk_1.tool)({
name: "analyze_cpp",
description: (0, sdk_1.text) `
Run clang-tidy static analysis on a C++ source file.
Returns diagnostics with file:line:col locations.
`,
parameters: {
path: zod_1.z.string().describe("Relative path to the source file"),
checks: zod_1.z.string().default("clang-analyzer-*,bugprone-*,modernize-*,performance-*").describe("Comma-separated check globs"),
fix: zBool(false).describe("Apply auto-fixes where available"),
},
implementation: safe_impl("analyze_cpp", async ({ path, checks, fix }) => {
const hasTidy = (await (0, sandbox_1.run)("which", ["clang-tidy"], { timeout: 3 })).success;
if (!hasTidy)
return "clang-tidy not found. Install LLVM/Clang tools.";
const p = (0, sandbox_1.safe)(ws(), path);
if (!await fileExists(p))
return `Not found: ${path}`;
const args = [`--checks=${checks}`, ...(fix ? ["--fix"] : []), p];
const r = await (0, sandbox_1.run)("clang-tidy", args, { cwd: ws(), timeout: 120 });
return (r.stdout + r.stderr).trim() || "No issues found by clang-tidy.";
}),
}),
(0, sdk_1.tool)({
name: "cmake_build",
description: (0, sdk_1.text) `
Configure and build a CMake project.
Steps: mkdir build_dir → cmake configure → cmake --build.
Enable in Settings → Allow C++ Compilation.
`,
parameters: {
source_dir: zod_1.z.string().default(".").describe("Directory containing CMakeLists.txt"),
build_dir: zod_1.z.string().default("build").describe("Out-of-source build directory"),
cmake_args: zod_1.z.string().default("").describe("Extra cmake args (e.g. '-DCMAKE_BUILD_TYPE=Release')"),
build_target: zod_1.z.string().default("").describe("Specific build target (empty = default)"),
clean: zBool(false).describe("Run cmake --build --target clean first"),
},
implementation: safe_impl("cmake_build", async ({ source_dir, build_dir, cmake_args, build_target, clean }) => {
if (!canCpp())
return disabled("cmake_build");
const hasCmake = (await (0, sandbox_1.run)("which", ["cmake"], { timeout: 3 })).success;
if (!hasCmake)
return "cmake not found. Install CMake.";
const src = (0, sandbox_1.safe)(ws(), source_dir);
const bld = (0, sandbox_1.safe)(ws(), build_dir);
await (0, promises_1.mkdir)(bld, { recursive: true });
// Configure
const cfgArgs = [src, "-B", bld, ...(cmake_args.trim() ? cmake_args.split(/\s+/) : [])];
const cfg = await (0, sandbox_1.run)("cmake", cfgArgs, { cwd: ws(), timeout: 120 });
if (!cfg.success)
return json({ phase: "configure", returncode: cfg.code, error: cfg.stderr, success: false });
// Clean
if (clean)
await (0, sandbox_1.run)("cmake", ["--build", bld, "--target", "clean"], { timeout: 60 });
// Build
const bldArgs = ["--build", bld, "--parallel", ...(build_target ? ["--target", build_target] : [])];
const bldResult = await (0, sandbox_1.run)("cmake", bldArgs, { timeout: 300 });
return json({
configure: { returncode: cfg.code, output: cfg.stdout },
build: { returncode: bldResult.code, stdout: bldResult.stdout, stderr: bldResult.stderr, success: bldResult.success },
});
}),
}),
(0, sdk_1.tool)({
name: "get_cpp_info",
description: (0, sdk_1.text) `Return version strings for available C++ compilers and tools.`,
parameters: {},
implementation: safe_impl("get_cpp_info", async () => {
const tools = ["clang++", "g++", "cmake", "make", "ninja", "clang-format", "clang-tidy", "ar"];
const info = {};
await Promise.all(tools.map(async (t) => {
const w = await (0, sandbox_1.run)("which", [t], { timeout: 3 });
if (!w.success) {
info[t] = "not found";
return;
}
const v = await (0, sandbox_1.run)(t, ["--version"], { timeout: 5 });
info[t] = (v.stdout + v.stderr).split("\n")[0].trim();
}));
return json(info);
}),
}),
// =========================================================================
// RESEARCH
// =========================================================================
(0, sdk_1.tool)({
name: "fetch_url",
description: (0, sdk_1.text) `
Fetch a web page and return its text content (HTML stripped by default).
Only public URLs (http/https) are supported — private/internal IPs are blocked.
`,
parameters: {
url: zod_1.z.string().describe("Full URL to fetch (must start with http:// or https://)"),
raw_html: zBool(false).describe("Return raw HTML instead of plain text"),
max_chars: zInt(50000).describe("Truncate at this many characters"),
},
implementation: safe_impl("fetch_url", async ({ url, raw_html, max_chars }) => {
if (!url.startsWith("http://") && !url.startsWith("https://")) {
return "Error: URL must start with http:// or https://";
}
// Block private/link-local IPs via a quick DNS+check approach
try {
const { hostname } = new URL(url);
// Rough private IP pattern check (before DNS resolution)
const privatePatterns = [
/^localhost$/i,
/^127\./,
/^10\./,
/^172\.(1[6-9]|2\d|3[01])\./,
/^192\.168\./,
/^169\.254\./,
/^::1$/,
/^fc[0-9a-f]{2}:/i,
/^fe[89ab][0-9a-f]:/i,
];
if (privatePatterns.some(r => r.test(hostname))) {
return `Request blocked: '${hostname}' is a private/internal address`;
}
}
catch {
return "Invalid URL";
}
try {
const res = await fetch(url, {
headers: { "User-Agent": "Mozilla/5.0 (LM Studio high-perf-tools/1.0)" },
signal: AbortSignal.timeout(20_000),
});
if (!res.ok)
return `HTTP ${res.status} ${res.statusText}`;
let body = await res.text();
if (!raw_html)
body = stripHtml(body);
if (body.length > max_chars)
body = body.slice(0, max_chars) + `\n\n[... truncated at ${max_chars} chars ...]`;
return body;
}
catch (e) {
return `Fetch failed: ${e.message}`;
}
}),
}),
(0, sdk_1.tool)({
name: "search_web",
description: (0, sdk_1.text) `
Search the web with DuckDuckGo and return a list of results with titles, URLs, and snippets.
`,
parameters: {
query: zod_1.z.string().describe("Search query"),
num_results: zod_1.z.coerce.number().int().min(1).max(20).default(5).describe("Number of results"),
},
implementation: safe_impl("search_web", async ({ query, num_results }) => {
try {
const results = await duckDuckScrape.search(query, { safeSearch: duckDuckScrape.SafeSearchType.MODERATE });
const items = (results.results ?? []).slice(0, num_results).map((r) => ({
title: r.title,
url: r.url,
snippet: r.description,
}));
return json(items);
}
catch (e) {
return `Search failed: ${e.message}`;
}
}),
}),
// =========================================================================
// GIT
// =========================================================================
(0, sdk_1.tool)({
name: "git_status",
description: (0, sdk_1.text) `Show working-tree status (staged, unstaged, untracked files).`,
parameters: {
path: zod_1.z.string().default(".").describe("Relative path of git repository"),
},
implementation: safe_impl("git_status", async ({ path }) => {
const p = (0, sandbox_1.safe)(ws(), path);
const r = await (0, sandbox_1.run)("git", ["status", "--short", "--branch"], { cwd: p, timeout: 15 });
return r.stdout || r.stderr || "Not a git repository";
}),
}),
(0, sdk_1.tool)({
name: "git_diff",
description: (0, sdk_1.text) `
Show diff of changes in the repository.
Set staged=true for the index diff. Optionally restrict to a specific file.
`,
parameters: {
path: zod_1.z.string().default(".").describe("Relative path of git repository"),
staged: zBool(false).describe("Show staged diff instead of working-tree"),
file_path: zod_1.z.string().default("").describe("Restrict diff to this file"),
},
implementation: safe_impl("git_diff", async ({ path, staged, file_path }) => {
const p = (0, sandbox_1.safe)(ws(), path);
const args = ["diff", ...(staged ? ["--cached"] : []), ...(file_path.trim() ? ["--", file_path] : [])];
const r = await (0, sandbox_1.run)("git", args, { cwd: p, timeout: 30 });
if (r.stdout)
return r.stdout;
return r.stderr || "(no diff)";
}),
}),
(0, sdk_1.tool)({
name: "git_log",
description: (0, sdk_1.text) `Show the git commit history.`,
parameters: {
path: zod_1.z.string().default(".").describe("Relative path of git repository"),
n: zod_1.z.coerce.number().int().min(1).max(100).default(15).describe("Number of commits"),
oneline: zBool(true).describe("Compact one-line format"),
author: zod_1.z.string().default("").describe("Filter by author name/email"),
since: zod_1.z.string().default("").describe("Show commits after this date (e.g. '2 weeks ago')"),
},
implementation: safe_impl("git_log", async ({ path, n, oneline, author, since }) => {
const p = (0, sandbox_1.safe)(ws(), path);
const args = ["log", `-${n}`,
...(oneline ? ["--oneline"] : []),
...(author ? [`--author=${author}`] : []),
...(since ? [`--since=${since}`] : []),
];
const r = await (0, sandbox_1.run)("git", args, { cwd: p, timeout: 15 });
return r.stdout || r.stderr;
}),
}),
(0, sdk_1.tool)({
name: "git_show",
description: (0, sdk_1.text) `Show details and diff of a specific commit.`,
parameters: {
path: zod_1.z.string().default(".").describe("Relative path of git repository"),
ref: zod_1.z.string().default("HEAD").describe("Commit hash, tag, or branch"),
},
implementation: safe_impl("git_show", async ({ path, ref }) => {
if (ref.startsWith("-"))
return "Error: ref must not start with '-'";
const p = (0, sandbox_1.safe)(ws(), path);
const r = await (0, sandbox_1.run)("git", ["show", ref], { cwd: p, timeout: 15 });
return r.stdout || r.stderr;
}),
}),
(0, sdk_1.tool)({
name: "git_branches",
description: (0, sdk_1.text) `List all local and remote branches.`,
parameters: {
path: zod_1.z.string().default(".").describe("Relative path of git repository"),
},
implementation: safe_impl("git_branches", async ({ path }) => {
const p = (0, sandbox_1.safe)(ws(), path);
const r = await (0, sandbox_1.run)("git", ["branch", "-a"], { cwd: p, timeout: 10 });
return r.stdout || r.stderr;
}),
}),
(0, sdk_1.tool)({
name: "git_stage",
description: (0, sdk_1.text) `
Stage files for the next commit (git add).
Enable Git Write in Settings.
`,
parameters: {
path: zod_1.z.string().default(".").describe("Relative path of git repository"),
files: zod_1.z.string().default(".").describe("Space-separated files/patterns to stage"),
},
implementation: safe_impl("git_stage", async ({ path, files }) => {
if (!canGitWrite())
return disabled("git_stage");
const p = (0, sandbox_1.safe)(ws(), path);
const fileList = files.trim().split(/\s+/).filter(Boolean);
const r = await (0, sandbox_1.run)("git", ["add", ...fileList], { cwd: p, timeout: 30 });
return r.stdout || r.stderr || "Files staged.";
}),
}),
(0, sdk_1.tool)({
name: "git_commit",
description: (0, sdk_1.text) `
Create a git commit with a message.
Optionally stage specified files first.
Enable Git Write in Settings.
`,
parameters: {
message: zod_1.z.string().describe("Commit message"),
path: zod_1.z.string().default(".").describe("Relative path of git repository"),
files: zod_1.z.string().default("").describe("Files to stage before committing (empty = use already-staged)"),
},
implementation: safe_impl("git_commit", async ({ message, path, files }) => {
if (!canGitWrite())
return disabled("git_commit");
if (!message.trim())
return "Error: commit message cannot be empty";
const p = (0, sandbox_1.safe)(ws(), path);
if (files.trim()) {
const stage = await (0, sandbox_1.run)("git", ["add", ...files.split(/\s+/).filter(Boolean)], { cwd: p, timeout: 15 });
if (!stage.success)
return `git add failed:\n${stage.stderr}`;
}
const r = await (0, sandbox_1.run)("git", ["commit", "-m", message], { cwd: p, timeout: 30 });
return r.stdout || r.stderr;
}),
}),
(0, sdk_1.tool)({
name: "git_init",
description: (0, sdk_1.text) `Initialise a new git repository.`,
parameters: {
path: zod_1.z.string().default(".").describe("Directory to initialise"),
},
implementation: safe_impl("git_init", async ({ path }) => {
const p = (0, sandbox_1.safe)(ws(), path);
await (0, promises_1.mkdir)(p, { recursive: true });
const r = await (0, sandbox_1.run)("git", ["init"], { cwd: p, timeout: 15 });
return r.stdout || r.stderr;
}),
}),
// =========================================================================
// AGENT ZERO — Memory · Sub-agents · Dynamic Tools
// =========================================================================
// ── Memory ────────────────────────────────────────────────────────────────
(0, sdk_1.tool)({
name: "memory_save",
description: (0, sdk_1.text) `
Save a fact, solution, or piece of knowledge to persistent memory.
Memories survive across conversations.
Use a short descriptive key and optional tags for easy retrieval later.
`,
parameters: {
key: zod_1.z.string().describe("Short title / identifier for this memory"),
content: zod_1.z.string().describe("Full content to remember"),
tags: zod_1.z.string().default("").describe("Comma-separated tags (e.g. 'python,bug-fix')"),
},
implementation: safe_impl("memory_save", async ({ key, content, tags }) => {
const tagList = tags.split(",").map(t => t.trim()).filter(Boolean);
return (0, memory_1.memorySave)(ws(), key, content, tagList);
}),
}),
(0, sdk_1.tool)({
name: "memory_recall",
description: (0, sdk_1.text) `
Search persistent memory for entries matching a query.
Returns the most relevant memories sorted by keyword relevance.
Use tags to narrow the search.
`,
parameters: {
query: zod_1.z.string().describe("What to search for (keywords)"),
limit: zInt(5).describe("Maximum results to return"),
tags: zod_1.z.string().default("").describe("Comma-separated tags to filter by"),
},
implementation: safe_impl("memory_recall", async ({ query, limit, tags }) => {
const tagList = tags.split(",").map(t => t.trim()).filter(Boolean);
return (0, memory_1.memoryRecall)(ws(), query, limit, tagList);
}),
}),
(0, sdk_1.tool)({
name: "memory_list",
description: (0, sdk_1.text) `List all saved memories (keys, tags, dates). Use tags to filter.`,
parameters: {
tags: zod_1.z.string().default("").describe("Comma-separated tags to filter by"),
},
implementation: safe_impl("memory_list", async ({ tags }) => {
const tagList = tags.split(",").map(t => t.trim()).filter(Boolean);
return (0, memory_1.memoryList)(ws(), tagList);
}),
}),
(0, sdk_1.tool)({
name: "memory_delete",
description: (0, sdk_1.text) `Delete a memory entry by its id or exact key.`,
parameters: {
id_or_key: zod_1.z.string().describe("Memory id or exact key to delete"),
},
implementation: safe_impl("memory_delete", async ({ id_or_key }) => {
return (0, memory_1.memoryDelete)(ws(), id_or_key);
}),
}),
// ── Sub-agents ────────────────────────────────────────────────────────────
(0, sdk_1.tool)({
name: "list_models",
description: (0, sdk_1.text) `
List all models currently loaded in LM Studio.
Use this before spawn_agent to see what models are available.
On low-RAM devices only one model will typically be shown.
`,
parameters: {},
implementation: safe_impl("list_models", async () => {
const endpoint = cfg.get("lmStudioEndpoint");
const models = await (0, subagent_1.listLoadedModels)(endpoint);
if (!models.length)
return "No models currently loaded in LM Studio.";
return json({
loaded_models: models,
note: models.length === 1
? "Only one model loaded. spawn_agent will reuse it (no extra RAM required)."
: `${models.length} models loaded. spawn_agent can use a dedicated sub-agent model.`,
});
}),
}),
(0, sdk_1.tool)({
name: "spawn_agent",
description: (0, sdk_1.text) `
Spawn a sub-agent to handle a specific task autonomously.
RAM behaviour:
• If only one model is loaded (low-RAM device) → the same model is reused
with a different system prompt. No extra RAM consumed.
• If a Sub-Agent Model ID is configured in settings AND that model is loaded
→ it is used as the dedicated sub-agent.
The sub-agent has access to: read_file, write_file, list_directory,
run_python_code, run_command, memory_save, memory_recall.
Set allow_tools=false for a simple one-shot generation (faster, less RAM).
`,
parameters: {
task: zod_1.z.string().describe("The task to delegate to the sub-agent"),
context: zod_1.z.string().default("").describe("Optional background context to provide"),
system_role: zod_1.z.string().default("").describe("Custom system prompt for the sub-agent (blank = sensible default)"),
allow_tools: zBool(true).describe("Whether the sub-agent can use tools (set false for pure generation tasks)"),
},
implementation: safe_impl("spawn_agent", async ({ task, context, system_role, allow_tools }) => {
const toolCtx = {
workspace: ws(),
pythonBin: await py(),
timeout: timeout(),
};
return (0, subagent_1.spawnAgent)({
endpoint: cfg.get("lmStudioEndpoint"),
preferredModelId: cfg.get("subAgentModelId"),
maxIterations: cfg.get("subAgentMaxIterations"),
systemPrompt: system_role,
task,
context,
toolCtx,
allowTools: allow_tools,
});
}),
}),
// ── Dynamic tools ─────────────────────────────────────────────────────────
(0, sdk_1.tool)({
name: "create_tool",
description: (0, sdk_1.text) `
Create a new reusable Python tool and save it to the workspace.
The tool persists across conversations and can be called by name with call_tool.
The python_code body receives an 'args' dict (from JSON stdin) and should
return a string or JSON-serialisable value.
Example python_code:
result = args.get("x", 0) + args.get("y", 0)
return str(result)
`,
parameters: {
name: zod_1.z.string().describe("Tool name (alphanumeric + underscores)"),
description: zod_1.z.string().describe("What this tool does"),
args_schema: zod_1.z.string().default("").describe("Description of expected JSON args (free text)"),
python_code: zod_1.z.string().describe("Python function body — receives 'args: dict', returns a value"),
},
implementation: safe_impl("create_tool", async ({ name, description, args_schema, python_code }) => {
return (0, dynamicTools_1.createTool)(ws(), name, description, args_schema, python_code);
}),
}),
(0, sdk_1.tool)({
name: "call_tool",
description: (0, sdk_1.text) `
Call a previously created dynamic tool by name.
Pass arguments as a JSON string (e.g. '{"x": 1, "y": 2}').
`,
parameters: {
name: zod_1.z.string().describe("Tool name (as given to create_tool)"),
args_json: zod_1.z.string().default("{}").describe("JSON object of arguments"),
},
implementation: safe_impl("call_tool", async ({ name, args_json }) => {
return (0, dynamicTools_1.callTool)(ws(), name, args_json, await py(), timeout());
}),
}),
(0, sdk_1.tool)({
name: "list_custom_tools",
description: (0, sdk_1.text) `List all dynamically created tools with their descriptions and argument schemas.`,
parameters: {},
implementation: safe_impl("list_custom_tools", async () => {
return (0, dynamicTools_1.listTools)(ws());
}),
}),
(0, sdk_1.tool)({
name: "delete_tool",
description: (0, sdk_1.text) `Delete a dynamically created tool by name.`,
parameters: {
name: zod_1.z.string().describe("Tool name to delete"),
},
implementation: safe_impl("delete_tool", async ({ name }) => {
return (0, dynamicTools_1.deleteTool)(ws(), name);
}),
}),
];
return tools;
};
exports.toolsProvider = toolsProvider;