87:T33a90,// --- Model Activation Helper --- async function ensureModelLoaded(client: LMStudioClient, modelKey?: string) { try { if (modelKey) { return await client.llm.model(modelKey); } return await client.llm.model(); } catch (e) { console.warn(`[Model Activation] Failed to load model: ${e instanceof Error ? e.message : String(e)}`); throw e; } } async function listLoadedModels(client: LMStudioClient) { try { const llmModels = await client.llm.listLoaded(); const embeddingModels = await client.embedding.listLoaded(); return { llm: llmModels, embedding: embeddingModels }; } catch (e) { console.warn(`[Model Activation] Failed to list loaded models: ${e instanceof Error ? e.message : String(e)}`); return { llm: [], embedding: [] }; } } // --- Embedding Model Auto-Loading --- async function ensureEmbeddingModelLoaded(client: LMStudioClient, modelId: string): Promise { try { // Try to get the model; LM Studio will auto-load it if not already loaded return await client.embedding.model(modelId); } catch (e) { console.warn(`[Embedding] Failed to load embedding model '${modelId}': ${e instanceof Error ? e.message : String(e)}`); throw e; } } // --- Embedder Autoloading and Caching --- const EMBEDDING_CACHE = new Map(); const EMBEDDING_CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes function getEmbeddingCacheKey(text: string): string { return `embed:${text.substring(0, 1000)}`; // Limit key length } function getCachedEmbedding(text: string): number[] | null { const key = getEmbeddingCacheKey(text); const entry = EMBEDDING_CACHE.get(key); if (!entry) return null; if (Date.now() - entry.timestamp > EMBEDDING_CACHE_TTL_MS) { EMBEDDING_CACHE.delete(key); return null; } return entry.embedding; } function setCachedEmbedding(text: string, embedding: number[]): void { const key = getEmbeddingCacheKey(text); EMBEDDING_CACHE.set(key, { embedding, timestamp: Date.now() }); } // Defensive embedding model ID resolution function resolveEmbeddingModelName(configuredName: string): string { // Try config value first if (configuredName) return configuredName; // Try common aliases const aliases = ["nomic-ai/nomic-embed-text-v1.5", "all-MiniLM-L6-v2", "nomic-embed-text"]; for (const alias of aliases) { if (alias) return alias; } // Fallback to first available return "nomic-ai/nomic-embed-text-v1.5"; } import { text, tool, type Tool, type ToolsProvider, type LMStudioClient } from "@lmstudio/sdk"; import { spawn } from "child_process"; import { rm, writeFile, readdir, readFile, stat, mkdir, rename, copyFile, appendFile } from "fs/promises"; import * as os from "os"; import { join, resolve, dirname, isAbsolute, relative } from "path"; import { z } from "zod"; import { pluginConfigSchematics } from "./config"; import { findLMStudioHome } from "./findLMStudioHome"; import { getPersistedState, savePersistedState, ensureWorkspaceExists, changeWorkingDirectory, formatCwdStatus, incrementMessageCount, shouldCompressContext, ensureMemoryFileExists, syncMemoryState, getRuntimeWorkingDirectory } from "./stateManager"; import { setWorkspacePaths } from "./stateRegistry"; import { validatePath as validatePathSecure, validatePathLegacy, PathSecurityError, rejectAbsolutePath, setUnrestrictedMode, isUnrestrictedMode } from "./pathSecurity"; import { executeBrowserActions } from "./browserActions"; import { rankFuzzyMatches } from "./fuzzySearch"; import { extractHandoffMessage } from "./handoffMessage"; import { parseSubAgentResponseMessage, type ParsedToolCall } from "./subAgentToolCallParser"; import { validateToolCall } from "./toolCallValidator"; import { backgroundCommands, generateId, BackgroundCommand } from "./backgroundCommands"; import { createHealthTools } from "./pluginHealth"; import * as neo4jTools from "./tools/neo4jTools"; import * as feedTools from "./tools/feedTools"; import * as imageTools from "./tools/imageTools"; import * as mediaTools from "./tools/mediaTools"; import * as archiveTools from "./tools/archiveTools"; import * as dataTools from "./tools/dataTools"; import * as automationTools from "./tools/automationTools"; import * as timeTools from "./tools/timeTools"; import * as utilityTools from "./tools/utilityTools"; import * as agentTools from "./tools/agentTools"; import * as memoryTools from "./tools/memoryTools"; import * as workflowTools from "./tools/workflowTools"; import * as parallelTools from "./tools/parallelTools"; import * as skillTools from "./tools/skillTools"; import * as contextManager from "./tools/contextManager"; import * as evalTools from "./tools/evalTools"; import * as gitWorkflowTools from "./tools/gitWorkflowTools"; import * as knowledgeBase from "./tools/knowledgeBase"; import * as pluginBridge from "./tools/pluginBridge"; import * as cacheTools from "./tools/cacheTools"; import * as configTools from "./tools/configTools"; import * as documentParsers from "./tools/documentParsers"; import type { Browser, Page } from "puppeteer"; // ── Retry helper for transient failures ───────────────────────────────── // Wraps a tool implementation so a transient error (momentary connection // blip, locked file, etc.) is retried with exponential backoff before // surfacing a failure. Successful results pass through unchanged. async function withRetry( fn: () => Promise, opts: { retries?: number; baseMs?: number } = {}, ): Promise { const retries = opts.retries ?? 2; const baseMs = opts.baseMs ?? 150; let lastErr: unknown; for (let attempt = 0; attempt <= retries; attempt++) { try { return await fn(); } catch (err) { lastErr = err; if (attempt === retries) break; await new Promise((r) => setTimeout(r, baseMs * 2 ** attempt)); } } throw lastErr; } // --- Tool Enable/Disable Helper --- function isToolEnabled(toolName: string, enabledToolsConfig: string[]): boolean { // If no tools are explicitly configured, enable all (backward compatibility) if (!enabledToolsConfig || enabledToolsConfig.length === 0) return true; return enabledToolsConfig.includes(toolName); } // --- Security Helper --- // Prefer validatePathSecure(workspaceRoot, cwd, path) for new code. // This two-arg form stays compatible with existing call sites and routes // through pathSecurity (null-byte rejection, drive guards, etc.). function validatePath(baseDir: string, requestedPath: string): string { return validatePathLegacy(baseDir, requestedPath); } function extractLikelyFilePath(text: string): string | null { const isPlausiblePath = (value: string): boolean => { const candidate = value.trim(); if (!candidate) return false; if (/[,\r\n]/.test(candidate)) return false; if (candidate.includes("=") && !candidate.includes("\\") && !candidate.includes("/")) return false; if (/[<>|*?]/.test(candidate)) return false; const extensionMatch = candidate.match(/\.([A-Za-z0-9_-]{1,15})$/); if (!extensionMatch) return false; const extension = extensionMatch[1]; if (!/[A-Za-z]/.test(extension)) return false; // reject ".0" and similar numeric pseudo-extensions return true; }; const patterns = [ /['"]([A-Za-z]:\\[^'"\r\n]+)['"]/, /\b([A-Za-z]:\\[^\s'"]+(?:\.[A-Za-z0-9_-]+)?)\b/, /['"]((?:\.{0,2}[\\/])?[^'"\r\n]+\.[A-Za-z0-9_-]+)['"]/, ]; for (const pattern of patterns) { const match = text.match(pattern); if (!match?.[1]) continue; const candidate = match[1].replace(/[),.;]+$/, "").trim(); if (!isPlausiblePath(candidate)) continue; return candidate; } return null; } const TOOL_PERMISSION_HINTS: Record = { execute_command: "Plugins → Timbers Toolbox → enable \"Allow Shell Commands\" (execution.allowShellCommandExecution)", run_background_command: "Plugins → Timbers Toolbox → enable \"Allow Shell Commands\"", run_test_command: "Plugins → Timbers Toolbox → enable \"Allow Shell Commands\"", run_in_terminal: "Plugins → Timbers Toolbox → enable \"Allow Terminal Execution\"", run_python: "Plugins → Timbers Toolbox → enable \"Allow Python Execution\"", run_javascript: "Plugins → Timbers Toolbox → enable \"Allow JavaScript Execution\"", browser_session_open: "Plugins → Timbers Toolbox → enable \"Allow Browser Control\"", browser_session_control: "Plugins → Timbers Toolbox → enable \"Allow Browser Control\"", browser_session_close: "Plugins → Timbers Toolbox → enable \"Allow Browser Control\"", browser_open_page: "Plugins → Timbers Toolbox → enable \"Allow Browser Control\"", }; const createSafeToolImplementation = ( originalImplementation: (params: TParameters) => Promise, isEnabled: boolean, toolName: string, ) => async (params: TParameters): Promise => { if (!isEnabled) { const hint = TOOL_PERMISSION_HINTS[toolName] || `Plugins → Timbers Toolbox → enable the permission for '${toolName}' (or \"Allow All Code Execution\").`; throw new Error(`Tool '${toolName}' is disabled. ${hint}`); } return originalImplementation(params); }; // Helper function for cosine similarity function cosineSimilarity(vecA: number[], vecB: number[]): number { const dotProduct = vecA.reduce((acc, val, i) => acc + val * vecB[i], 0); const magA = Math.sqrt(vecA.reduce((acc, val) => acc + val * val, 0)); const magB = Math.sqrt(vecB.reduce((acc, val) => acc + val * val, 0)); if (magA === 0 || magB === 0) { return 0; } return dotProduct / (magA * magB); } // Main RAG-on-text helper async function performRagOnText(text: string, query: string, client: LMStudioClient, embeddingModelName: string) { // 1. Load (or auto-load) the configured embedding model const embeddingModel = await ensureEmbeddingModelLoaded(client, embeddingModelName); // 2. Chunk the text (simple paragraph-based chunking) const chunks = text.split(/\n\s*\n/).filter(chunk => chunk.trim().length > 20); if (chunks.length === 0) { return [{ chunk: text.substring(0, 4000), score: 1 }]; } // 3. Embed query and chunks const [queryEmbedding] = await embeddingModel.embed([query]); const chunkEmbeddings = await embeddingModel.embed(chunks); // 4. Calculate similarity const similarities = chunkEmbeddings.map((chunkEmb: { embedding: number[] }, i: number) => ({ chunk: chunks[i], score: cosineSimilarity(queryEmbedding.embedding, chunkEmb.embedding), })); // 5. Sort by score and return top results similarities.sort((a: { score: number }, b: { score: number }) => b.score - a.score); return similarities.slice(0, 5); // Return top 5 } function getDenoPath() { const lmstudioHome = findLMStudioHome(); const utilPath = join(lmstudioHome, ".internal", "utils"); const denoPath = join(utilPath, process.platform === "win32" ? "deno.exe" : "deno"); return denoPath; } let isWorkspaceInitialized = false; // --- Tool Result Cache (Fix #5: Avoid re-executing identical queries) --- const TOOL_RESULT_CACHE = new Map(); const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes function getCachedToolResult(key: string): any | null { const entry = TOOL_RESULT_CACHE.get(key); if (!entry) return null; if (Date.now() - entry.timestamp > CACHE_TTL_MS) { TOOL_RESULT_CACHE.delete(key); return null; } return entry.result; } function setCachedToolResult(key: string, result: any): void { // Evict oldest entries if cache gets too large (LRU-ish) if (TOOL_RESULT_CACHE.size > 100) { const firstKey = TOOL_RESULT_CACHE.keys().next().value; if (firstKey) TOOL_RESULT_CACHE.delete(firstKey); } TOOL_RESULT_CACHE.set(key, { result, timestamp: Date.now() }); } function generateToolCacheKey(toolName: string, args: any): string { return `${toolName}:${JSON.stringify(args)}`; } // ───────────────────────────────────────────────────────────── // Shared Sub-Agent Delegation Engine // Used by both consult_secondary_agent and agent_run_with_retry // ───────────────────────────────────────────────────────────── interface SubAgentResult { response: string; generated_files: string[]; handoff_message: string; } const DEFAULT_SUB_AGENT_ENDPOINT = "http://localhost:1234/v1"; function resolveSubAgentEndpoint(configuredEndpoint: unknown): string { const endpoint = typeof configuredEndpoint === "string" ? configuredEndpoint.trim() : ""; return (endpoint || DEFAULT_SUB_AGENT_ENDPOINT).replace(/\/+$/, ""); } function isLocalSubAgentEndpoint(endpoint: string): boolean { try { const hostname = new URL(endpoint).hostname.toLowerCase(); return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1"; } catch { return false; } } async function resolveRemoteModelId(endpoint: string, signal: AbortSignal): Promise { const response = await fetch(`${endpoint}/models`, { signal }); if (!response.ok) { throw new Error(`Remote sub-agent model discovery failed (${response.status} ${response.statusText})`); } const payload = await response.json() as { data?: Array<{ id?: unknown }> }; const modelId = payload.data?.find(model => typeof model.id === "string" && model.id.trim())?.id; if (typeof modelId !== "string") { throw new Error(`Remote sub-agent endpoint "${endpoint}" returned no models`); } return modelId; } async function respondWithRemoteSubAgent( endpoint: string, modelId: string | undefined, messages: Array<{ role: string; content: string }>, signal: AbortSignal ): Promise { const resolvedModelId = modelId || await resolveRemoteModelId(endpoint, signal); const response = await fetch(`${endpoint}/chat/completions`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ model: resolvedModelId, messages, temperature: 0.7, }), signal, }); if (!response.ok) { const details = await response.text(); throw new Error(`Remote sub-agent request failed (${response.status} ${response.statusText}): ${details.substring(0, 500)}`); } const payload = await response.json() as { choices?: Array<{ message?: unknown }> }; const message = payload.choices?.[0]?.message; if (!message) { throw new Error("Remote sub-agent response did not contain a chat message"); } return message; } export async function runSubAgentLoop( client: LMStudioClient, pluginConfig: any, role: string, taskPrompt: string, contextData: string, loopLimit: number = 8, forceTools: boolean = false, currentWorkingDirectory: string, allowTools: boolean = false ): Promise { const unrestricted = isUnrestrictedMode() || pluginConfig.get?.("general.unrestrictedMode") === true; const enableSecondary = unrestricted ? true : pluginConfig.get("agent.enableSecondaryAgent"); if (!enableSecondary) { return { response: "Secondary agent is disabled in settings.", generated_files: [], handoff_message: "" }; } const endpoint = resolveSubAgentEndpoint(pluginConfig.get("agent.secondaryAgentEndpoint")); let modelId: string | undefined = pluginConfig.get("agent.secondaryModelId"); const useMainModel = pluginConfig.get("agent.useMainModelForSubAgent"); if (useMainModel) { modelId = undefined; } // The injected SDK client is tied to LM Studio's default local server. Any // explicitly configured endpoint, including a different localhost port, // must use the endpoint directly. const useSDK = endpoint === DEFAULT_SUB_AGENT_ENDPOINT && isLocalSubAgentEndpoint(endpoint); const subAgentProfilesStr = pluginConfig.get("agent.subAgentProfiles"); const debugMode = pluginConfig.get("debug.enableDebugMode"); const subAgentDebugLogging = pluginConfig.get("debug.enableSubAgentDebugLogging"); const autoSave = pluginConfig.get("debug.subAgentAutoSave"); const showFullCode = pluginConfig.get("debug.showFullCodeOutput"); let allowFileSystem = pluginConfig.get("agent.subAgentAllowFileSystem"); let allowWeb = pluginConfig.get("agent.subAgentAllowWeb"); let allowCode = pluginConfig.get("agent.subAgentAllowCode"); let allowSubAgentBrowserControl = pluginConfig.get("agent.subAgentAllowBrowserControl"); let allowBrowserControl = pluginConfig.get("execution.allowBrowserControl"); if (unrestricted) { allowFileSystem = true; allowWeb = true; allowCode = true; allowSubAgentBrowserControl = true; allowBrowserControl = true; } let currentSystemPrompt = "You are a helpful assistant."; // Load Instructions // Prefer packaged plugin instructions, then workspace copies. const subAgentInstructionCandidates = [ join(__dirname, "..", "instructions", "SUB_AGENT_INSTRUCTIONS.md"), join(__dirname, "instructions", "SUB_AGENT_INSTRUCTIONS.md"), join(dirname(__dirname), "instructions", "SUB_AGENT_INSTRUCTIONS.md"), join(currentWorkingDirectory, "instructions", "SUB_AGENT_INSTRUCTIONS.md"), join(currentWorkingDirectory, "SUB_AGENT_INSTRUCTIONS.md"), ]; for (const instructionsPath of subAgentInstructionCandidates) { try { const instructions = await readFile(instructionsPath, "utf-8"); if (instructions.trim()) { currentSystemPrompt = instructions; break; } } catch (e) { /* try next */ } } currentSystemPrompt += `\n\n## Current Workspace\nYour current working directory is: ${currentWorkingDirectory}\nAlways assume relative paths are from this directory.`; try { const profiles = JSON.parse(subAgentProfilesStr); if (profiles[role]) { currentSystemPrompt += `\n\n## Your Persona\n${profiles[role]}`; } else if (role === "reviewer") { currentSystemPrompt += `\n\n## Your Persona\nYou are a Senior Code Reviewer. Your job is to analyze code, find bugs, security issues, or logic errors, and FIX them.\n\nIMPORTANT: To fix a file, you MUST use the 'save_file' tool with the complete, corrected content. DO NOT use 'container.exec' or diff formats. Just overwrite the file with the fixed version using 'save_file'.`; } } catch (jsonErr) { } let toolsReminder = ""; const toolsEnabled = allowTools || forceTools; if (toolsEnabled) { const allowedTools: string[] = []; if (allowFileSystem) allowedTools.push("read_file", "list_directory", "save_file", "replace_text_in_file", "delete_files_by_pattern", "rag_local_files", "fuzzy_find_local_files", "search_file_content"); if (allowWeb) allowedTools.push("wikipedia_search", "web_search", "duckduckgo_search", "fetch_web_content", "rag_web_content"); if (allowWeb && allowSubAgentBrowserControl && allowBrowserControl) allowedTools.push("browser_session_open", "browser_session_control", "browser_session_close"); if (allowCode) allowedTools.push("run_python", "run_javascript"); if (allowedTools.length > 0) { const toolsList = allowedTools.join(", "); currentSystemPrompt += `\n\n## Allowed Tools\nYou have access to the following tools via JSON output: ${toolsList}.\nRefer to the "Tool Usage" section above for the JSON format.\n`; toolsReminder = `\n\n[SYSTEM REMINDER: You have access to tools: ${toolsList}. If you need information you don't have, USE A TOOL. Do not refuse. Format tool calls exactly as: {"tool": "tool_name", "args": {"arg_name": "value"}}]`; } } currentSystemPrompt += `\n\n## Task Completion\nIf you have successfully completed your task, output 'TASK_COMPLETED'.\nIf you cannot complete the task, output 'TASK_FAILED' to abort early.`; const msgList: Array<{ role: string; content: string }> = [ { role: "system", content: currentSystemPrompt }, { role: "user", content: `Task: ${taskPrompt}\n\nContext: ${contextData}${toolsReminder}` } ]; let loops = 0; let noToolCallCount = 0; let executedToolCallCount = 0; let finalContent = ""; let lastMeaningfulResponse = ""; const filesModified: string[] = []; let handoffMessage = ""; const maxSubAgentToolOutputChars = 30000; const startTime = Date.now(); const timeLimitMs = (pluginConfig.get("agent.subAgentTimeLimit") ?? 600) * 1000; while (loops < loopLimit) { if (Date.now() - startTime > timeLimitMs) { return { response: `Sub-agent task timed out after ${(timeLimitMs / 1000)} seconds.`, generated_files: filesModified, handoff_message: handoffMessage }; } try { const controller = new AbortController(); const remainingTime = Math.max(5000, timeLimitMs - (Date.now() - startTime)); const timeoutId = setTimeout(() => controller.abort(), remainingTime); let chatResponse: any; try { console.log(`[Sub-Agent] Calling model.respond()...`); if (useSDK) { const model = modelId ? await client.llm.model(modelId) : await client.llm.model(); chatResponse = await model.respond(msgList as any, { temperature: 0.7, signal: controller.signal }); } else { chatResponse = await respondWithRemoteSubAgent(endpoint, modelId, msgList, controller.signal); } console.log(`[Sub-Agent] model.respond() returned: ${typeof chatResponse}`); } catch (respondErr: any) { console.error(`[Sub-Agent] model.respond() error: ${respondErr.message}`); console.error(`[Sub-Agent] Stack: ${respondErr.stack}`); throw respondErr; } finally { clearTimeout(timeoutId); } // chatResponse is the message object from the SDK (e.g., { content, reasoning_content, ... }) const message = chatResponse; const parsedMessage = parseSubAgentResponseMessage(message); const content = parsedMessage.content; let toolCall: ParsedToolCall | null = parsedMessage.toolCall; if (subAgentDebugLogging) { const rawContent = (typeof message === "string" ? message : JSON.stringify(message)) ?? ""; console.log(`[Sub-Agent] RAW content received: ${rawContent.substring(0, 1000)}...`); } finalContent = content; if (!toolsEnabled) { const extracted = extractHandoffMessage(content); return { response: extracted.response, generated_files: filesModified, handoff_message: extracted.handoffMessage || '' }; } const trimmed = content.trim(); if (!toolCall && trimmed) { const refusalKeywords = [ "i cannot browse", "i don't have access", "i can't access", "unable to browse", "real-time news", "no internet access", "as an ai", "i do not have the ability", "cannot access the internet" ]; if (refusalKeywords.some(kw => trimmed.toLowerCase().includes(kw))) { msgList.push({ role: "assistant", content: content }); msgList.push({ role: "system", content: "SYSTEM ERROR: You HAVE access to tools. USE THEM." }); loops++; continue; } } if (toolCall && toolCall.tool) { noToolCallCount = 0; executedToolCallCount++; msgList.push({ role: "assistant", content: content }); let toolResult = ""; const args = toolCall.args || {}; const toolValidationError = validateToolCall(toolCall.tool, args); if (toolValidationError) { toolResult = `TOOL_VALIDATION_ERROR: ${toolValidationError}`; } else { if (allowFileSystem) { if (toolCall.tool === "read_file" && toolCall.args?.file_name) { const fpath = validatePath(currentWorkingDirectory, toolCall.args.file_name); const readContent = await readFile(fpath, "utf-8"); toolResult = readContent.length > maxSubAgentToolOutputChars ? `${readContent.substring(0, maxSubAgentToolOutputChars)}\n... (truncated ${readContent.length - maxSubAgentToolOutputChars} chars)` : readContent; } else if (toolCall.tool === "list_directory") { const files = await readdir(currentWorkingDirectory); toolResult = JSON.stringify(files); } else if (toolCall.tool === "save_file") { if (Array.isArray(toolCall.args?.files)) { const savedList: string[] = []; for (const fileObj of toolCall.args.files) { const fName = fileObj.file_name || fileObj.name || fileObj.path; const fContent = fileObj.content || fileObj.data; if (fName && fContent) { try { const fpath = validatePath(currentWorkingDirectory, fName); await mkdir(dirname(fpath), { recursive: true }); await writeFile(fpath, fContent, "utf-8"); filesModified.push(fName); savedList.push(fName); } catch (err: any) { /* continue */ } } } toolResult = savedList.length > 0 ? `Success: Saved ${savedList.length} files: ${savedList.join(", ")}` : "Error: No valid files found in batch."; } else { const fileName = toolCall.args?.file_name || toolCall.args?.name || toolCall.args?.path; const content2 = toolCall.args?.content || toolCall.args?.data; if (fileName && content2) { const fpath = validatePath(currentWorkingDirectory, fileName); await mkdir(dirname(fpath), { recursive: true }); await writeFile(fpath, content2, "utf-8"); toolResult = `Success: File saved to ${fpath}`; filesModified.push(fileName); } else { toolResult = "Error: Missing 'file_name' or 'content' arguments."; } } } else if (toolCall.tool === "replace_text_in_file" && toolCall.args?.file_name && toolCall.args?.old_string && toolCall.args?.new_string) { const fpath = validatePath(currentWorkingDirectory, toolCall.args.file_name); const fileContent = await readFile(fpath, "utf-8"); if (!fileContent.includes(toolCall.args.old_string)) { toolResult = "Error: 'old_string' not found exactly."; } else { const count = fileContent.split(toolCall.args.old_string).length - 1; if (count > 1) { toolResult = `Error: Found ${count} occurrences. Be more specific.`; } else { await writeFile(fpath, fileContent.replace(toolCall.args.old_string, toolCall.args.new_string), "utf-8"); toolResult = "Success: Text replaced."; filesModified.push(toolCall.args.file_name); } } } else if (toolCall.tool === "delete_files_by_pattern" && toolCall.args?.pattern) { const regex = new RegExp(toolCall.args.pattern); const files = await readdir(currentWorkingDirectory); const deleted: string[] = []; for (const file of files) { if (regex.test(file)) { const fpath = validatePath(currentWorkingDirectory, file); await rm(fpath, { force: true }); deleted.push(file); } } toolResult = `Deleted ${deleted.length} files: ${deleted.join(", ")}`; } else if (toolCall.tool === "fuzzy_find_local_files" && toolCall.args?.query) { const targetDir = validatePath(currentWorkingDirectory, toolCall.args?.path || "."); const entries = await readdir(targetDir, { recursive: true, withFileTypes: true }); const fileNames = entries.filter(entry => entry.isFile()).map(entry => relative(targetDir, join(entry.path, entry.name)).replace(/\\/g, "/")); const ranked = rankFuzzyMatches(toolCall.args.query, fileNames, 5); toolResult = JSON.stringify(ranked.map(item => ({ path: item.value, score: item.score }))); } } if (allowWeb && !toolResult) { if (toolCall.tool === "wikipedia_search") toolResult = "Wiki Search (mocked)"; else if (toolCall.tool === "web_search" || toolCall.tool === "duckduckgo_search") { const { search, SafeSearchType } = await import("duck-duck-scrape"); const r = await search(toolCall.args.query, { safeSearch: SafeSearchType.OFF }); toolResult = JSON.stringify(r.results.slice(0, 3)); } } if (allowCode && !toolResult) { if (toolCall.tool === "run_python") { const scriptFileName = `temp_script_${Date.now()}.py`; const scriptFilePath = join(currentWorkingDirectory, scriptFileName); try { await writeFile(scriptFilePath, toolCall.args.python, "utf-8"); const childProcess = spawn("python", [scriptFilePath], { cwd: currentWorkingDirectory, timeout: 5000, stdio: "pipe", }); let pyStdout = ""; let pyStderr = ""; childProcess.stdout.setEncoding("utf-8"); childProcess.stderr.setEncoding("utf-8"); childProcess.stdout.on("data", (d: string) => { pyStdout += d; }); childProcess.stderr.on("data", (d: string) => { pyStderr += d; }); await new Promise((resolve, reject) => { childProcess.on("close", (code) => { if (code === 0) resolve(); else reject(new Error(`Process exited with code ${code}. Stderr: ${pyStderr}`)); }); childProcess.on("error", reject); }); toolResult = pyStderr ? `Error: ${pyStderr}` : pyStdout; } catch (pyErr: any) { toolResult = `Python error: ${pyErr.message}`; } finally { await rm(scriptFilePath, { force: true }).catch(() => {}); } } } if (!toolResult) toolResult = "Error: Tool not found/allowed."; } msgList.push({ role: "user", content: `Tool Output: ${toolResult}` }); loops++; } else { noToolCallCount++; const planningLikeText = /(?:\\bI(?:'ll| will)\\b|\\blet me\\b|\\bnext\\b|\\bfirst\\b|\bstep\s*\d+\b)/i.test(trimmed); const hasToolCallIntent = /\{.*"tool".*}/.test(trimmed); const isCompletionMarker = /TASK_COMPLETED|TASK_FAILED/.test(trimmed); const isOnlyCompletionMarker = trimmed === "TASK_COMPLETED" || trimmed === "TASK_FAILED"; const shouldTreatAsFinalResponse = trimmed.length >= 120 && !planningLikeText && !hasToolCallIntent; // Track the last meaningful response (non-empty, not just a marker, non-planning) if (!isOnlyCompletionMarker && !planningLikeText && !hasToolCallIntent && trimmed.length > 0) { lastMeaningfulResponse = content; } // If the model signals completion, return the last meaningful response (not the marker) if (isCompletionMarker) { const responseToReturn = lastMeaningfulResponse || content; const extracted = extractHandoffMessage(responseToReturn); handoffMessage = extracted.handoffMessage || handoffMessage; return { response: extracted.response, generated_files: filesModified, handoff_message: handoffMessage }; } if (shouldTreatAsFinalResponse) { const extracted = extractHandoffMessage(content); handoffMessage = extracted.handoffMessage || handoffMessage; return { response: extracted.response, generated_files: filesModified, handoff_message: handoffMessage }; } if (noToolCallCount >= 3) { const responseToReturn = lastMeaningfulResponse || content; const extracted = extractHandoffMessage(responseToReturn); handoffMessage = extracted.handoffMessage || handoffMessage; return { response: extracted.response, generated_files: filesModified, handoff_message: handoffMessage }; } msgList.push({ role: "assistant", content: content }); loops++; } } catch (err: any) { if (subAgentDebugLogging) { console.log(`[Sub-Agent] Loop error: ${err.message}`); } msgList.push({ role: "user", content: `Error: ${err.message}` }); loops++; } } // Use the last meaningful response if available (avoids returning bare completion markers) const responseToUse = lastMeaningfulResponse || finalContent; return { response: responseToUse, generated_files: filesModified, handoff_message: handoffMessage }; } export const toolsProvider: ToolsProvider = async (ctl) => { const client = (ctl as any).client as LMStudioClient; const pluginConfig = ctl.getPluginConfig(pluginConfigSchematics); const defaultWorkspacePath = pluginConfig.get("general.defaultWorkspacePath"); const neo4jConfig = { uri: (pluginConfig.get("neo4j.uri") || "").trim(), username: (pluginConfig.get("neo4j.username") || "neo4j").trim(), password: pluginConfig.get("neo4j.password") ?? "", }; /** Prefer plugin settings; optional connection_string is an override only. */ const resolveNeo4jConnection = (connectionString?: string) => { const uri = (connectionString?.trim() || neo4jConfig.uri).trim(); if (!uri) { throw new Error( "Neo4j is not configured. Set neo4j.uri (and neo4j.password) in Timbers Toolbox plugin settings, or pass connection_string as an override.", ); } if (!connectionString?.trim() && !neo4jConfig.password) { throw new Error( "Neo4j password is empty. Set neo4j.password in Timbers Toolbox plugin settings.", ); } return { connection_string: uri, username: neo4jConfig.username || "neo4j", password: neo4jConfig.password || undefined, }; }; // LM Studio standard per-chat working directory (used when config path is empty) const lmStudioCwd = getRuntimeWorkingDirectory(ctl); // Hot-swappable: re-reads config every toolsProvider invocation const fullState = await getPersistedState(defaultWorkspacePath, lmStudioCwd); let currentWorkingDirectory = fullState.currentWorkingDirectory; let workspaceRoot = fullState.workspaceRoot; const allowAllCode = pluginConfig.get("execution.allowAllCode"); const unrestrictedMode = pluginConfig.get("general.unrestrictedMode") === true; // Push the master switch into the path layer FIRST so every validatePath / // assertInsideWorkspace / change_directory call in this process honors it. setUnrestrictedMode(unrestrictedMode); let allowJavascript = pluginConfig.get("execution.allowJavascriptExecution"); let allowPython = pluginConfig.get("execution.allowPythonExecution"); let allowTerminal = pluginConfig.get("execution.allowTerminalExecution"); let allowShell = pluginConfig.get("execution.allowShellCommandExecution"); let allowBrowserControl = pluginConfig.get("execution.allowBrowserControl"); const sandboxWorkspace = pluginConfig.get("execution.sandboxWorkspace"); const getExecCwd = () => (sandboxWorkspace && !unrestrictedMode ? currentWorkingDirectory : process.cwd()); let enableMemory = pluginConfig.get("memory.enabled"); let enableWikipedia = pluginConfig.get("wikipedia.enabled"); let enableLocalRag = pluginConfig.get("localRag.enabled"); let enableSecondary = pluginConfig.get("agent.enableSecondaryAgent"); const embeddingModelName = pluginConfig.get("retrieval.embeddingModel"); // Master override (single toggle – unchanged) if (allowAllCode) { allowJavascript = true; allowPython = true; allowTerminal = true; allowShell = true; allowBrowserControl = true; } // ⚠️ UNRESTRICTED MODE: enable EVERYTHING, ignore every individual toggle. // Covers: execution (js/py/terminal/shell/browser), git, github, DB inspect, // notifications, memory, wikipedia, local RAG, secondary agent + sub-agent caps. let allowGit = pluginConfig.get("git.allowGitOperations"); let allowDb = pluginConfig.get("git.allowDatabaseInspection"); let allowNotify = pluginConfig.get("execution.allowSystemNotifications"); let allowGitHubTools = pluginConfig.get("git.allowGitHubTools"); let allowSubAgentFS = pluginConfig.get("agent.subAgentAllowFileSystem"); let allowSubAgentWeb = pluginConfig.get("agent.subAgentAllowWeb"); let allowSubAgentCode = pluginConfig.get("agent.subAgentAllowCode"); let allowSubAgentBrowser = pluginConfig.get("agent.subAgentAllowBrowserControl"); let evalEnabled = pluginConfig.get("eval.enabled"); let docParserEnabled = pluginConfig.get("documentParser.enabled"); if (unrestrictedMode) { allowJavascript = true; allowPython = true; allowTerminal = true; allowShell = true; allowBrowserControl = true; allowGit = true; allowDb = true; allowNotify = true; allowGitHubTools = true; enableMemory = true; enableWikipedia = true; enableLocalRag = true; enableSecondary = true; allowSubAgentFS = true; allowSubAgentWeb = true; allowSubAgentCode = true; allowSubAgentBrowser = true; evalEnabled = true; docParserEnabled = true; console.log("[toolsProvider] ⚠️ UNRESTRICTED MODE ON — all tools enabled, workspace sandbox disabled."); } // Ensure workspace exists; always refresh live CWD into status await ensureWorkspaceExists(workspaceRoot); if (currentWorkingDirectory !== workspaceRoot) { await ensureWorkspaceExists(currentWorkingDirectory); } setWorkspacePaths(currentWorkingDirectory, workspaceRoot); fullState.currentWorkingDirectory = currentWorkingDirectory; fullState.workspaceRoot = workspaceRoot; await savePersistedState(fullState); // --- Memory / State Enforcement --- // Ensure memory.md exists and is initialized with a header const memoryPath = await ensureMemoryFileExists(workspaceRoot); // Sync in-memory knowledge with persisted memory.md on every plugin load const memSyncResult = await syncMemoryState(workspaceRoot); if (!memSyncResult.synced) { console.log(`[stateManager] Initialized new memory file at ${memoryPath}`); } else { console.log(`[stateManager] Memory synced: ${memSyncResult.entriesCount} entries loaded from ${memoryPath}`); } // Log message count status for context compression tracking if (!isWorkspaceInitialized) { console.log(formatCwdStatus(fullState)); isWorkspaceInitialized = true; } console.log(`[stateManager] Message count: ${fullState.messageCount} (compression threshold: ${50})`); // Persist uiLanguageOverride on every plugin load so i18n.ts can read it // synchronously at the next startup — no message required. const uiLanguageOverride = pluginConfig.get("general.uiLanguageOverride"); if (fullState.uiLanguageOverride !== uiLanguageOverride) { fullState.uiLanguageOverride = uiLanguageOverride; await savePersistedState(fullState); console.log(`[i18n] uiLanguageOverride persisted: "${uiLanguageOverride}". Restart plugin to apply.`); } const tools: Tool[] = []; let browserSession: { browser: Browser; page: Page; currentUrl: string } | null = null; // (allowGit / allowDb / allowNotify / allowGitHubTools already resolved above // with unrestrictedMode override — do NOT re-read raw config here.) // --- Git Tools --- if (allowGit) { const gitStatusTool = tool({ name: "git_status", description: "Get the current git status of the repository.", parameters: {}, implementation: async () => { const { simpleGit } = await import("simple-git"); const git = simpleGit(currentWorkingDirectory); try { const status = await git.status(); return status; } catch (e) { return { error: `Git status failed: ${e instanceof Error ? e.message : String(e)}` }; } } }); tools.push(gitStatusTool); const gitDiffTool = tool({ name: "git_diff", description: "Get the git diff of the current repository or specific files.", parameters: { file_path: z.string().optional().describe("Optional: Path to specific file to diff."), cached: z.boolean().optional().describe("Optional: Show staged changes only (git diff --cached).") }, implementation: async ({ file_path, cached }) => { const { simpleGit } = await import("simple-git"); const git = simpleGit(currentWorkingDirectory); try { const args = []; if (cached) args.push("--cached"); if (file_path) args.push(validatePath(currentWorkingDirectory, file_path)); const diff = await git.diff(args); return { diff: diff || "No changes." }; } catch (e) { return { error: `Git diff failed: ${e instanceof Error ? e.message : String(e)}` }; } } }); tools.push(gitDiffTool); const gitCommitTool = tool({ name: "git_commit", description: "Commit staged changes to the git repository.", parameters: { message: z.string(), }, implementation: async ({ message }) => { const { simpleGit } = await import("simple-git"); const git = simpleGit(currentWorkingDirectory); try { // Ensure something is staged? Assuming user has used 'execute_command("git add ...")' or we should auto-stage? // Standard git behavior is to commit only staged. const result = await git.commit(message); return { success: true, summary: result.summary }; } catch (e) { return { error: `Git commit failed: ${e instanceof Error ? e.message : String(e)}` }; } } }); tools.push(gitCommitTool); const gitLogTool = tool({ name: "git_log", description: "Get recent git commit history.", parameters: { max_count: z.number().optional().describe("Max number of commits to return (default: 10)") }, implementation: async ({ max_count = 10 }) => { const { simpleGit } = await import("simple-git"); const git = simpleGit(currentWorkingDirectory); try { const log = await git.log({ maxCount: max_count }); return { history: log.all }; } catch (e) { return { error: `Git log failed: ${e instanceof Error ? e.message : String(e)}` }; } } }); tools.push(gitLogTool); const gitAddTool = tool({ name: "git_add", description: "Stage specific files or all changes for the next commit.", parameters: { paths: z.array(z.string()).optional().describe("Optional: Specific file paths to stage. If omitted, stages all changes."), }, implementation: async ({ paths }) => { const { simpleGit } = await import("simple-git"); const git = simpleGit(currentWorkingDirectory); try { if (paths && paths.length > 0) { const validatedPaths = paths.map(p => validatePath(currentWorkingDirectory, p)); await git.add(validatedPaths); } else { await git.add("."); } return { success: true, message: "Files staged successfully." }; } catch (e) { return { error: `Git add failed: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(gitAddTool); const gitCheckoutTool = tool({ name: "git_checkout", description: "Switch to an existing branch or create and switch to a new one.", parameters: { branch_name: z.string().describe("Name of the branch to checkout."), create_new: z.boolean().optional().default(false).describe("If true, creates the branch if it doesn't exist (like git checkout -b)."), }, implementation: async ({ branch_name, create_new = false }) => { const { simpleGit } = await import("simple-git"); const git = simpleGit(currentWorkingDirectory); try { if (create_new) { await git.checkout(["-b", branch_name]); } else { await git.checkout(branch_name); } return { success: true, message: `Switched to branch '${branch_name}'.` }; } catch (e) { return { error: `Git checkout failed: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(gitCheckoutTool); } // --- Document Tools --- const readDocumentTool = tool({ name: "read_document", description: "Read content from PDF or DOCX files.", parameters: { file_path: z.string(), }, implementation: async ({ file_path }) => { const fpath = validatePath(currentWorkingDirectory, file_path); const ext = fpath.split('.').pop()?.toLowerCase(); try { if (ext === 'pdf') { // Polyfill DOMMatrix for pdf-parse v2 (required for node environment) if (typeof global.DOMMatrix === 'undefined') { (global as any).DOMMatrix = class DOMMatrix { constructor(arg?: any) { (this as any).a = 1; (this as any).b = 0; (this as any).c = 0; (this as any).d = 1; (this as any).e = 0; (this as any).f = 0; if (Array.isArray(arg)) { (this as any).a = arg[0]; (this as any).b = arg[1]; (this as any).c = arg[2]; (this as any).d = arg[3]; (this as any).e = arg[4]; (this as any).f = arg[5]; } } }; } // Dynamically require pdf-parse v2 class const { PDFParse } = require("pdf-parse"); const dataBuffer = await readFile(fpath); // Use new class-based API const parser = new PDFParse({ data: dataBuffer }); const textResult = await parser.getText(); const infoResult = await parser.getInfo(); // Optional: get metadata await parser.destroy(); // Cleanup return { content: textResult.text, metadata: infoResult.info }; } else if (ext === 'docx') { const mammoth = await import("mammoth"); const result = await mammoth.extractRawText({ path: fpath }); return { content: result.value, messages: result.messages }; } else { return { error: "Unsupported document format. Use read_file for text files." }; } } catch (e) { return { error: `Failed to read document: ${e instanceof Error ? e.message : String(e)}` }; } } }); tools.push(readDocumentTool); // --- Notification Tool --- if (allowNotify) { const sendNotificationTool = tool({ name: "send_notification", description: "Send a system notification to the user.", parameters: { title: z.string(), message: z.string(), }, implementation: async ({ title, message }) => { const notifier = await import("node-notifier"); // node-notifier is a CommonJS module, so dynamic import returns it on .default notifier.default.notify({ title: title, message: message, sound: true, wait: false }); return { success: true, message: "Notification sent." }; } }); tools.push(sendNotificationTool); } // --- Database Tool --- if (allowDb) { const queryDatabaseTool = tool({ name: "query_database", description: "Execute a read-only query on a SQLite database file.", parameters: { db_path: z.string(), query: z.string(), }, implementation: async ({ db_path, query }) => { const fpath = validatePath(currentWorkingDirectory, db_path); // Safety: Attempt to block write operations (naive check) if (/^\s*(INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|REPLACE)\b/i.test(query)) { return { error: "Only SELECT/read queries are allowed for safety." }; } try { const Database = (await import("better-sqlite3")).default; const db = new Database(fpath, { readonly: true }); const stmt = db.prepare(query); const results = stmt.all(); db.close(); return { results }; } catch (e) { return { error: `Database query failed: ${e instanceof Error ? e.message : String(e)}` }; } } }); tools.push(queryDatabaseTool); } // --- Code Analysis Tool --- const analyzeProjectTool = tool({ name: "analyze_project", description: "Run project-wide analysis (linting) to find errors and warnings.", parameters: {}, implementation: async () => { // Try to detect available linters const packageJsonPath = join(currentWorkingDirectory, "package.json"); let command = ""; let type = "unknown"; try { const pkg = JSON.parse(await readFile(packageJsonPath, "utf-8")); if (pkg.scripts && pkg.scripts.lint) { command = "npm run lint"; type = "npm-script"; } else if (pkg.devDependencies?.eslint || pkg.dependencies?.eslint) { command = "npx eslint . --format json"; // JSON for easier parsing? Or just text. type = "eslint"; } } catch (e) { // check for python? const entries = await readdir(currentWorkingDirectory); if (entries.some(f => f.endsWith(".py"))) { command = "pylint ."; // Assuming pylint is in path type = "python-lint"; } } if (!command) { return { error: "Could not detect a supported linter (ESLint script or Python)." }; } try { const child = spawn(command, { shell: true, cwd: getExecCwd(), timeout: 60000 }); let stdout = ""; let stderr = ""; child.stdout.on("data", d => stdout += d); child.stderr.on("data", d => stderr += d); await new Promise((resolve) => child.on("close", resolve)); return { tool: command, type, report: (stdout + stderr).substring(0, 10000) // Limit size }; } catch (e) { return { error: `Analysis failed: ${e instanceof Error ? e.message : String(e)}` }; } } }); tools.push(analyzeProjectTool); const changeDirectoryTool = tool({ name: "change_directory", description: text` Change the current working directory. - Relative path: move within the current workspace. - Absolute path to an existing directory: hot-swap the workspace to that path (switch projects mid-session, e.g. D:\\AGI_Copy or E:\\AI\\new_build). Always returns the new Current working directory. `, parameters: { directory: z.string().describe( "Relative path inside workspace, or absolute path to switch workspaces", ), }, implementation: async ({ directory }) => { const result = await changeWorkingDirectory(fullState, directory); currentWorkingDirectory = result.current_directory; workspaceRoot = result.workspace_root; setWorkspacePaths(currentWorkingDirectory, workspaceRoot); return result; }, }); tools.push(changeDirectoryTool); // pwd – explicit current working directory readout const pwdTool = tool({ name: "pwd", description: "Print the current working directory and workspace root.", parameters: {}, implementation: async () => ({ current_working_directory: currentWorkingDirectory, workspace_root: workspaceRoot, message: `Current working directory: ${currentWorkingDirectory}`, }), }); tools.push(pwdTool); const saveMemoryTool = tool({ name: "save_memory", description: text` Save a specific piece of information or fact to long-term memory. This information will be available in future interactions if memory is enabled. Use this for user preferences, important facts, or context that should persist. Memory is persisted to 'memory.md' in the workspace root and synced across sessions. `, parameters: { fact: z.string().describe("The specific fact or piece of information to remember."), }, implementation: async ({ fact }) => { if (!enableMemory) { return { error: "Memory is currently disabled in the plugin settings. Please ask the user to enable it." }; } // Ensure memory file exists before writing const memoryFile = await ensureMemoryFileExists(workspaceRoot); const timestamp = new Date().toISOString(); const entry = `\n- [${timestamp}] ${fact}`; try { await appendFile(memoryFile, entry, "utf-8"); // Sync state after saving to ensure persistence await syncMemoryState(workspaceRoot); // Also mirror into the HybridMemoryService store (.timber_memory.md) so // memory_search / memory_list (workspace scope) see save_memory writes. // Without this, save_memory → memory.md but memory_search → .timber_memory.md (invisible). // getMemoryConfig is defined below but resolved at tool-call time (post-init), so safe. try { await memoryTools.memory_save(`md-${Date.now()}`, fact, getMemoryConfig("workspace")); invalidateMemoryCache(); } catch (mirrorErr) { console.warn(`[save_memory] hybrid mirror failed (memory.md write succeeded): ${mirrorErr instanceof Error ? mirrorErr.message : String(mirrorErr)}`); } return { success: true, message: `Fact saved to memory. Total entries in ${memoryFile}.` }; } catch (error) { try { await writeFile(memoryFile, "# Long-Term Memory\n" + entry, "utf-8"); await syncMemoryState(workspaceRoot); return { success: true, message: `Fact saved to memory (new file created at ${memoryFile}).` }; } catch (writeError) { return { error: `Failed to save memory: ${writeError instanceof Error ? writeError.message : String(writeError)}` }; } } }, }); tools.push(saveMemoryTool); const originalRunJavascriptImplementation = async ({ javascript, timeout_seconds }: { javascript: string; timeout_seconds?: number }) => { const scriptFileName = `temp_script_${Date.now()}.ts`; const scriptFilePath = join(currentWorkingDirectory, scriptFileName); try { await writeFile(scriptFilePath, javascript, "utf-8"); const childProcess = spawn( getDenoPath(), [ "run", "--allow-read=.", "--allow-write=.", "--no-prompt", "--deny-net", "--deny-env", "--deny-sys", "--deny-run", "--deny-ffi", scriptFilePath, ], { cwd: getExecCwd(), timeout: (timeout_seconds ?? 5) * 1000, // Convert seconds to milliseconds stdio: "pipe", env: { NO_COLOR: "true", // Disable color output in Deno }, }, ); let stdout = ""; let stderr = ""; childProcess.stdout.setEncoding("utf-8"); childProcess.stderr.setEncoding("utf-8"); childProcess.stdout.on("data", data => { stdout += data; }); childProcess.stderr.on("data", data => { stderr += data; }); await new Promise((resolve, reject) => { childProcess.on("close", code => { if (code === 0) { resolve(); } else { reject(new Error(`Process exited with code ${code}. Stderr: ${stderr}`)); } }); childProcess.on("error", err => { reject(err); }); }); return { stdout: stdout.trim(), stderr: stderr.trim(), }; } finally { // Always cleanup temp file, even on error await rm(scriptFilePath, { force: true }).catch(() => { }); } }; const createFileTool = tool({ name: "run_javascript", description: text` Run a JavaScript code snippet using deno. You cannot import external modules but you have read/write access to the current working directory. Pass the code you wish to run as a string in the 'javascript' parameter. By default, the code will timeout in 5 seconds. You can extend this timeout by setting the 'timeout_seconds' parameter to a higher value in seconds, up to a maximum of 60 seconds. You will get the stdout and stderr output of the code execution, thus please print the output you wish to return using 'console.log' or 'console.error'. `, parameters: { javascript: z.string(), timeout_seconds: z.number().min(0.1).max(60).optional() }, implementation: createSafeToolImplementation( originalRunJavascriptImplementation, allowJavascript, "run_javascript" ), }); tools.push(createFileTool); const originalRunPythonImplementation = async ({ python, timeout_seconds }: { python: string; timeout_seconds?: number }) => { const scriptFileName = `temp_script_${Date.now()}.py`; const scriptFilePath = join(currentWorkingDirectory, scriptFileName); try { await writeFile(scriptFilePath, python, "utf-8"); const childProcess = spawn( "python", [ scriptFilePath, ], { cwd: getExecCwd(), timeout: (timeout_seconds ?? 5) * 1000, // Convert seconds to milliseconds stdio: "pipe", }, ); let stdout = ""; let stderr = ""; childProcess.stdout.setEncoding("utf-8"); childProcess.stderr.setEncoding("utf-8"); childProcess.stdout.on("data", data => { stdout += data; }); childProcess.stderr.on("data", data => { stderr += data; }); await new Promise((resolve, reject) => { childProcess.on("close", code => { if (code === 0) { resolve(); } else { reject(new Error(`Process exited with code ${code}. Stderr: ${stderr}`)); } }); childProcess.on("error", err => { reject(err); }); }); return { stdout: stdout.trim(), stderr: stderr.trim(), }; } finally { // Always cleanup temp file, even on error await rm(scriptFilePath, { force: true }).catch(() => { }); } }; const runPythonTool = tool({ name: "run_python", description: text` Run a Python code snippet. You cannot import external modules but you have read/write access to the current working directory. Pass the code you wish to run as a string in the 'python' parameter. By default, the code will timeout in 5 seconds. You can extend this timeout by setting the 'timeout_seconds' parameter to a higher value in seconds, up to a maximum of 60 seconds. You will get the stdout and stderr output of the code execution, thus please print the output you wish to return using 'print()'. `, parameters: { python: z.string(), timeout_seconds: z.number().min(0.1).max(60).optional() }, implementation: createSafeToolImplementation( originalRunPythonImplementation, allowPython, "run_python" ), }); tools.push(runPythonTool); const saveFileTool = tool({ name: "save_file", description: text` Save content to a specified file in the current working directory. This tool returns the full path to the saved file. You should then output this full path to the user. `, parameters: { file_name: z.string().optional(), content: z.string().optional(), files: z.array(z.object({ file_name: z.string(), content: z.string() })).optional().describe("For saving multiple files at once. E.g. [{file_name: 'a.txt', content: 'hello'}]"), }, implementation: async ({ file_name, content, files }) => { const filesToSave = Array.isArray(files) ? files : []; if (file_name && content) { filesToSave.push({ file_name, content }); } if (filesToSave.length === 0) { return { error: "Must provide either file_name and content, or a files array." }; } const savedPaths: string[] = []; const errors: string[] = []; for (const file of filesToSave) { // Validate filename if (!file.file_name || file.file_name.trim().length === 0) { errors.push(`Filename cannot be empty`); continue; } if (file.file_name && /[ \*\?<>|"]/.test(file.file_name)) { errors.push("Filename " + file.file_name + " contains invalid characters"); } try { const filePath = validatePath(currentWorkingDirectory, file.file_name); await mkdir(dirname(filePath), { recursive: true }); await writeFile(filePath, file.content, "utf-8"); savedPaths.push(filePath); } catch (e) { errors.push(`Failed to save ${file.file_name}: ${e instanceof Error ? e.message : String(e)}`); } } if (errors.length > 0 && savedPaths.length === 0) { return { error: errors.join("\n") }; } return { success: true, paths: savedPaths, errors: errors.length > 0 ? errors : undefined, }; }, }); tools.push(saveFileTool); const replaceTextTool = tool({ name: "replace_text_in_file", description: text` Replace a specific string in a file with a new string. Useful for making small edits without rewriting the entire file. Ensure 'old_string' matches exactly (including whitespace) or the replace will fail. `, parameters: { file_name: z.string(), old_string: z.string().describe("The exact text to replace. Must be unique in the file."), new_string: z.string().describe("The text to insert in place of old_string."), }, implementation: async ({ file_name, old_string, new_string }) => { try { if (!old_string || old_string.length === 0) { return { error: "old_string cannot be empty" }; } const filePath = validatePath(currentWorkingDirectory, file_name); const content = await readFile(filePath, "utf-8"); if (!content.includes(old_string)) { return { error: "Could not find the exact 'old_string' in the file. Please check whitespace and indentation." }; } const occurrenceCount = content.split(old_string).length - 1; if (occurrenceCount > 1) { return { error: `Found ${occurrenceCount} occurrences of 'old_string'. Please provide more context (surrounding lines) in 'old_string' to make it unique.` }; } const newContent = content.replace(old_string, new_string); await writeFile(filePath, newContent, "utf-8"); return { success: true, message: `Successfully replaced text in ${file_name}` }; } catch (e) { return { error: `Failed to replace text: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(replaceTextTool); const multiReplaceTextTool = tool({ name: "multi_replace_text", description: text` Replace multiple scattered text blocks in a single file safely. Each replacement must specify start_line, end_line, old_string, and new_string. The old_string must perfectly match what is currently in the file. `, parameters: { file_name: z.string(), replacements: z.array(z.object({ start_line: z.number().int().min(1), end_line: z.number().int().min(1), old_string: z.string(), new_string: z.string() })).describe("Array of replacements to make in the file") }, implementation: async ({ file_name, replacements }) => { try { const filePath = validatePath(currentWorkingDirectory, file_name); const content = await readFile(filePath, "utf-8"); let lines = content.split("\n"); let errors = []; // Sort replacements from bottom to top to avoid line index shifts! const sortedReplacements = [...replacements].sort((a, b) => b.start_line - a.start_line); for (const rep of sortedReplacements) { if (rep.start_line > rep.end_line) { errors.push(`Invalid range: start_line ${rep.start_line} > end_line ${rep.end_line}`); continue; } const chunk = lines.slice(rep.start_line - 1, rep.end_line).join("\n"); if (!chunk.includes(rep.old_string)) { errors.push(`Could not find old_string between lines ${rep.start_line}-${rep.end_line}`); continue; } // Only replace the first occurrence in the exact block const newChunk = chunk.replace(rep.old_string, rep.new_string); const newChunkLines = newChunk.split("\n"); lines.splice(rep.start_line - 1, rep.end_line - rep.start_line + 1, ...newChunkLines); } if (errors.length > 0) { return { error: "Replacements failed:\n" + errors.join("\n") }; } await writeFile(filePath, lines.join("\n"), "utf-8"); return { success: true, message: `Applied ${replacements.length} replacements to ${file_name}` }; } catch (e) { return { error: `Failed to multi-replace: ${e instanceof Error ? e.message : String(e)}` }; } } }); tools.push(multiReplaceTextTool); const searchDirectoryTool = tool({ name: "search_directory", description: text` Search an entire directory for a regex pattern (like grep). Returns matching file paths and line numbers. `, parameters: { directory_path: z.string().optional().describe("Directory to search. Defaults to workspace root."), pattern: z.string().describe("Regex pattern or string to search for"), use_regex: z.boolean().optional().default(false) }, implementation: async ({ directory_path, pattern, use_regex }) => { try { const targetDir = directory_path ? validatePath(currentWorkingDirectory, directory_path) : currentWorkingDirectory; const regex = new RegExp( use_regex ? pattern : pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g", ); const results: string[] = []; let searchedCount = 0; async function search(dir: string) { const files = await readdir(dir); for (const file of files) { if (file === "node_modules" || file === ".git" || file.startsWith(".")) continue; const fullPath = join(dir, file); const st = await stat(fullPath); if (st.isDirectory()) { await search(fullPath); } else if (st.isFile()) { if (st.size > 2000000) continue; // Skip large files > 2MB try { const content = await readFile(fullPath, "utf-8"); if (content.includes('\0')) continue; // Skip binary const lines = content.split('\n'); for (let i = 0; i < lines.length; i++) { if (lines[i].match(regex)) { results.push(`${relative(currentWorkingDirectory, fullPath)}:${i+1} => ${lines[i].trim()}`); if (results.length >= 100) return; // Limit output } } searchedCount++; } catch (e) {} } } } await search(targetDir); if (results.length === 0) return { message: `No matches found. Searched ${searchedCount} files.` }; return { matches: results, message: `Found ${results.length} matches across ${searchedCount} files searched.` }; } catch (e) { return { error: `Search failed: ${e instanceof Error ? e.message : String(e)}` }; } } }); tools.push(searchDirectoryTool); const runBackgroundCommandTool = tool({ name: "run_background_command", description: text` Starts a long-running process in the background. The process is not blocked, allowing you to do other things. You MUST provide a timeout (max 10 hours) and a descriptive name. `, parameters: { command: z.string(), timeout_hours: z.number().max(10).describe("MANDATORY: How long the process is allowed to run before being killed."), name: z.string().describe("MANDATORY: A short, descriptive name for the background task (e.g. 'Vite Dev Server')") }, implementation: async ({ command, timeout_hours, name }) => { try { if (!timeout_hours) return { error: "timeout_hours is MANDATORY" }; if (!name) return { error: "name is MANDATORY" }; const timeoutMs = timeout_hours * 60 * 60 * 1000; const id = generateId(); const isWindows = os.platform() === "win32"; const shellCmd = isWindows ? "cmd.exe" : "sh"; const shellArgs = isWindows ? ["/c", command] : ["-c", command]; const proc = spawn(shellCmd, shellArgs, { cwd: getExecCwd() }); const bgCmd: BackgroundCommand = { id, name, startTime: Date.now(), process: proc, timeoutMs, stdout: "", stderr: "", status: "running" as const }; proc.stdout.on("data", (data) => { bgCmd.stdout += data.toString(); if (bgCmd.stdout.length > 50000) bgCmd.stdout = bgCmd.stdout.slice(-50000); }); proc.stderr.on("data", (data) => { bgCmd.stderr += data.toString(); if (bgCmd.stderr.length > 50000) bgCmd.stderr = bgCmd.stderr.slice(-50000); }); proc.on("close", (code) => { bgCmd.status = bgCmd.status === "cancelled" || bgCmd.status === "timeout" ? bgCmd.status : "completed"; bgCmd.exitCode = code; if (bgCmd.timeoutHandle) clearTimeout(bgCmd.timeoutHandle); }); proc.on("error", (err) => { bgCmd.status = "error"; bgCmd.stderr += `\nError: ${err.message}`; }); bgCmd.timeoutHandle = setTimeout(() => { if (bgCmd.status === "running") { bgCmd.status = "timeout"; proc.kill("SIGKILL"); } }, timeoutMs); backgroundCommands.set(id, bgCmd); // Wait briefly to catch immediate errors await new Promise((resolve) => setTimeout(resolve, 500)); return { id, status: bgCmd.status, message: `Command launched. Use check_background_command with ID ${id} to poll output.`, initial_stdout: bgCmd.stdout.slice(-1000), initial_stderr: bgCmd.stderr.slice(-1000) }; } catch (e) { return { error: `Failed to launch: ${e instanceof Error ? e.message : String(e)}` }; } } }); tools.push(runBackgroundCommandTool); const checkBackgroundCommandTool = tool({ name: "check_background_command", description: "Check the status, stdout, and stderr of a running or completed background command.", parameters: { id: z.string() }, implementation: async ({ id }) => { const bgCmd = backgroundCommands.get(id); if (!bgCmd) return { error: `No background command found with ID ${id}` }; return { id: bgCmd.id, name: bgCmd.name, status: bgCmd.status, duration_seconds: Math.floor((Date.now() - bgCmd.startTime) / 1000), stdout_tail: bgCmd.stdout.slice(-2000), // last 2000 chars stderr_tail: bgCmd.stderr.slice(-2000), exitCode: bgCmd.exitCode }; } }); tools.push(checkBackgroundCommandTool); const cancelBackgroundCommandTool = tool({ name: "cancel_background_command", description: "Kills a running background command.", parameters: { id: z.string() }, implementation: async ({ id }) => { const bgCmd = backgroundCommands.get(id); if (!bgCmd) return { error: `No background command found with ID ${id}` }; if (bgCmd.status !== "running") return { message: `Command is already ${bgCmd.status}` }; bgCmd.status = "cancelled"; bgCmd.process.kill("SIGKILL"); if (bgCmd.timeoutHandle) clearTimeout(bgCmd.timeoutHandle); return { success: true, message: `Command ${id} killed.` }; } }); tools.push(cancelBackgroundCommandTool); const listDirectoryTool = tool({ name: "list_directory", description: "List the files and directories in the current working directory or a specified subdirectory.", parameters: { path: z.string().optional().describe("The path to the directory to list. Defaults to current working directory."), }, implementation: async ({ path }) => { const targetPath = path ? validatePath(currentWorkingDirectory, path) : currentWorkingDirectory; const files = await readdir(targetPath); return { files, }; }, }); tools.push(listDirectoryTool); const readFileTool = tool({ name: "read_file", description: "Read the content of a file in the current working directory.", parameters: { file_name: z.string(), }, implementation: async ({ file_name }) => { const filePath = validatePath(currentWorkingDirectory, file_name); const stats = await stat(filePath); if (stats.size > 10_000_000) { return { error: "File too large (>10MB)" }; } // Check for binary content (simple null byte check in first 1KB) // Read as buffer first const buffer = await readFile(filePath); // Check first 1024 bytes for null byte const checkBuffer = buffer.subarray(0, Math.min(buffer.length, 1024)); if (checkBuffer.includes(0)) { return { error: "File appears to be binary and cannot be read as text." }; } const content = buffer.toString("utf-8"); return { content, }; }, }); tools.push(readFileTool); const originalExecuteCommandImplementation = async ({ command, input, timeout_seconds }: { command: string; input?: string; timeout_seconds?: number }) => { const childProcess = spawn(command, [], { cwd: getExecCwd(), shell: true, timeout: (timeout_seconds ?? 5) * 1000, stdio: "pipe", }); if (input) { childProcess.stdin.write(input); childProcess.stdin.end(); } else { // If no input is provided, we might want to leave stdin open or close it. // Closing it is safer for non-interactive commands to prevent hanging. childProcess.stdin.end(); } let stdout = ""; let stderr = ""; childProcess.stdout.setEncoding("utf-8"); childProcess.stderr.setEncoding("utf-8"); childProcess.stdout.on("data", data => { stdout += data; }); childProcess.stderr.on("data", data => { stderr += data; }); await new Promise((resolve, reject) => { childProcess.on("close", code => { if (code === 0) { resolve(); } else { reject(new Error(`Process exited with code ${code}. Stderr: ${stderr}`)); } }); childProcess.on("error", err => { reject(err); }); }); return { stdout: stdout.trim(), stderr: stderr.trim(), }; }; const executeCommandTool = tool({ name: "execute_command", description: text` Execute a shell command in the current working directory. Returns the stdout and stderr output of the command. You can optionally provide input to be piped to the command's stdin. IMPORTANT: The host operating system is '${process.platform}'. If the OS is 'win32' (Windows), do NOT use 'bash' or 'sh' commands unless you are certain WSL is available. Instead, use standard Windows 'cmd' or 'powershell' syntax. `, parameters: { command: z.string(), input: z.string().optional().describe("Input text to pipe to the command's stdin."), timeout_seconds: z.number().min(0.1).max(60).optional().describe("Timeout in seconds (default: 5, max: 60)"), }, implementation: createSafeToolImplementation( originalExecuteCommandImplementation, allowShell, "execute_command" ), }); tools.push(executeCommandTool); const makeDirectoryTool = tool({ name: "make_directory", description: "Create a new directory in the current working directory.", parameters: { directory_name: z.string(), }, implementation: async ({ directory_name }) => { const dirPath = validatePath(currentWorkingDirectory, directory_name); await mkdir(dirPath, { recursive: true }); return { success: true, path: dirPath, }; }, }); tools.push(makeDirectoryTool); const deletePathTool = tool({ name: "delete_path", description: "Delete a file or directory in the current working directory. Be careful!", parameters: { path: z.string(), }, implementation: async ({ path }) => { const targetPath = validatePath(currentWorkingDirectory, path); await rm(targetPath, { recursive: true, force: true }); return { success: true, path: targetPath, }; }, }); tools.push(deletePathTool); const deleteFilesByPatternTool = tool({ name: "delete_files_by_pattern", description: "Delete multiple files in the current directory that match a regex pattern.", parameters: { pattern: z.string().describe("Regex pattern to match filenames (e.g., '^auto_gen_.*\\.txt$')"), }, implementation: async ({ pattern }) => { try { // Validate regex complexity to prevent ReDoS if (pattern.length > 100) { return { error: "Pattern too complex (max 100 characters)" }; } const regex = new RegExp(pattern); // Safety check for ReDoS const start = Date.now(); regex.test("safe_test_string_for_redos_check_1234567890_safe_test_string_for_redos_check_1234567890"); if (Date.now() - start > 100) { return { error: "Pattern is too complex or slow (ReDoS protection)." }; } const files = await readdir(currentWorkingDirectory); const deleted = []; for (const file of files) { if (regex.test(file)) { await rm(join(currentWorkingDirectory, file), { force: true }); deleted.push(file); } } return { deleted_count: deleted.length, deleted_files: deleted }; } catch (e) { return { error: `Failed to delete files: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(deleteFilesByPatternTool); const originalRunInTerminalImplementation = async ({ command }: { command: string }) => { if (process.platform === "win32") { // Escape quotes to prevent command injection const escapedDir = currentWorkingDirectory.replace(/"/g, '""'); const escapedCmd = command.replace(/"/g, '""'); // Windows: Use 'start' with a title to avoid ambiguity and /D for the directory. const shellCommand = `start "" /D "${escapedDir}" cmd.exe /k "${escapedCmd}"`; const child = spawn("cmd.exe", ["/c", shellCommand], { detached: true, stdio: "ignore", windowsHide: false, windowsVerbatimArguments: true, }); child.unref(); } else { // Linux/Mac if (process.platform === "darwin") { // macOS: Use AppleScript to launch Terminal and run command // Escaping for AppleScript is tricky, simple approach: const safeCmd = command.replace(/\\/g, "\\\\").replace(/"/g, '\\"'); const safeCwd = currentWorkingDirectory.replace(/\\/g, "\\\\").replace(/"/g, '\\"'); const appleScript = ` tell application "Terminal" do script "cd \\"${safeCwd}\\" && ${safeCmd}" activate end tell `; const child = spawn("osascript", ["-e", appleScript], { detached: true, stdio: "ignore" }); child.unref(); } else { // Linux: x-terminal-emulator // Wrap command in single quotes for bash -c const safeCwd = currentWorkingDirectory.replace(/'/g, "'\\''"); const safeCmd = command.replace(/'/g, "'\\''"); const bashScript = `cd '${safeCwd}' && ${safeCmd}; bash`; // spawn directly, don't use sh -c const child = spawn("x-terminal-emulator", ["-e", "bash", "-c", bashScript], { detached: true, stdio: "ignore", }); child.on("error", (e) => { // Fallback to gnome-terminal if x-terminal-emulator fails const child2 = spawn("gnome-terminal", ["--", "bash", "-c", bashScript], { detached: true, stdio: "ignore" }); child2.unref(); }); child.unref(); } } return { success: true, message: "Terminal window launched. Please check your taskbar.", }; }; const runInTerminalTool = tool({ name: "run_in_terminal", description: text` Launch a command in a new, separate interactive terminal window. Use this for scripts that require user interaction (input/output) or to open a shell in a specific directory. (Currently optimized for Windows). `, parameters: { command: z.string(), }, implementation: createSafeToolImplementation( originalRunInTerminalImplementation, allowTerminal, "run_in_terminal" ), }); tools.push(runInTerminalTool); const webSearchTool = tool({ name: "web_search", description: "Search the web using multiple providers (DuckDuckGo, Google, Bing). Uses no-key, no-Chrome providers first, then browser providers as fallback.", parameters: { query: z.string(), providers: z.array(z.enum(["duckduckgo-api", "duckduckgo-fetch", "duckduckgo-html", "google", "bing"])) .optional() .describe("Optional: List of specific providers. If omitted, fallback chain is: DDG Fetch (no Chrome) -> DDG API -> DDG browser -> Google -> Bing."), }, implementation: async ({ query, providers }) => { type SearchProvider = "duckduckgo-api" | "duckduckgo-fetch" | "duckduckgo-html" | "google" | "bing"; type SearchResult = { title: string; link: string; snippet: string; provider: SearchProvider }; const results: SearchResult[] = []; const errors: string[] = []; const logs: string[] = []; const decodeHtmlEntities = (value: string) => value .replace(/"/g, "\"") .replace(/'/g, "'") .replace(/'/g, "'") .replace(/</g, "<") .replace(/>/g, ">") .replace(/ /g, " ") .replace(/&/g, "&"); const stripHtml = (value: string) => decodeHtmlEntities(value) .replace(/<[^>]+>/g, " ") .replace(/\s+/g, " ") .trim(); const normalizeDuckDuckGoLink = (link: string): string => { const decoded = decodeHtmlEntities(link); const absolute = decoded.startsWith("//") ? `https:${decoded}` : decoded.startsWith("/") ? `https://duckduckgo.com${decoded}` : decoded; try { const parsed = new URL(absolute); const redirect = parsed.searchParams.get("uddg"); if (redirect) { return decodeURIComponent(redirect); } } catch { // Return original normalized URL below. } return absolute; }; const parseDuckDuckGoHtml = (html: string, provider: "duckduckgo-fetch" | "duckduckgo-html"): SearchResult[] => { const parsedResults: SearchResult[] = []; const titleRegex = /]*class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/gi; let match: RegExpExecArray | null; while ((match = titleRegex.exec(html)) !== null) { const link = normalizeDuckDuckGoLink(match[1]); const title = stripHtml(match[2]); const nearbyHtml = html.slice(match.index, Math.min(html.length, match.index + 1800)); const snippetMatch = nearbyHtml.match(/class="result__snippet"[^>]*>([\s\S]*?)<\/(?:a|div)>/i); const snippet = snippetMatch ? stripHtml(snippetMatch[1]) : ""; if (title && link) { parsedResults.push({ title, link, snippet, provider }); } if (parsedResults.length >= 10) break; } return parsedResults; }; let sharedBrowser: Browser | null = null; const getBrowser = async () => { if (!sharedBrowser) { const puppeteer = await import("puppeteer"); sharedBrowser = await puppeteer.launch({ headless: true, args: ["--no-sandbox", "--disable-setuid-sandbox"], }); } return sharedBrowser; }; const searchFunctions: Record Promise> = { "duckduckgo-api": async (q: string) => { const { search, SafeSearchType } = await import("duck-duck-scrape"); let attempt = 0; let lastError: unknown = null; while (attempt < 2) { try { const r = await search(q, { safeSearch: SafeSearchType.OFF }); if (r.results && r.results.length > 0) { return r.results.slice(0, 10).map((result: any) => ({ title: result.title, link: result.url, snippet: result.description, provider: "duckduckgo-api", })); } break; } catch (e) { lastError = e; attempt++; await new Promise(res => setTimeout(res, 1000)); } } if (lastError) { throw lastError; } throw new Error("DuckDuckGo API returned no results"); }, "duckduckgo-fetch": async (q: string) => { const response = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(q)}`, { headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36", "Accept-Language": "en-US,en;q=0.9", }, }); if (!response.ok) { throw new Error(`HTTP ${response.status}`); } const html = await response.text(); const extracted = parseDuckDuckGoHtml(html, "duckduckgo-fetch"); if (extracted.length > 0) return extracted; throw new Error("No results parsed from DuckDuckGo HTML"); }, "duckduckgo-html": async (q: string) => { const browser = await getBrowser(); try { const page = await browser.newPage(); await page.goto(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(q)}`, { waitUntil: "networkidle2", timeout: 15000 }); const html = await page.content(); const extracted = parseDuckDuckGoHtml(html, "duckduckgo-html"); if (extracted.length > 0) return extracted; throw new Error("No results found"); } finally { await browser.close(); } }, "google": async (q: string) => { const browser = await getBrowser(); try { const page = await browser.newPage(); await page.goto(`https://www.google.com/search?q=${encodeURIComponent(q)}`, { waitUntil: "networkidle2", timeout: 15000 }); const extracted = await page.evaluate(() => { const items = document.querySelectorAll("div.g"); const data = []; for (const item of items) { const titleEl = item.querySelector("h3"); const linkEl = item.querySelector("a"); const snippetEl = item.querySelector('div[style*="-webkit-line-clamp"]') || item.querySelector("div.VwiC3b"); if (titleEl && linkEl) { data.push({ title: titleEl.innerText, link: linkEl.getAttribute("href") || "", snippet: snippetEl ? (snippetEl as HTMLElement).innerText : "", provider: "google" as const, }); } } return data; }); if (extracted.length > 0) return extracted.slice(0, 10); throw new Error("No results found"); } finally { await browser.close(); } }, "bing": async (q: string) => { const browser = await getBrowser(); try { const page = await browser.newPage(); await page.goto(`https://www.bing.com/search?q=${encodeURIComponent(q)}`, { waitUntil: "networkidle2", timeout: 15000 }); const extracted = await page.evaluate(() => { const items = document.querySelectorAll("li.b_algo"); const data = []; for (const item of items) { const titleEl = item.querySelector("h2 a"); const linkEl = item.querySelector("h2 a"); const snippetEl = item.querySelector("p"); if (titleEl && linkEl) { data.push({ title: (titleEl as HTMLElement).innerText, link: linkEl.getAttribute("href") || "", snippet: snippetEl ? (snippetEl as HTMLElement).innerText : "", provider: "bing" as const, }); } } return data; }); if (extracted.length > 0) return extracted.slice(0, 10); throw new Error("No results found"); } finally { await browser.close(); } }, }; if (providers && providers.length > 0) { for (const providerKey of providers) { try { logs.push(`[Manual] Attempting ${providerKey}...`); const pResults = await searchFunctions[providerKey](query); results.push(...pResults); logs.push(`[Manual] Success: ${providerKey} found ${pResults.length} results.`); } catch (e) { const errMsg = e instanceof Error ? e.message : String(e); errors.push(`${providerKey}: ${errMsg}`); logs.push(`[Manual] Failed: ${providerKey} - ${errMsg}`); } } } else { const chain: SearchProvider[] = ["duckduckgo-fetch", "duckduckgo-api", "duckduckgo-html", "google", "bing"]; const browserProviders: SearchProvider[] = ["duckduckgo-html", "google", "bing"]; let chromeUnavailable = false; for (let i = 0; i < chain.length; i++) { const providerKey = chain[i]; if (chromeUnavailable && browserProviders.includes(providerKey)) { logs.push(`[Fallback Chain] Skipping ${providerKey}: Chrome not available on this system.`); continue; } const nextProvider = chain[i + 1]; try { logs.push(`[Fallback Chain] Attempting ${providerKey}...`); const pResults = await searchFunctions[providerKey](query); results.push(...pResults); logs.push(`[Fallback Chain] Success: ${providerKey} found ${pResults.length} results. Stopping chain.`); break; } catch (e) { const errMsg = e instanceof Error ? e.message : String(e); errors.push(`${providerKey}: ${errMsg}`); if (/chrome|chromium/i.test(errMsg) && browserProviders.includes(providerKey)) { chromeUnavailable = true; logs.push(`[Fallback Chain] Failed: ${providerKey} - Chrome not available. Skipping all browser-based providers.`); } else { const nextMsg = nextProvider ? `Falling back to ${nextProvider}...` : "No more providers."; logs.push(`[Fallback Chain] Failed: ${providerKey} - ${errMsg}. ${nextMsg}`); } } } } if (results.length === 0) { return { error: "All attempted search providers failed.", attempts: errors, trace: logs, }; } const seenLinks = new Set(); const dedupedResults = results.filter(r => { const key = r.link.trim(); if (!key || seenLinks.has(key)) return false; seenLinks.add(key); return true; }); return { results: dedupedResults, meta: { total_found: dedupedResults.length, providers_used: [...new Set(dedupedResults.map(r => r.provider))], no_api_key_required: true, trace: logs, }, }; }, }); tools.push(webSearchTool); const moveFileTool = tool({ name: "move_file", description: "Move or rename a file or directory.", parameters: { source: z.string(), destination: z.string(), }, implementation: async ({ source, destination }) => { const sourcePath = validatePath(currentWorkingDirectory, source); const destPath = validatePath(currentWorkingDirectory, destination); await rename(sourcePath, destPath); return { success: true, from: sourcePath, to: destPath, }; }, }); tools.push(moveFileTool); const copyFileTool = tool({ name: "copy_file", description: "Copy a file to a new location.", parameters: { source: z.string(), destination: z.string(), }, implementation: async ({ source, destination }) => { const sourcePath = validatePath(currentWorkingDirectory, source); const destPath = validatePath(currentWorkingDirectory, destination); await copyFile(sourcePath, destPath); return { success: true, from: sourcePath, to: destPath, }; }, }); tools.push(copyFileTool); const fetchWebContentTool = tool({ name: "fetch_web_content", description: "Fetch the clean, text-based content of a webpage URL.", parameters: { url: z.string(), }, implementation: async ({ url }) => { try { const response = await fetch(url); if (!response.ok) { throw new Error(`HTTP error! status: ${response.status}`); } let text = await response.text(); const result: any = { url, status: response.status, }; const titleMatch = text.match(/]*>([^<]+)<\/title>/i); if (titleMatch) result.title = titleMatch[1]; const { compile } = await import("html-to-text"); const compiledConvert = compile({ wordwrap: false, selectors: [ { selector: "a", options: { ignoreHref: true } }, { selector: "img", format: "skip" }, ], }); text = compiledConvert(text); result.content = text.substring(0, 40000) + (text.length > 40000 ? "... (truncated)" : ""); return result; } catch (error) { return { error: `Failed to fetch URL: ${error instanceof Error ? error.message : String(error)}`, }; } }, }); tools.push(fetchWebContentTool); const ragWebContentTool = tool({ name: "rag_web_content", description: "Fetch content from a URL, and then use RAG to find and return only the text chunks most relevant to a specific query.", parameters: { url: z.string(), query: z.string(), }, implementation: async ({ url, query }) => { try { // 1. Fetch content const response = await fetch(url); if (!response.ok) { throw new Error(`HTTP error! status: ${response.status}`); } let text = await response.text(); const { compile } = await import("html-to-text"); const compiledConvert = compile({ wordwrap: false, selectors: [ { selector: "a", options: { ignoreHref: true } }, { selector: "img", format: "skip" }, ], }); text = compiledConvert(text); if (text.length === 0) { return { error: "Could not extract any text from the URL." }; } // 3. Perform RAG if (!client) { return { error: "LM Studio Client is not available. RAG features require the client to be initialized." }; } const ragResults = await performRagOnText(text, query, client, embeddingModelName); return { url: url, query: query, relevant_chunks: ragResults, }; } catch (error) { return { error: `Failed during RAG web search: ${error instanceof Error ? error.message : String(error)}` }; } }, }); tools.push(ragWebContentTool); const getSystemInfoTool = tool({ name: "get_system_info", description: "Get information about the system (OS, CPU, Memory).", parameters: {}, implementation: async () => { return { platform: os.platform(), arch: os.arch(), release: os.release(), hostname: os.hostname(), total_memory: os.totalmem(), free_memory: os.freemem(), cpus: os.cpus().length, node_version: process.version, }; }, }); tools.push(getSystemInfoTool); const findFilesTool = tool({ name: "find_files", description: "Find files recursively in the current directory matching a name pattern.", parameters: { pattern: z.string().describe("Substring to match in filename (case-insensitive)"), max_depth: z.number().optional().describe("Maximum depth to search (default: 5)"), }, implementation: async ({ pattern, max_depth }) => { const depthLimit = max_depth ?? 5; const foundFiles: string[] = []; const lowerPattern = pattern.toLowerCase(); async function scan(dir: string, currentDepth: number) { if (currentDepth > depthLimit) return; try { const entries = await readdir(dir, { withFileTypes: true }); for (const entry of entries) { if (['node_modules', '.git', 'dist', '.lmstudio'].includes(entry.name)) continue; const fullPath = join(dir, entry.name); if (entry.isDirectory()) { await scan(fullPath, currentDepth + 1); } else if (entry.isFile()) { if (entry.name.toLowerCase().includes(lowerPattern)) { foundFiles.push(fullPath); } } } } catch (e) { // Ignore access errors } } await scan(currentWorkingDirectory, 0); return { found_files: foundFiles.slice(0, 100), // Limit results count: foundFiles.length, }; }, }); tools.push(findFilesTool); const fuzzyFindLocalFilesTool = tool({ name: "fuzzy_find_local_files", description: "Fuzzy find local files by path/name similarity using Levenshtein scoring.", parameters: { query: z.string().describe("Search query to match against file names/paths."), path: z.string().optional().describe("Sub-directory to search in (default: current directory)."), max_results: z.number().int().min(1).max(20).optional().describe("Max results to return (default: 5)."), }, implementation: async (p) => { const searchPath = p.path ?? "."; const maxResults = p.max_results ?? 5; try { const targetDir = validatePath(currentWorkingDirectory, searchPath); console.log(`[fuzzy_find_local_files] searchPath=${searchPath}, targetDir=${targetDir}, typeof=${typeof targetDir}`); if (!targetDir || typeof targetDir !== 'string') { return { error: `Fuzzy file search failed: targetDir is not a valid string (got: ${targetDir})` }; } const entries = await readdir(targetDir, { recursive: true, withFileTypes: true }); const files = entries .filter(entry => entry.isFile()) .map(entry => { const fullPath = join(entry.path, entry.name); const relativePath = relative(targetDir, fullPath); return relativePath.replace(/\\/g, "/"); }); const ranked = rankFuzzyMatches(p.query, files, maxResults); return { query: p.query, path: targetDir, results: ranked.map(item => ({ path: item.value, score: item.score, })), }; } catch (error) { return { error: `Fuzzy file search failed: ${error instanceof Error ? error.message : String(error)}` }; } }, }); tools.push(fuzzyFindLocalFilesTool); const getFileMetadataTool = tool({ name: "get_file_metadata", description: "Get metadata (size, dates) for a specific file.", parameters: { path: z.string(), }, implementation: async ({ path }) => { try { const targetPath = validatePath(currentWorkingDirectory, path); const stats = await stat(targetPath); return { path: targetPath, size: stats.size, created: stats.birthtime, modified: stats.mtime, is_directory: stats.isDirectory(), is_file: stats.isFile(), }; } catch (error) { return { error: `Failed to get metadata: ${error instanceof Error ? error.message : String(error)}` }; } }, }); tools.push(getFileMetadataTool); const readClipboardTool = tool({ name: "read_clipboard", description: "Read text content from the system clipboard.", parameters: {}, implementation: async () => { let command = ""; let args: string[] = []; if (process.platform === "win32") { command = "powershell"; args = ["-command", "Get-Clipboard"]; } else if (process.platform === "darwin") { command = "pbpaste"; } else { // Linux fallback (might fail if tools missing) command = "xclip"; args = ["-selection", "clipboard", "-o"]; } return Promise.race([ new Promise((resolve) => { const child = spawn(command, args); let output = ""; let error = ""; child.stdout.on("data", (data) => output += data.toString()); child.stderr.on("data", (data) => error += data.toString()); child.on("close", (code) => { if (code === 0) { resolve({ content: output.trim() }); } else { resolve({ error: `Failed to read clipboard. Exit code: ${code}. Error: ${error}` }); } }); child.on("error", (err) => { resolve({ error: `Failed to spawn clipboard command: ${err.message}` }); }); }), new Promise((_, reject) => setTimeout(() => reject(new Error("Clipboard operation timeout")), 5000) ) ]).catch((err) => ({ error: err.message })); }, }); tools.push(readClipboardTool); const writeClipboardTool = tool({ name: "write_clipboard", description: "Write text content to the system clipboard.", parameters: { content: z.string(), }, implementation: async ({ content }) => { let command = ""; let args: string[] = []; let input = content; if (process.platform === "win32") { command = "powershell"; // Use base64 to avoid complex escaping issues in PowerShell const base64Content = Buffer.from(content, 'utf8').toString('base64'); // Command decodes base64 and sets clipboard args = ["-command", `$str = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('${base64Content}')); Set-Clipboard -Value $str`]; input = ""; // Input handled via args } else if (process.platform === "darwin") { command = "pbcopy"; } else { command = "xclip"; args = ["-selection", "clipboard", "-i"]; } return Promise.race([ new Promise((resolve) => { const child = spawn(command, args, { stdio: ['pipe', 'ignore', 'pipe'] }); if (input && process.platform !== "win32") { child.stdin.write(input); child.stdin.end(); } else if (process.platform === "win32") { child.stdin.end(); } let error = ""; child.stderr.on("data", (data) => error += data.toString()); child.on("close", (code) => { if (code === 0) { resolve({ success: true }); } else { resolve({ error: `Failed to write to clipboard. Exit code: ${code}. Error: ${error}` }); } }); child.on("error", (err) => { resolve({ error: `Failed to spawn clipboard command: ${err.message}` }); }); }), new Promise((_, reject) => setTimeout(() => reject(new Error("Clipboard operation timeout")), 5000) ) ]).catch((err) => ({ error: err.message })); }, }); tools.push(writeClipboardTool); const openFileTool = tool({ name: "open_file", description: "Open a file or URL in the system's default application. Use this to preview images, PDFs, or open web pages.", parameters: { target: z.string().describe("File path or URL"), }, implementation: async ({ target }) => { // Resolve path if it's a file and not a URL let targetToOpen = target; if (!target.startsWith("http://") && !target.startsWith("https://")) { targetToOpen = validatePath(currentWorkingDirectory, target); } const open = (await import("open")).default; await open(targetToOpen); return { success: true, message: `Opened ${targetToOpen}` }; } }); tools.push(openFileTool); const previewHtmlTool = tool({ name: "preview_html", description: "Render and preview HTML content in the system's default browser. Useful for visualizing code or UIs.", parameters: { html_content: z.string(), file_name: z.string().optional().describe("Optional filename (default: preview.html)") }, implementation: async ({ html_content, file_name }) => { const name = file_name || `preview_${Date.now()}.html`; const filePath = validatePath(currentWorkingDirectory, name); await writeFile(filePath, html_content, "utf-8"); // Open it const open = (await import("open")).default; await open(filePath); return { success: true, path: filePath, message: "HTML preview launched in browser." }; } }); tools.push(previewHtmlTool); const browserActionSchema = z.object({ type: z.enum(["wait_for_selector", "wait", "click", "type", "press", "select", "hover", "scroll", "evaluate"]), selector: z.string().optional().describe("CSS selector used by selector-based actions."), text: z.string().optional().describe("Text payload for type action."), value: z.string().optional().describe("Value payload for select action."), key: z.string().optional().describe("Keyboard key for press action (e.g., Enter, Tab)."), milliseconds: z.number().int().min(0).max(30000).optional().describe("Delay in milliseconds for wait action."), x: z.number().optional().describe("Horizontal scroll delta for scroll action."), y: z.number().optional().describe("Vertical scroll delta for scroll action."), script: z.string().optional().describe("JavaScript snippet for evaluate action (executed in page context)."), }); const browserSessionOpenTool = tool({ name: "browser_session_open", description: "Open a persistent browser session (single active page), navigate to URL, and return page text for context.", parameters: { url: z.string(), wait_for_selector: z.string().optional().describe("Optional selector to wait for after navigation."), include_page_text: z.boolean().optional().describe("If true (default), returns full page text content after opening."), }, implementation: createSafeToolImplementation(async ({ url, wait_for_selector, include_page_text = true }) => { try { if (browserSession) { await browserSession.browser.close().catch(() => { }); browserSession = null; } const puppeteer = await import("puppeteer"); const browser = await puppeteer.launch({ headless: true, args: ["--no-sandbox", "--disable-setuid-sandbox"], }); const page = await browser.newPage(); await page.goto(url, { waitUntil: "networkidle0", timeout: 30000 }); if (wait_for_selector) { await page.waitForSelector(wait_for_selector, { timeout: 15000 }); } browserSession = { browser, page, currentUrl: page.url(), }; const pageText = include_page_text ? await page.evaluate(() => document.body.innerText || "") : undefined; return { success: true, session_active: true, url: page.url(), title: await page.title(), text_content: pageText, text_length: pageText ? pageText.length : 0, message: "Browser session opened.", }; } catch (error) { return { error: `Failed to open browser session: ${error instanceof Error ? error.message : String(error)}` }; } }, allowBrowserControl, "browser_control"), }); tools.push(browserSessionOpenTool); const browserSessionControlTool = tool({ name: "browser_session_control", description: "Control the active persistent browser session. Supports actions, page reading, screenshot capture, and fuzzy finding in-page text/selectors.", parameters: { actions: z.array(browserActionSchema).optional().describe("Optional scripted browser actions to execute on the active page."), read_page: z.boolean().optional().describe("If true (default), returns page metadata. Full text is returned only on URL change or when full_read=true."), full_read: z.boolean().optional().describe("If true, forces full page text output even when URL has not changed."), screenshot_path: z.string().optional().describe("Optional screenshot output path."), full_page_screenshot: z.boolean().optional().describe("If true, captures full page screenshot."), fuzzy_find: z.string().optional().describe("Optional fuzzy-find query for in-page content/selectors."), max_results: z.number().int().min(1).max(20).optional().describe("Max fuzzy results to return (default: 5)."), }, implementation: createSafeToolImplementation(async ({ actions, read_page = true, full_read = false, screenshot_path, full_page_screenshot, fuzzy_find, max_results = 5 }) => { if (!browserSession) { return { error: "No active browser session. Call 'browser_session_open' first." }; } try { const beforeUrl = browserSession.page.url(); const actionLog = await executeBrowserActions(browserSession.page, actions || []); const afterUrl = browserSession.page.url(); const urlChanged = beforeUrl !== afterUrl; browserSession.currentUrl = afterUrl; let screenshotSaved = false; if (screenshot_path) { const screenshotFilePath = validatePath(currentWorkingDirectory, screenshot_path); await browserSession.page.screenshot({ path: screenshotFilePath, fullPage: full_page_screenshot ?? false }); screenshotSaved = true; } let pageSnapshot: | { url: string; title: string; text_content?: string; text_length?: number; note?: string } | undefined = undefined; if (read_page) { const title = await browserSession.page.title(); if (urlChanged || full_read) { const textContent = await browserSession.page.evaluate(() => document.body.innerText || ""); pageSnapshot = { url: afterUrl, title, text_content: textContent, text_length: textContent.length, }; } else { pageSnapshot = { url: afterUrl, title, note: "Full page text omitted (URL unchanged). Set full_read=true to force full output.", }; } } let fuzzyResults: Array<{ text: string; selector: string; score: number }> = []; if (typeof fuzzy_find === "string" && fuzzy_find.trim()) { const candidates = await browserSession.page.evaluate(() => { const dedup = new Map(); const nodes = document.querySelectorAll("a,button,input,textarea,select,[role='button'],[aria-label],h1,h2,h3,h4,h5,h6,p,span"); const clean = (value: string) => value.replace(/\s+/g, " ").trim(); const classSelector = (el: Element) => { const classes = Array.from(el.classList).slice(0, 2).map(c => c.replace(/[^a-zA-Z0-9_-]/g, "")); return classes.length > 0 ? `.${classes.join(".")}` : ""; }; const buildSelector = (el: Element) => { if ((el as HTMLElement).id) return `#${(el as HTMLElement).id}`; const name = el.getAttribute("name"); if (name) return `${el.tagName.toLowerCase()}[name="${name.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"]`; return `${el.tagName.toLowerCase()}${classSelector(el)}`; }; for (const node of nodes) { const element = node as HTMLElement; const text = clean( element.innerText || (element as HTMLInputElement).value || element.getAttribute("aria-label") || "", ); if (!text) continue; const selector = buildSelector(element); const key = `${text}||${selector}`; if (!dedup.has(key)) { dedup.set(key, { text: text.substring(0, 200), selector }); } if (dedup.size >= 400) break; } return Array.from(dedup.values()); }); const ranked = candidates .map(candidate => ({ ...candidate, score: Math.max( rankFuzzyMatches(fuzzy_find, [candidate.text], 1)[0]?.score ?? 0, rankFuzzyMatches(fuzzy_find, [candidate.selector], 1)[0]?.score ?? 0, ), })) .sort((a, b) => b.score - a.score) .slice(0, max_results); fuzzyResults = ranked.map(item => ({ text: item.text, selector: item.selector, score: item.score, })); } return { success: true, session_active: true, actions_executed: actionLog, screenshot_saved: screenshotSaved, url_changed: urlChanged, url_change_notice: urlChanged ? `Url changed to -> [${afterUrl}]` : undefined, page: pageSnapshot, fuzzy_find_results: fuzzyResults, }; } catch (error) { return { error: `Browser session control failed: ${error instanceof Error ? error.message : String(error)}` }; } }, allowBrowserControl, "browser_control"), }); tools.push(browserSessionControlTool); const browserSessionCloseTool = tool({ name: "browser_session_close", description: "Close the active persistent browser session.", parameters: {}, implementation: createSafeToolImplementation(async () => { if (!browserSession) { return { success: true, session_active: false, message: "No active browser session." }; } try { await browserSession.browser.close(); browserSession = null; return { success: true, session_active: false, message: "Browser session closed." }; } catch (error) { return { error: `Failed to close browser session: ${error instanceof Error ? error.message : String(error)}` }; } }, allowBrowserControl, "browser_control"), }); tools.push(browserSessionCloseTool); const browserOpenPageTool = tool({ name: "browser_open_page", description: "Open a webpage in a headless browser (Puppeteer), render it once, and return content. One-shot only; do not use for multi-step navigation.", parameters: { url: z.string(), screenshot_path: z.string().optional().describe("Path to save a screenshot (e.g., 'screenshot.png')."), wait_for_selector: z.string().optional().describe("CSS selector to wait for before returning."), full_page_screenshot: z.boolean().optional().describe("If true, captures the full page when taking a screenshot."), actions: z.array(browserActionSchema).optional().describe("Optional scripted browser steps to run after navigation."), }, implementation: createSafeToolImplementation(async ({ url, screenshot_path, wait_for_selector, full_page_screenshot, actions }) => { let browser; try { // Dynamically import puppeteer const puppeteer = await import("puppeteer"); browser = await puppeteer.launch({ headless: true, args: ["--no-sandbox", "--disable-setuid-sandbox"], }); const page = await browser.newPage(); try { await page.goto(url, { waitUntil: 'networkidle0', timeout: 30000 }); if (wait_for_selector) { await page.waitForSelector(wait_for_selector, { timeout: 10000 }); } const beforeActionUrl = page.url(); const action_log = await executeBrowserActions(page, actions || []); const currentUrl = page.url(); const urlChanged = currentUrl !== beforeActionUrl; const title = await page.title(); const textContent = await page.evaluate(() => document.body.innerText || ""); let screenshot_saved = false; if (screenshot_path) { const screenshotFilePath = validatePath(currentWorkingDirectory, screenshot_path); await page.screenshot({ path: screenshotFilePath, fullPage: full_page_screenshot ?? false }); screenshot_saved = true; } return { url: currentUrl, title, text_content: textContent.substring(0, 5000), screenshot_saved, actions_executed: action_log, url_changed: urlChanged, url_change_notice: urlChanged ? `Url changed to -> [${currentUrl}]` : undefined, }; } finally { await browser.close(); } } catch (error) { if (browser) { await browser.close().catch(() => { }); } return { error: `Browser operation failed: ${error instanceof Error ? error.message : String(error)}` }; } }, allowBrowserControl, "browser_control") }); tools.push(browserOpenPageTool); const runTestCommandTool = tool({ name: "run_test_command", description: "Execute a test command (like 'npm test') and return the results. Specialized for capturing test output.", parameters: { command: z.string().describe("The test command to run (e.g., 'npm test', 'pytest')."), }, implementation: async ({ command }) => { return new Promise((resolve) => { const parts = command.split(" "); const cmd = parts[0]; const args = parts.slice(1); const child = spawn(cmd, args, { cwd: getExecCwd(), shell: true, env: { ...process.env, CI: 'true' } }); let stdout = ""; let stderr = ""; child.stdout.on("data", (data) => { stdout += data.toString(); }); child.stderr.on("data", (data) => { stderr += data.toString(); }); child.on("close", (code) => { resolve({ command, exit_code: code, stdout: stdout.trim(), stderr: stderr.trim(), passed: code === 0 }); }); child.on("error", (err) => { resolve({ command, error: err.message, passed: false }); }); }); } }); tools.push(runTestCommandTool); const wikipediaSearchTool = tool({ name: "wikipedia_search", description: "Search Wikipedia for a given query and return page summaries.", parameters: { query: z.string(), lang: z.string().optional().describe("Language code (default: en)"), }, implementation: createSafeToolImplementation( async ({ query, lang = "en" }) => { try { const searchUrl = `https://${lang}.wikipedia.org/w/api.php?action=query&list=search&srsearch=${encodeURIComponent(query)}&format=json`; const searchResponse = await fetch(searchUrl); const searchData = await searchResponse.json(); if (!searchData.query || !searchData.query.search || searchData.query.search.length === 0) { return { results: "No Wikipedia articles found." }; } const results = []; for (const item of searchData.query.search.slice(0, 3)) { // Top 3 const pageUrl = `https://${lang}.wikipedia.org/w/api.php?action=query&prop=extracts&exintro&explaintext&pageids=${item.pageid}&format=json`; const pageResponse = await fetch(pageUrl); const pageData = await pageResponse.json(); const page = pageData.query.pages[item.pageid]; results.push({ title: item.title, summary: page.extract.substring(0, 2000) + (page.extract.length > 2000 ? "..." : ""), url: `https://${lang}.wikipedia.org/wiki/${encodeURIComponent(item.title.replace(/ /g, "_"))}` }); } return { results }; } catch (error) { return { error: `Wikipedia search failed: ${error instanceof Error ? error.message : String(error)}` }; } }, enableWikipedia as boolean, "wikipedia_search" ) }); tools.push(wikipediaSearchTool); const ragLocalFilesTool = tool({ name: "rag_local_files", description: "Perform RAG (Retrieval-Augmented Generation) on files in the current workspace. Use this to find code snippets or information within local files relevant to a query.", parameters: { query: z.string(), path: z.string().optional().describe("Sub-directory to limit search (default: current working directory)"), file_pattern: z.string().optional().describe("File pattern to include (e.g. '.ts', 'src/'). Default: all text files."), }, implementation: createSafeToolImplementation( async ({ query, path = ".", file_pattern = "" }) => { try { if (!client) return { error: "LM Studio Client unavailable." }; const targetDir = validatePath(currentWorkingDirectory, path); const entries = await readdir(targetDir, { recursive: true, withFileTypes: true }); // NOTE: .md files are explicitly INCLUDED — project notes / memory.md / // AGENTS.md are the highest-signal files for local RAG. Only binaries excluded. const textFiles = entries.filter(e => e.isFile() && !e.name.match(/\.(png|jpg|jpeg|gif|ico|exe|dll|bin|zip|tar|gz|mp4|mp3|avi|mov|pdf)$/i)); // Filter by pattern if provided const filteredFiles = file_pattern ? textFiles.filter(e => e.name.includes(file_pattern) || join(e.parentPath, e.name).includes(file_pattern)) : textFiles; // Limit to avoid massive reads. // In a real 'Gemini Flow' robust implementation, we'd use an index. // Here we'll read top 50 files max to be safe. const filesToScan = filteredFiles.slice(0, 50); let allChunks: { chunk: string, score: number, file: string }[] = []; const embeddingModel = await ensureEmbeddingModelLoaded(client, embeddingModelName); const [queryEmbedding] = await embeddingModel.embed([query]); for (const file of filesToScan) { try { const fullPath = join(file.parentPath, file.name); const content = await readFile(fullPath, "utf-8"); // reuse chunking logic const chunks = content.split(/\n\s*\n/).filter(c => c.trim().length > 20); if (chunks.length === 0) continue; // Batch embed chunks for this file const chunkEmbeddings = await embeddingModel.embed(chunks); chunks.forEach((chunk, i) => { const score = cosineSimilarity(queryEmbedding.embedding, chunkEmbeddings[i].embedding); if (score > 0.4) { // Threshold allChunks.push({ chunk, score, file: file.name }); } }); } catch (e) { // ignore read errors } } // Sort all chunks allChunks.sort((a, b) => b.score - a.score); return { query, results: allChunks.slice(0, 10).map(c => ({ file: c.file, score: c.score.toFixed(3), content: c.chunk })) }; } catch (error) { return { error: `Local RAG failed: ${error instanceof Error ? error.message : String(error)}` }; } }, enableLocalRag as boolean, "rag_local_files" ) }); tools.push(ragLocalFilesTool); const consultSecondaryAgentTool = tool({ name: "consult_secondary_agent", description: "Delegate a task to a secondary agent. IMPORTANT: If the task is 'coding' or 'writing files', the secondary agent will AUTOMATICALLY CREATE AND SAVE the files to the disk. You do NOT need to save them yourself. The tool returns a list of generated files. Trust this list.", parameters: { task: z.string(), agent_role: z.string().optional().describe("Key from 'Sub-Agent Profiles' config (e.g., 'coder'). Default: 'general'."), context: z.string().optional().describe("Additional context or data for the agent."), allow_tools: z.boolean().optional().describe("If true, the secondary agent can use tools like Web Search (DuckDuckGo, Wikipedia), File System (Read/List), and Code Execution (if enabled in settings). Default: false."), }, implementation: createSafeToolImplementation( async ({ task, agent_role = "general", context = "", allow_tools = false }) => { const endpoint = resolveSubAgentEndpoint(pluginConfig.get("agent.secondaryAgentEndpoint")); let modelId: string | undefined = pluginConfig.get("agent.secondaryModelId"); const useMainModel = pluginConfig.get("agent.useMainModelForSubAgent"); let handoffMessage: string | undefined = undefined; let finalResponse = ""; if (useMainModel) { modelId = undefined; // Use active model via SDK } const subAgentProfilesStr = pluginConfig.get("agent.subAgentProfiles"); const debugMode = pluginConfig.get("debug.enableDebugMode"); const subAgentDebugLogging = pluginConfig.get("debug.enableSubAgentDebugLogging"); const autoSave = pluginConfig.get("debug.subAgentAutoSave"); const showFullCode = pluginConfig.get("debug.showFullCodeOutput"); let allowFileSystem = pluginConfig.get("agent.subAgentAllowFileSystem"); let allowWeb = pluginConfig.get("agent.subAgentAllowWeb"); let allowCode = pluginConfig.get("agent.subAgentAllowCode"); let allowSubAgentBrowserControl = pluginConfig.get("agent.subAgentAllowBrowserControl"); if (unrestrictedMode) { allowFileSystem = true; allowWeb = true; allowCode = true; allowSubAgentBrowserControl = true; } if (!enableSecondary) return { error: "Secondary agent is disabled in settings." }; // Helper to run an agent loop const runAgentLoop = async ( role: string, taskPrompt: string, contextData: string, loopLimit: number = 8, forceTools: boolean = false, currentWorkingDirectory: string ) => { try { const result = await runSubAgentLoop( client, pluginConfig, role, taskPrompt, contextData, loopLimit, forceTools, currentWorkingDirectory, true // Enable tools ); // Map to the expected return shape return { response: result.response, filesModified: result.generated_files, handoff_message: result.handoff_message }; } catch (err: any) { console.error(`[Sub-Agent] runAgentLoop error: ${err.message}`); console.error(`[Sub-Agent] Stack: ${err.stack}`); return { response: "", filesModified: [], handoff_message: "", error: err.message }; } }; // --- 1. Primary Agent Loop --- const primaryResult = await runAgentLoop(agent_role, task, context, 8, false, currentWorkingDirectory); if (primaryResult.error) return { error: primaryResult.error }; finalResponse = primaryResult.response || ""; handoffMessage = primaryResult.handoff_message; const generatedFiles = [...primaryResult.filesModified]; // --- 2. Auto-Debug Loop --- if (debugMode && primaryResult.filesModified.length > 0) { const filesToCheck = primaryResult.filesModified.join(", "); const debugTask = `Review the code in these files: ${filesToCheck}. Check for bugs, syntax errors, or logic flaws. If you find any, use 'save_file' to FIX them. If they are correct, confirm it.`; // Read content of modified files to pass as context let debugContext = "Here is the content of the created files:\n"; for (const f of primaryResult.filesModified) { try { const c = await readFile(join(currentWorkingDirectory, f), "utf-8"); debugContext += `\n--- ${f} ---\n${c}\n`; } catch (e) { } } const debugResult = await runAgentLoop("reviewer", debugTask, debugContext, 5, true, currentWorkingDirectory); finalResponse += "\n\n--- Auto-Debug Report ---\n" + (debugResult.response || "Debug pass completed."); if (debugResult.filesModified.length > 0) { finalResponse += `\n(The reviewer fixed these files: ${debugResult.filesModified.join(", ")})`; } if (!handoffMessage && debugResult.handoff_message) { handoffMessage = debugResult.handoff_message; } } // Append generated file list for Main Agent visibility if (primaryResult.filesModified.length > 0) { const fullPaths = primaryResult.filesModified.map(f => { if (isAbsolute(f)) return f; return join(currentWorkingDirectory, f); }); finalResponse += `\n\n[GENERATED_FILES]: ${fullPaths.join(", ")}`; if (showFullCode) { finalResponse += `\n\n### Generated Code Content:\n`; for (const f of primaryResult.filesModified) { try { const fpath = isAbsolute(f) ? f : join(currentWorkingDirectory, f); const content = await readFile(fpath, "utf-8"); const ext = f.split('.').pop() || 'txt'; finalResponse += `\n**${f}**\n\`\`\`${ext}\n${content}\n\`\`\`\n`; } catch (e) { } } } } // Only hide code blocks when files were actually saved. // If nothing was written to disk, leave the raw response intact so the primary agent // can see what the sub-agent actually did (or didn't do) rather than being misled // by a false "code has been handled" success message. if (!showFullCode && primaryResult.filesModified.length > 0) { finalResponse = finalResponse.replace(/```[\s\S]*?```/g, "\n[System: Code Block Hidden for Brevity. The code has been handled/saved by the sub-agent. Do NOT request it again. Proceed.]\n"); } return { response: finalResponse, generated_files: generatedFiles, handoff_message: handoffMessage }; }, enableSecondary, "consult_secondary_agent" ) }); tools.push(consultSecondaryAgentTool); // --- Issue #13: Enhanced File Editing Tools --- const insertAtLineTool = tool({ name: "insert_at_line", description: text` Insert content at a specific line number in a file. The line_number is 1-indexed (line 1 is the first line). Existing content at that line and below will be pushed down. `, parameters: { file_name: z.string(), line_number: z.number().int().min(1).describe("The line number to insert at (1-indexed)"), content_to_insert: z.string().describe("The text content to insert at the specified line"), }, implementation: async ({ file_name, line_number, content_to_insert }) => { try { const filePath = validatePath(currentWorkingDirectory, file_name); let content = ""; try { content = await readFile(filePath, "utf-8"); } catch { if (line_number !== 1) { return { error: `File '${file_name}' does not exist. Can only insert at line 1 in a new file.` }; } } const lines = content.split("\n"); const insertIndex = Math.min(line_number - 1, lines.length); lines.splice(insertIndex, 0, content_to_insert); await writeFile(filePath, lines.join("\n"), "utf-8"); return { success: true, message: `Inserted ${content_to_insert.split('\n').length} line(s) at line ${line_number} in ${file_name}`, new_line_count: lines.length }; } catch (e) { return { error: `Failed to insert text: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(insertAtLineTool); const appendFileTool = tool({ name: "append_file", description: text` Append content to the end of a file. If the file doesn't exist, it will be created. Useful for adding logs, entries, or building files incrementally. `, parameters: { file_name: z.string(), content: z.string().describe("The text content to append to the file"), }, implementation: async ({ file_name, content }) => { try { const filePath = validatePath(currentWorkingDirectory, file_name); await mkdir(dirname(filePath), { recursive: true }); await appendFile(filePath, content, "utf-8"); return { success: true, message: `Content appended to ${file_name}` }; } catch (e) { return { error: `Failed to append to file: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(appendFileTool); const readFileRangeTool = tool({ name: "read_file_range", description: text` Read a specific range of lines from a file. Returns the content with line numbers for easy reference. Line numbers are 1-indexed (line 1 is the first line). `, parameters: { file_name: z.string(), start_line: z.number().int().min(1).describe("Starting line number (1-indexed)"), end_line: z.number().int().min(1).describe("Ending line number (1-indexed, inclusive)"), }, implementation: async ({ file_name, start_line, end_line }) => { try { const filePath = validatePath(currentWorkingDirectory, file_name); const content = await readFile(filePath, "utf-8"); const lines = content.split("\n"); if (start_line > lines.length) { return { error: `Start line ${start_line} is beyond the end of the file (${lines.length} lines)` }; } const actualEndLine = Math.min(end_line, lines.length); const selectedLines = lines.slice(start_line - 1, actualEndLine); const numberedContent = selectedLines.map((line, idx) => `${start_line + idx}: ${line}` ).join("\n"); return { file_name: file_name, start_line: start_line, end_line: actualEndLine, line_count: selectedLines.length, content_with_line_numbers: numberedContent, }; } catch (e) { return { error: `Failed to read file range: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(readFileRangeTool); const searchInFileTool = tool({ name: "search_in_file", description: text` Search for a pattern within a single file (grep-like functionality). Returns matching lines with their line numbers. The pattern can be a simple substring or a regex pattern. `, parameters: { file_name: z.string(), pattern: z.string().describe("Search pattern (substring or regex)"), case_sensitive: z.boolean().optional().default(false).describe("Whether the search is case-sensitive (default: false)"), use_regex: z.boolean().optional().default(false).describe("Whether to treat pattern as a regex (default: false, treats as literal substring)"), }, implementation: async ({ file_name, pattern, case_sensitive = false, use_regex = false }) => { try { const filePath = validatePath(currentWorkingDirectory, file_name); const content = await readFile(filePath, "utf-8"); const lines = content.split("\n"); let matches: Array<{ line_number: number; content: string }> = []; for (let i = 0; i < lines.length; i++) { let line = lines[i]; let searchPattern = pattern; if (!case_sensitive) { line = line.toLowerCase(); searchPattern = pattern.toLowerCase(); } let isMatch = false; if (use_regex) { try { const regex = new RegExp(searchPattern); isMatch = regex.test(line); } catch (e) { return { error: `Invalid regex pattern: ${e instanceof Error ? e.message : String(e)}` }; } } else { isMatch = line.includes(searchPattern); } if (isMatch) { matches.push({ line_number: i + 1, content: lines[i], }); } } return { file_name: file_name, pattern: pattern, match_count: matches.length, matches: matches.slice(0, 100), note: matches.length > 100 ? `Showing first 100 of ${matches.length} matches` : undefined, }; } catch (e) { return { error: `Failed to search file: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(searchInFileTool); const deleteLinesInFileTool = tool({ name: "delete_lines_in_file", description: text` Delete a specific line or range of lines from a file. Line numbers are 1-indexed (line 1 is the first line). If end_line is omitted, only start_line will be deleted. `, parameters: { file_name: z.string(), start_line: z.number().int().min(1).describe("The starting line number to delete (1-indexed)"), end_line: z.number().int().min(1).optional().describe("Optional: The ending line number to delete (inclusive). If omitted, only deletes start_line."), }, implementation: async ({ file_name, start_line, end_line }) => { try { const filePath = validatePath(currentWorkingDirectory, file_name); let content = ""; try { content = await readFile(filePath, "utf-8"); } catch { return { error: `File '${file_name}' does not exist.` }; } const lines = content.split("\n"); const actualEndLine = end_line ?? start_line; if (start_line > lines.length) { return { error: `Start line ${start_line} is beyond the end of the file (${lines.length} lines)` }; } const deleteCount = Math.min(actualEndLine - start_line + 1, lines.length - start_line + 1); if (deleteCount <= 0) { return { error: `Invalid line range. End line must be >= Start line.` }; } lines.splice(start_line - 1, deleteCount); await writeFile(filePath, lines.join("\n"), "utf-8"); return { success: true, message: `Deleted ${deleteCount} line(s) (lines ${start_line}-${actualEndLine}) from ${file_name}`, new_line_count: lines.length }; } catch (e) { return { error: `Failed to delete lines: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(deleteLinesInFileTool); if (allowGitHubTools) { // --- GitHub CLI (gh) Tools --- const checkGhInstalled = async (): Promise => { try { const cmd = process.platform === 'win32' ? 'where gh' : 'which gh'; const child = spawn(cmd, [], { shell: true }); await new Promise((resolve) => child.on('close', resolve)); return true; } catch (e) { return "GitHub CLI ('gh') is not installed. Please ask the user to install it from https://cli.github.com/"; } }; const ghAuthTool = tool({ name: "gh_auth", description: "Check GitHub authentication status. If not authenticated, opens a terminal window for the user to sign in.", parameters: {}, implementation: async () => { const isInstalled = await checkGhInstalled(); if (typeof isInstalled === 'string') return { error: isInstalled }; try { // Check status first const statusChild = spawn("gh auth status", [], { shell: true }); let stderr = ""; statusChild.stderr.on("data", d => stderr += d); await new Promise((resolve) => statusChild.on('close', resolve)); if (statusChild.exitCode === 0) { return { success: true, message: "Already authenticated with GitHub." }; } else { // Open terminal for login const escapedDir = currentWorkingDirectory.replace(/"/g, '""'); const shellCommand = `start "" /D "${escapedDir}" cmd.exe /k "gh auth login --git-protocol=https & exit"`; spawn("cmd.exe", ["/c", shellCommand], { detached: true, stdio: "ignore" }); return { success: true, message: "Opened a terminal window for GitHub authentication. Please sign in there." }; } } catch (e) { return { error: `Auth check failed: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(ghAuthTool); const ghCreateIssueTool = tool({ name: "gh_create_issue", description: "Create a new GitHub issue in the current repository.", parameters: { title: z.string(), body: z.string().optional(), labels: z.array(z.string()).optional(), }, implementation: async ({ title, body, labels }) => { const isInstalled = await checkGhInstalled(); if (typeof isInstalled === 'string') return { error: isInstalled }; try { let tempFilePath = ""; const ghArgs = ["issue", "create", "--title", title]; if (body) { tempFilePath = join(currentWorkingDirectory, `gh_issue_body_${Date.now()}.md`); await writeFile(tempFilePath, body, "utf-8"); ghArgs.push("--body-file", tempFilePath); } if (labels) { for (const label of labels) { ghArgs.push("-l", label); } } const child = spawn("gh", ghArgs); let stdout = "", stderr = ""; child.stdout.on("data", d => stdout += d); child.stderr.on("data", d => stderr += d); await new Promise((resolve) => child.on('close', resolve)); if (tempFilePath) await rm(tempFilePath, { force: true }); if (child.exitCode === 0) return { success: true, url: stdout.trim() }; return { error: `Failed to create issue: ${stderr}` }; } catch (e) { return { error: `Create issue failed: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(ghCreateIssueTool); const ghListIssuesTool = tool({ name: "gh_list_issues", description: "List issues in the current repository.", parameters: { state: z.enum(["open", "closed"]).optional().default("open"), labels: z.array(z.string()).optional(), limit: z.number().min(1).max(50).optional().default(10), }, implementation: async ({ state, labels, limit }) => { const isInstalled = await checkGhInstalled(); if (typeof isInstalled === 'string') return { error: isInstalled }; try { const ghArgs = ["issue", "list", "--state", state, "--limit", String(limit), "--json", "number,title,state,url,labels"]; if (labels) { for (const label of labels) { ghArgs.push("-l", label); } } const child = spawn("gh", ghArgs); let stdout = "", stderr = ""; child.stdout.on("data", d => stdout += d); child.stderr.on("data", d => stderr += d); await new Promise((resolve) => child.on('close', resolve)); if (child.exitCode === 0) { try { return { issues: JSON.parse(stdout) }; } catch { return { error: "Failed to parse issue list output" }; } } return { error: `List issues failed: ${stderr}` }; } catch (e) { return { error: `List issues failed: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(ghListIssuesTool); const ghViewCommentsTool = tool({ name: "gh_view_comments", description: "View comments on a specific issue or pull request.", parameters: { number: z.number().describe("The issue or PR number"), type: z.enum(["issue", "pr"]).default("issue").describe("Whether it's an issue or a pull request"), }, implementation: async ({ number, type }) => { const isInstalled = await checkGhInstalled(); if (typeof isInstalled === 'string') return { error: isInstalled }; try { // Fallback to standard gh command for reliable JSON parsing of comments const ghArgs = type === "issue" ? ["issue", "view", String(number), "--json", "comments"] : ["pr", "view", String(number), "--json", "comments"]; const child = spawn("gh", ghArgs); let stdout = "", stderr = ""; child.stdout.on("data", d => stdout += d); child.stderr.on("data", d => stderr += d); await new Promise((resolve) => child.on('close', resolve)); if (child.exitCode === 0) { try { const data = JSON.parse(stdout); return { comments: data.comments || [] }; } catch { return { raw_output: stdout }; } } return { error: `View comments failed: ${stderr}` }; } catch (e) { return { error: `View comments failed: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(ghViewCommentsTool); const ghCreatePrTool = tool({ name: "gh_create_pr", description: "Create a new pull request in the current repository.", parameters: { title: z.string(), body: z.string().optional(), head_branch: z.string().describe("The branch containing your changes"), base_branch: z.string().default("main").describe("The branch you want to merge into (e.g., main, master)"), }, implementation: async ({ title, body, head_branch, base_branch }) => { const isInstalled = await checkGhInstalled(); if (typeof isInstalled === 'string') return { error: isInstalled }; try { let tempFilePath = ""; const ghArgs = ["pr", "create", "--title", title, "--head", head_branch, "--base", base_branch]; if (body) { tempFilePath = join(currentWorkingDirectory, `gh_pr_body_${Date.now()}.md`); await writeFile(tempFilePath, body, "utf-8"); ghArgs.push("--body-file", tempFilePath); } const child = spawn("gh", ghArgs); let stdout = "", stderr = ""; child.stdout.on("data", d => stdout += d); child.stderr.on("data", d => stderr += d); await new Promise((resolve) => child.on('close', resolve)); if (tempFilePath) await rm(tempFilePath, { force: true }); if (child.exitCode === 0) return { success: true, url: stdout.trim() }; return { error: `Failed to create PR: ${stderr}` }; } catch (e) { return { error: `Create PR failed: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(ghCreatePrTool); const ghListPrsTool = tool({ name: "gh_list_prs", description: "List pull requests in the current repository.", parameters: { state: z.enum(["open", "closed"]).optional().default("open"), limit: z.number().min(1).max(50).optional().default(10), }, implementation: async ({ state, limit }) => { const isInstalled = await checkGhInstalled(); if (typeof isInstalled === 'string') return { error: isInstalled }; try { const ghArgs = ["pr", "list", "--state", state, "--limit", String(limit), "--json", "number,title,state,url,headRefName,baseRefName"]; const child = spawn("gh", ghArgs); let stdout = "", stderr = ""; child.stdout.on("data", d => stdout += d); child.stderr.on("data", d => stderr += d); await new Promise((resolve) => child.on('close', resolve)); if (child.exitCode === 0) { try { return { pull_requests: JSON.parse(stdout) }; } catch { return { error: "Failed to parse PR list output" }; } } return { error: `List PRs failed: ${stderr}` }; } catch (e) { return { error: `List PRs failed: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(ghListPrsTool); const ghViewPrDiffTool = tool({ name: "gh_view_pr_diff", description: "Fetch the diff/patch of a specific pull request.", parameters: { number: z.number().describe("The PR number"), }, implementation: async ({ number }) => { const isInstalled = await checkGhInstalled(); if (typeof isInstalled === 'string') return { error: isInstalled }; try { const ghArgs = ["pr", "diff", String(number)]; const child = spawn("gh", ghArgs); let stdout = "", stderr = ""; child.stdout.on("data", d => stdout += d); child.stderr.on("data", d => stderr += d); await new Promise((resolve) => child.on('close', resolve)); if (child.exitCode === 0) { return { diff: stdout.substring(0, 50000) + (stdout.length > 50000 ? "\n... (truncated)" : "") }; } return { error: `Fetch PR diff failed: ${stderr}` }; } catch (e) { return { error: `Fetch PR diff failed: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(ghViewPrDiffTool); const ghPushTool = tool({ name: "gh_push", description: "Push local commits to the remote GitHub repository.", parameters: { branch: z.string().optional().describe("Optional: The branch to push. Defaults to current branch."), }, implementation: async ({ branch }) => { const isInstalled = await checkGhInstalled(); if (typeof isInstalled === 'string') return { error: isInstalled }; try { const gitArgs = ["push", "origin"]; if (branch) gitArgs.push(branch); const child = spawn("git", gitArgs); let stdout = "", stderr = ""; child.stdout.on("data", d => stdout += d); child.stderr.on("data", d => stderr += d); await new Promise((resolve) => child.on('close', resolve)); if (child.exitCode === 0) return { success: true, message: "Pushed successfully." }; return { error: `Git push failed: ${stderr}` }; } catch (e) { return { error: `Git push failed: ${e instanceof Error ? e.message : String(e)}` }; } }, }); tools.push(ghPushTool); } // End of if (allowGitHubTools) // --- Neo4j graph tools --- const neo4jQueryTool = tool({ name: "neo4j_query", description: "Execute Cypher on Neo4j using plugin neo4j.* settings (connection_string optional override). Prefer single statements; for large multi-statement scripts use neo4j_run_cypher_file with a workspace path.", parameters: { connection_string: z.string().optional(), cypher: z.string(), params: z.record(z.any()).optional() }, implementation: async (p) => { const c = resolveNeo4jConnection(p.connection_string); return neo4jTools.neo4j_query(c.connection_string, p.cypher, p.params, c.username, c.password); } }); tools.push(neo4jQueryTool); const neo4jCreateNodeTool = tool({ name: "neo4j_create_node", description: "Create a node with labels and properties in Neo4j.", parameters: { connection_string: z.string().optional(), labels: z.array(z.string()), properties: z.record(z.any()) }, implementation: async (p) => { const c = resolveNeo4jConnection(p.connection_string); return neo4jTools.neo4j_create_node(c.connection_string, p.labels, p.properties, c.username, c.password); } }); tools.push(neo4jCreateNodeTool); const neo4jDeleteNodeTool = tool({ name: "neo4j_delete_node", description: "Delete a node and its relationships in Neo4j.", parameters: { connection_string: z.string().optional(), node_id: z.string() }, implementation: async (p) => { const c = resolveNeo4jConnection(p.connection_string); return neo4jTools.neo4j_delete_node(c.connection_string, p.node_id, c.username, c.password); } }); tools.push(neo4jDeleteNodeTool); const neo4jUpdateNodeTool = tool({ name: "neo4j_update_node", description: "Update properties on a Neo4j node.", parameters: { connection_string: z.string().optional(), node_id: z.string(), properties: z.record(z.any()) }, implementation: async (p) => { const c = resolveNeo4jConnection(p.connection_string); return neo4jTools.neo4j_update_node(c.connection_string, p.node_id, p.properties, c.username, c.password); } }); tools.push(neo4jUpdateNodeTool); const neo4jCreateRelTool = tool({ name: "neo4j_create_relationship", description: "Create a relationship between two nodes in Neo4j.", parameters: { connection_string: z.string().optional(), from_node_id: z.string(), to_node_id: z.string(), type: z.string(), properties: z.record(z.any()).optional() }, implementation: async (p) => { const c = resolveNeo4jConnection(p.connection_string); return neo4jTools.neo4j_create_relationship(c.connection_string, p.from_node_id, p.to_node_id, p.type, p.properties, c.username, c.password); } }); tools.push(neo4jCreateRelTool); const neo4jDeleteRelTool = tool({ name: "neo4j_delete_relationship", description: "Delete a specific relationship in Neo4j.", parameters: { connection_string: z.string().optional(), relationship_id: z.string() }, implementation: async (p) => { const c = resolveNeo4jConnection(p.connection_string); return neo4jTools.neo4j_delete_relationship(c.connection_string, p.relationship_id, c.username, c.password); } }); tools.push(neo4jDeleteRelTool); const neo4jPathFindTool = tool({ name: "neo4j_path_find", description: "Find shortest path between two nodes in Neo4j.", parameters: { connection_string: z.string().optional(), start_node_id: z.string(), end_node_id: z.string(), max_depth: z.number().int().min(1).max(20).optional() }, implementation: async (p) => { const c = resolveNeo4jConnection(p.connection_string); return neo4jTools.neo4j_path_find(c.connection_string, p.start_node_id, p.end_node_id, p.max_depth, c.username, c.password); } }); tools.push(neo4jPathFindTool); const neo4jGraphAnalysisTool = tool({ name: "neo4j_graph_analysis", description: "Get connected subgraph around a node in Neo4j.", parameters: { connection_string: z.string().optional(), node_id: z.string(), depth: z.number().int().min(1).max(10).optional() }, implementation: async (p) => { const c = resolveNeo4jConnection(p.connection_string); return neo4jTools.neo4j_graph_analysis(c.connection_string, p.node_id, p.depth, c.username, c.password); } }); tools.push(neo4jGraphAnalysisTool); const neo4jTestConnectionTool = tool({ name: "neo4j_test_connection", description: "Verify Neo4j connectivity using plugin settings (or optional connection_string override).", parameters: { connection_string: z.string().optional() }, implementation: async (p) => { const c = resolveNeo4jConnection(p.connection_string); return neo4jTools.neo4j_test_connection(c.connection_string, c.username, c.password); }, }); tools.push(neo4jTestConnectionTool); const neo4jRunScriptTool = tool({ name: "neo4j_run_script", description: "Run a multi-statement Cypher script (statements separated by semicolons). Better for bulk MERGE scripts than neo4j_query.", parameters: { connection_string: z.string().optional(), cypher: z.string().min(1), stop_on_error: z.boolean().optional(), }, implementation: async (p) => { const c = resolveNeo4jConnection(p.connection_string); return neo4jTools.neo4j_run_script(c.connection_string, p.cypher, c.username, c.password, p.stop_on_error !== false); }, }); tools.push(neo4jRunScriptTool); const neo4jRunCypherFileTool = tool({ name: "neo4j_run_cypher_file", description: "Load and run a .cypher file from the workspace (multi-statement bulk load). Prefer this over pasting large Cypher into neo4j_query.", parameters: { connection_string: z.string().optional(), file_path: z.string().min(1), stop_on_error: z.boolean().optional(), }, implementation: async (p) => { const c = resolveNeo4jConnection(p.connection_string); const abs = validatePath(currentWorkingDirectory, p.file_path); const content = await readFile(abs, "utf-8"); return neo4jTools.neo4j_run_script(c.connection_string, content, c.username, c.password, p.stop_on_error !== false); }, }); tools.push(neo4jRunCypherFileTool); // --- Feed Tools (3 tools) --- const rssFetchTool = tool({ name: "rss_fetch", description: "Fetch and parse an RSS/Atom feed.", parameters: { url: z.string().url() }, implementation: async (p) => feedTools.rss_fetch(p.url) }); tools.push(rssFetchTool); const atomParseTool = tool({ name: "atom_parse", description: "Parse Atom XML content directly.", parameters: { xml_content: z.string().min(1) }, implementation: async (p) => feedTools.atom_parse(p.xml_content) }); tools.push(atomParseTool); const feedMonitorCheckTool = tool({ name: "feed_monitor_check", description: "Check if a feed has been updated since last check.", parameters: { feed_url: z.string().url(), last_etag: z.string().optional() }, implementation: async (p) => feedTools.feed_monitor_check(p.feed_url, p.last_etag) }); tools.push(feedMonitorCheckTool); // --- Image Tools (5 tools) --- const imageResizeTool = tool({ name: "image_resize", description: "Resize an image file.", parameters: { file_path: z.string(), width: z.number().optional(), height: z.number().optional() }, implementation: async (p) => imageTools.image_resize(p.file_path, p.width, p.height, workspaceRoot) }); tools.push(imageResizeTool); const imageConvertFormatTool = tool({ name: "image_convert_format", description: "Convert an image to a different format.", parameters: { input_path: z.string(), output_path: z.string(), format: z.enum(["jpg", "png", "jpeg", "webp", "tiff", "bmp", "gif"]) }, implementation: async (p) => imageTools.image_convert_format(p.input_path, p.output_path, p.format as any, workspaceRoot) }); tools.push(imageConvertFormatTool); const imageExtractMetadataTool = tool({ name: "image_extract_metadata", description: "Extract EXIF/IPTC/XMP metadata from an image.", parameters: { file_path: z.string() }, implementation: async (p) => imageTools.image_extract_metadata(p.file_path, workspaceRoot) }); tools.push(imageExtractMetadataTool); const imageCreateThumbnailTool = tool({ name: "image_create_thumbnail", description: "Create a thumbnail from an image.", parameters: { input_path: z.string(), size: z.number(), output_path: z.string() }, implementation: async (p) => imageTools.image_create_thumbnail(p.input_path, p.size, p.output_path, workspaceRoot) }); tools.push(imageCreateThumbnailTool); const pdfMergePagesTool = tool({ name: "pdf_merge_pages", description: "Merge multiple PDF files into one.", parameters: { pdf_paths: z.array(z.string()), output_path: z.string() }, implementation: async (p) => imageTools.pdf_merge_pages(p.pdf_paths, p.output_path, workspaceRoot) }); tools.push(pdfMergePagesTool); // --- Media Tools (4 tools) --- const videoTranscodeTool = tool({ name: "video_transcode", description: "Transcode a video file.", parameters: { input_path: z.string(), output_path: z.string(), preset: z.enum(["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow"]).optional() }, implementation: async (p) => mediaTools.video_transcode(p.input_path, p.output_path, p.preset, workspaceRoot) }); tools.push(videoTranscodeTool); const audioExtractTool = tool({ name: "audio_extract", description: "Extract audio from a video file.", parameters: { video_path: z.string(), output_format: z.enum(["mp3", "wav", "aac", "flac", "ogg"]) }, implementation: async (p) => mediaTools.audio_extract(p.video_path, p.output_format, workspaceRoot) }); tools.push(audioExtractTool); const mediaInfoGetTool = tool({ name: "media_info_get", description: "Get media information about a file.", parameters: { file_path: z.string() }, implementation: async (p) => mediaTools.media_info_get(p.file_path, workspaceRoot) }); tools.push(mediaInfoGetTool); const gifAnimateFromVideoTool = tool({ name: "gif_animate_from_video", description: "Create an animated GIF from a video.", parameters: { input_path: z.string(), frames: z.number().optional(), fps: z.number().optional() }, implementation: async (p) => mediaTools.gif_animate_from_video(p.input_path, p.frames, p.fps, workspaceRoot) }); tools.push(gifAnimateFromVideoTool); // --- Archive Tools (5 tools) --- const zipCreateTool = tool({ name: "zip_create", description: "Create a ZIP archive.", parameters: { files: z.array(z.string()), output_path: z.string() }, implementation: async (p) => archiveTools.zip_create({ files: p.files, output_path: p.output_path }, workspaceRoot) }); tools.push(zipCreateTool); const zipExtractTool = tool({ name: "zip_extract", description: "Extract a ZIP archive.", parameters: { archive_path: z.string(), dest_dir: z.string() }, implementation: async (p) => archiveTools.zip_extract({ archive_path: p.archive_path, dest_dir: p.dest_dir }, workspaceRoot) }); tools.push(zipExtractTool); const tarCreateTool = tool({ name: "tar_create", description: "Create a TAR archive.", parameters: { files: z.array(z.string()), output_path: z.string(), format: z.enum(["tar", "gz", "bz2", "xz"]).optional() }, implementation: async (p) => archiveTools.tar_create({ files: p.files, output_path: p.output_path, format: p.format }, workspaceRoot) }); tools.push(tarCreateTool); const tarExtractTool = tool({ name: "tar_extract", description: "Extract a TAR archive.", parameters: { archive_path: z.string(), dest_dir: z.string() }, implementation: async (p) => archiveTools.tar_extract({ archive_path: p.archive_path, dest_dir: p.dest_dir }, workspaceRoot) }); tools.push(tarExtractTool); const archiveListContentsTool = tool({ name: "archive_list_contents", description: "List contents of an archive without extracting.", parameters: { path: z.string() }, implementation: async (p) => archiveTools.archive_list_contents({ path: p.path }, workspaceRoot) }); tools.push(archiveListContentsTool); // --- Data Format Tools (8 tools) --- const csvToJsonStreamTool = tool({ name: "csv_to_json_stream", description: "Convert CSV content to JSON.", parameters: { csv_content: z.string().min(1) }, implementation: async (p) => dataTools.csv_to_json_stream(p.csv_content) }); tools.push(csvToJsonStreamTool); const jsonToCsvConvertTool = tool({ name: "json_to_csv_convert", description: "Convert JSON data to CSV string.", parameters: { json_data: z.any(), options: z.object({ headers: z.array(z.string()).optional(), delimiter: z.string().optional() }).optional() }, implementation: async (p) => dataTools.json_to_csv_convert(p.json_data, p.options) }); tools.push(jsonToCsvConvertTool); const csvValidateSchemaTool = tool({ name: "csv_validate_schema", description: "Validate CSV against a schema.", parameters: { file_path: z.string(), schema: z.any() }, implementation: async (p) => dataTools.csv_validate_schema(p.file_path, p.schema, workspaceRoot) }); tools.push(csvValidateSchemaTool); const csvMergeFilesTool = tool({ name: "csv_merge_files", description: "Merge multiple CSV files by header matching.", parameters: { files: z.array(z.string()), output_path: z.string() }, implementation: async (p) => dataTools.csv_merge_files(p.files, p.output_path, workspaceRoot) }); tools.push(csvMergeFilesTool); const yamlParseFileTool = tool({ name: "yaml_parse_file", description: "Parse a YAML file.", parameters: { path: z.string().min(1) }, implementation: async (p) => dataTools.yaml_parse_file(p.path, workspaceRoot) }); tools.push(yamlParseFileTool); const yamlGenerateFileTool = tool({ name: "yaml_generate_file", description: "Generate a YAML file from data.", parameters: { data: z.any(), path: z.string().min(1) }, implementation: async (p) => dataTools.yaml_generate_file(p.data, p.path, workspaceRoot) }); tools.push(yamlGenerateFileTool); const configDiffYamlTool = tool({ name: "config_diff_yaml", description: "Deep diff two YAML files.", parameters: { file1: z.string().min(1), file2: z.string().min(1) }, implementation: async (p) => dataTools.config_diff_yaml(p.file1, p.file2, workspaceRoot) }); tools.push(configDiffYamlTool); const yamlToJsonTool = tool({ name: "yaml_to_json", description: "Convert YAML content to JSON string.", parameters: { yaml_content: z.string() }, implementation: async (p) => dataTools.yaml_to_json(p.yaml_content) }); tools.push(yamlToJsonTool); // --- Automation Tools (5 tools) --- const cronScheduleTool = tool({ name: "cron_schedule", description: "Schedule a recurring cron job.", parameters: { cron_expr: z.string().min(1), command: z.string().min(1) }, implementation: createSafeToolImplementation((p) => automationTools.cron_schedule(p.cron_expr, p.command, workspaceRoot), allowShell, "cron_schedule") }); tools.push(cronScheduleTool); const cronListTool = tool({ name: "cron_list", description: "List all active cron jobs.", parameters: {}, implementation: async () => automationTools.cron_list() }); tools.push(cronListTool); const cronDeleteTool = tool({ name: "cron_delete", description: "Delete a scheduled cron job.", parameters: { job_id: z.string() }, implementation: async (p) => automationTools.cron_delete(p.job_id, workspaceRoot) }); tools.push(cronDeleteTool); const taskQueueAddTool = tool({ name: "task_queue_add", description: "Add a task to the priority queue.", parameters: { task_name: z.string().min(1), priority: z.number().int().min(0).max(100).optional() }, implementation: async (p) => automationTools.task_queue_add(p.task_name, p.priority) }); tools.push(taskQueueAddTool); // --- Time Tools (8 tools) --- const timerStartTool = tool({ name: "timer_start", description: "Start a timer.", parameters: { label: z.string().optional() }, implementation: async (p) => timeTools.timer_start(p.label) }); tools.push(timerStartTool); const timerStopTool = tool({ name: "timer_stop", description: "Stop a timer and get elapsed time.", parameters: { timer_id: z.string() }, implementation: async (p) => timeTools.timer_stop(p.timer_id) }); tools.push(timerStopTool); const timerStatusTool = tool({ name: "timer_status", description: "Get status of all active timers.", parameters: {}, implementation: async () => timeTools.timer_status() }); tools.push(timerStatusTool); const timeLogCreateTool = tool({ name: "time_log_create", description: "Create a time log entry.", parameters: { project: z.string().min(1), description: z.string().min(1).optional() }, implementation: async (p) => timeTools.time_log_create(p.project, p.description) }); tools.push(timeLogCreateTool); const timeLogEntryTool = tool({ name: "time_log_entry", description: "Add duration to a time log entry.", parameters: { log_id: z.string(), minutes: z.number().int().positive() }, implementation: async (p) => timeTools.time_log_entry(p.log_id, p.minutes) }); tools.push(timeLogEntryTool); const timeLogReportTool = tool({ name: "time_log_report", description: "Generate a time report.", parameters: { start_date: z.string().optional(), end_date: z.string().optional() }, implementation: async (p) => timeTools.time_log_report(p.start_date, p.end_date) }); tools.push(timeLogReportTool); const calendarAddEventTool = tool({ name: "calendar_add_event", description: "Add a calendar event.", parameters: { title: z.string(), start: z.string(), end: z.string() }, implementation: async (p) => timeTools.calendar_add_event(p.title, p.start, p.end) }); tools.push(calendarAddEventTool); const reminderSetTool = tool({ name: "reminder_set", description: "Set a notification reminder.", parameters: { message: z.string(), delay_minutes: z.number() }, implementation: async (p) => timeTools.reminder_set(p.message, p.delay_minutes) }); tools.push(reminderSetTool); // --- Utility Tools (6 tools) --- const jsonMergeTool = tool({ name: "json_merge", description: "Merge multiple JSON files into one object.", parameters: { files: z.array(z.string()), output_path: z.string().optional() }, implementation: async (p) => utilityTools.json_merge(p.files, p.output_path) }); tools.push(jsonMergeTool); const regexTestTool = tool({ name: "regex_test", description: "Test a regex pattern against text.", parameters: { pattern: z.string().min(1), text: z.string().min(1), flags: z.string().optional() }, implementation: async (p) => utilityTools.regex_test(p.pattern, p.text, p.flags) }); tools.push(regexTestTool); const urlBuildTool = tool({ name: "url_build", description: "Build a URL with query parameters.", parameters: { base_url: z.string().url(), params: z.record(z.union([z.string(), z.number(), z.boolean()])) }, implementation: async (p) => utilityTools.url_build(p.base_url, p.params) }); tools.push(urlBuildTool); const hashGenerateTool = tool({ name: "hash_generate", description: "Generate a hash of content.", parameters: { content: z.union([z.string(), z.instanceof(Buffer)]), algorithm: z.enum(["md5", "sha1", "sha256", "sha512"]).optional() }, implementation: async (p) => utilityTools.hash_generate(p.content, p.algorithm) }); tools.push(hashGenerateTool); const uuidGenerateTool = tool({ name: "uuid_generate", description: "Generate a UUID.", parameters: {}, implementation: async () => utilityTools.uuid_generate() }); tools.push(uuidGenerateTool); const uuidValidateTool = tool({ name: "uuid_validate", description: "Validate a UUID format.", parameters: { id: z.string() }, implementation: async (p) => utilityTools.uuid_validate(p.id) }); tools.push(uuidValidateTool); // --- Agent Management Tools (6 tools) --- const agentCreateTool = tool({ name: "agent_create", description: "Create a new sub-agent with universal tool access.", parameters: { name: z.string().min(1), role: z.enum(["coder", "reviewer", "researcher", "general", "custom"]), tools_enabled: z.array(z.string()).optional(), config: z.record(z.any()).optional() }, implementation: async (p) => agentTools.agent_create(p.name, p.role, p.tools_enabled, p.config) }); tools.push(agentCreateTool); const agentUpdateTool = tool({ name: "agent_update", description: "Update an existing sub-agent.", parameters: { agent_id: z.string(), status: z.enum(["active", "paused", "completed", "failed"]).optional(), tools_enabled: z.array(z.string()).optional() }, implementation: async (p) => agentTools.agent_update(p.agent_id, p.status, p.tools_enabled) }); tools.push(agentUpdateTool); const agentDeleteTool = tool({ name: "agent_delete", description: "Delete a sub-agent.", parameters: { agent_id: z.string() }, implementation: async (p) => agentTools.agent_delete(p.agent_id) }); tools.push(agentDeleteTool); const agentAssignTaskTool = tool({ name: "agent_assign_task", description: "Assign a task to an agent.", parameters: { agent_id: z.string(), task: z.string().min(1), priority: z.number().int().min(0).max(100).optional() }, implementation: async (p) => agentTools.agent_assign_task(p.agent_id, p.task, p.priority) }); tools.push(agentAssignTaskTool); const agentStatusTool = tool({ name: "agent_status", description: "Get status of all agents.", parameters: {}, implementation: async () => agentTools.agent_status() }); tools.push(agentStatusTool); const agentTaskQueueStatusTool = tool({ name: "agent_task_queue_status", description: "Get task queue status.", parameters: {}, implementation: async () => agentTools.agent_task_queue_status() }); tools.push(agentTaskQueueStatusTool); // --- Cache Tools (5 tools) --- const cachedRagQueryTool = tool({ name: "cached_rag_query", description: "Execute RAG query with caching.", parameters: { query: z.string(), workspace_path: z.string() }, implementation: async (p) => cacheTools.cachedRagQuery(p.query, p.workspace_path) }); tools.push(cachedRagQueryTool); const cachedWebFetchTool = tool({ name: "cached_web_fetch", description: "Fetch URL with response caching.", parameters: { url: z.string().url() }, implementation: async (p) => cacheTools.cachedWebFetch(p.url) }); tools.push(cachedWebFetchTool); const cachedFileReadTool = tool({ name: "cached_file_read", description: "Read file with content caching.", parameters: { file_path: z.string() }, implementation: async (p) => cacheTools.cachedFileRead(p.file_path) }); tools.push(cachedFileReadTool); const clearCacheTool = tool({ name: "clear_all_caches", description: "Clear all plugin caches.", parameters: {}, implementation: async () => cacheTools.clearAllCaches() }); tools.push(clearCacheTool); const getCacheStatsTool = tool({ name: "get_cache_stats", description: "Get cache hit/miss statistics.", parameters: {}, implementation: async () => cacheTools.getCacheStats() }); tools.push(getCacheStatsTool); // --- Config Tools (4 tools) --- const configExportTool = tool({ name: "config_export", description: "Export plugin configuration to JSON file.", parameters: { output_path: z.string().optional() }, implementation: async (p) => configTools.configExport(p.output_path, workspaceRoot) }); tools.push(configExportTool); const configImportTool = tool({ name: "config_import", description: "Import plugin configuration from JSON file.", parameters: { input_path: z.string(), merge: z.boolean().optional() }, implementation: async (p) => configTools.configImport(p.input_path, p.merge, workspaceRoot) }); tools.push(configImportTool); const configBackupTool = tool({ name: "config_backup", description: "Create timestamped backup of current configuration.", parameters: {}, implementation: async () => configTools.configBackup(workspaceRoot) }); tools.push(configBackupTool); const configRestoreTool = tool({ name: "config_restore", description: "Restore plugin configuration from backup file.", parameters: { backup_path: z.string() }, implementation: async (p) => configTools.configRestore(p.backup_path, workspaceRoot) }); tools.push(configRestoreTool); // --- State Query Tool --- const stateQueryTool = tool({ name: "state_query", description: text` Query current plugin state. Available queries: - "tools": List all available tools and their enabled/disabled status - "cache": Show cache hit/miss statistics - "agents": List active sub-agents and their statuses - "background": List running background commands - "memory": Show memory file status, entry count, and compression state - "context": Show context entries and compression status `, parameters: { query: z.enum(["tools", "cache", "agents", "background", "memory", "context"]) }, implementation: async (p) => { if (p.query === "memory") { const memSync = await syncMemoryState(currentWorkingDirectory); return { query: "memory", memory_file: join(currentWorkingDirectory, "memory.md"), entries_count: memSync.entriesCount, synced: memSync.synced, message_count: fullState.messageCount, compression_threshold: 50, dont_ask_to_compress: fullState.dontAskToCompress, memory_enabled: enableMemory, }; } if (p.query === "context") { const contextEntries = await contextManager.context_get(); return { query: "context", entries_count: Array.isArray(contextEntries) ? contextEntries.length : 0, message_count: fullState.messageCount, compression_threshold: 50, needs_compression: shouldCompressContext(fullState), dont_ask_to_compress: fullState.dontAskToCompress, }; } return require('./stateRegistry').queryState(p.query); }, }); tools.push(stateQueryTool); // --- Agent Chaining Tools --- const delegateToAgentTool = tool({ name: "delegate_to_agent", description: "Delegate a task from one sub-agent to another (nested delegation).", parameters: { parent_task_id: z.string(), task: z.string().min(1), priority: z.number().int().min(0).max(100).optional(), tools_enabled: z.array(z.string()).optional() }, implementation: async (p) => agentTools.delegate_to_agent(p.parent_task_id, p.task, p.priority, p.tools_enabled) }); tools.push(delegateToAgentTool); const getDelegationChainTool = tool({ name: "get_delegation_chain", description: "Get the delegation chain for an agent.", parameters: { agent_id: z.string() }, implementation: async (p) => agentTools.getDelegationChain(p.agent_id) }); tools.push(getDelegationChainTool); // Tool toggles are now handled by the UI sidebar. State is initialized empty here. require('./contextInjector').updateToolStatus([], []); // --- Memory Tools (5 tools) --- const getMemoryConfig = (scope: "global" | "workspace") => ({ scope, workspacePath: workspaceRoot, neo4j: { uri: pluginConfig.get("neo4j.uri"), username: pluginConfig.get("neo4j.username"), password: pluginConfig.get("neo4j.password"), }, embeddingModel: pluginConfig.get("retrieval.embeddingModel"), lmStudioBaseUrl: process.env.LMS_PLUGIN_BASE_URL || process.env.LM_STUDIO_ENDPOINT, hotThreshold: pluginConfig.get("memory.hotThreshold"), }); // Helper to invalidate memory search cache when data changes function invalidateMemoryCache(): void { for (const key of TOOL_RESULT_CACHE.keys()) { if (key.startsWith("memory_search:") || key.startsWith("memory_list:") || key.startsWith("kb_get_entries:")) { TOOL_RESULT_CACHE.delete(key); } } } const memoryScope = z.enum(["global", "workspace"]).optional().default("global"); const memorySaveTool = tool({ name: "memory_save", description: "Save a fact to global or active workspace memory.", parameters: { key: z.string(), value: z.string(), scope: memoryScope }, implementation: async (p) => { const config = getMemoryConfig(p.scope); const result = await withRetry(async () => memoryTools.memory_save(p.key, p.value, config)); invalidateMemoryCache(); // Invalidate search cache on write return result; }}); tools.push(memorySaveTool); // Fix B: Wire up tool result cache to actual tools (with invalidation) const memorySearchTool = tool({ name: "memory_search", description: "Search global or active workspace memory for a fact.", parameters: { query: z.string(), scope: memoryScope }, implementation: async (p) => { const config = getMemoryConfig(p.scope); const cacheKey = generateToolCacheKey("memory_search", { ...p, _scope: JSON.stringify(config) }); const cached = getCachedToolResult(cacheKey); if (cached) return cached; const result = await withRetry(async () => memoryTools.memory_search(p.query, config)); setCachedToolResult(cacheKey, result); return result; }}); tools.push(memorySearchTool); const memoryListTool = tool({ name: "memory_list", description: "List memories from global or active workspace storage.", parameters: { scope: memoryScope }, implementation: async (p) => { const config = getMemoryConfig(p.scope); const cacheKey = generateToolCacheKey("memory_list", { scope: p.scope, _scope: JSON.stringify(config) }); const cached = getCachedToolResult(cacheKey); if (cached) return cached; const result = await withRetry(async () => memoryTools.memory_list(config)); setCachedToolResult(cacheKey, result); return result; }}); tools.push(memoryListTool); const memoryDeleteTool = tool({ name: "memory_delete", description: "Delete a memory by key from global or active workspace storage.", parameters: { key: z.string(), scope: memoryScope }, implementation: async (p) => { const config = getMemoryConfig(p.scope); const result = await withRetry(async () => memoryTools.memory_delete(p.key, config)); invalidateMemoryCache(); // Invalidate search cache on delete return result; }}); tools.push(memoryDeleteTool); const memoryClearTool = tool({ name: "memory_clear", description: "Clear global or active workspace memory.", parameters: { scope: memoryScope }, implementation: async (p) => { const config = getMemoryConfig(p.scope); const result = await withRetry(async () => memoryTools.memory_clear(config)); invalidateMemoryCache(); // Invalidate search cache on clear return result; }}); tools.push(memoryClearTool); // --- Workflow Tools (4 tools) --- const workflowCreateTool = tool({ name: "workflow_create", description: "Create a multi-step workflow.", parameters: { name: z.string(), steps: z.array(z.object({ agent_role: z.string(), task: z.string() })) }, implementation: async (p) => workflowTools.workflow_create(p.name, p.steps) }); tools.push(workflowCreateTool); const workflowExecuteTool = tool({ name: "workflow_execute", description: "Execute a workflow.", parameters: { workflow_id: z.string() }, implementation: async (p) => workflowTools.workflow_execute(p.workflow_id) }); tools.push(workflowExecuteTool); const workflowStatusTool = tool({ name: "workflow_status", description: "Get workflow status.", parameters: { workflow_id: z.string().optional() }, implementation: async (p) => workflowTools.workflow_status(p.workflow_id) }); tools.push(workflowStatusTool); const workflowDeleteTool = tool({ name: "workflow_delete", description: "Delete a workflow.", parameters: { workflow_id: z.string() }, implementation: async (p) => workflowTools.workflow_delete(p.workflow_id) }); tools.push(workflowDeleteTool); // --- Parallel Execution Tools (3 tools) --- const parallelExecuteTool = tool({ name: "parallel_execute", description: "Execute multiple tasks in parallel.", parameters: { tasks: z.array(z.object({ agent_role: z.string(), task: z.string() })) }, implementation: async (p) => parallelTools.parallel_execute(p.tasks) }); tools.push(parallelExecuteTool); const parallelStatusTool = tool({ name: "parallel_status", description: "Get parallel execution status.", parameters: { execution_id: z.string().optional() }, implementation: async (p) => parallelTools.parallel_status(p.execution_id) }); tools.push(parallelStatusTool); const parallelCancelTool = tool({ name: "parallel_cancel", description: "Cancel a parallel execution.", parameters: { execution_id: z.string() }, implementation: async (p) => parallelTools.parallel_cancel(p.execution_id) }); tools.push(parallelCancelTool); // --- Skill Library Tools (4 tools) --- const skillListTool = tool({ name: "skill_list", description: "List available agent skills.", parameters: {}, implementation: async () => skillTools.skill_list() }); tools.push(skillListTool); const skillCreateTool = tool({ name: "skill_create", description: "Create a new agent skill template.", parameters: { name: z.string(), description: z.string(), role: z.string(), tools_enabled: z.array(z.string()), prompt_template: z.string() }, implementation: async (p) => skillTools.skill_create(p.name, p.description, p.role, p.tools_enabled, p.prompt_template) }); tools.push(skillCreateTool); const skillDeleteTool = tool({ name: "skill_delete", description: "Delete an agent skill.", parameters: { id: z.string() }, implementation: async (p) => skillTools.skill_delete(p.id) }); tools.push(skillDeleteTool); const skillGetTool = tool({ name: "skill_get", description: "Get details of a specific skill.", parameters: { id: z.string() }, implementation: async (p) => skillTools.skill_get(p.id) }); tools.push(skillGetTool); // --- Self-Correction Tool --- const agentRunWithRetryTool = tool({ name: "agent_run_with_retry", description: "Run an agent with automatic self-correction on failure. The sub-agent will ACTUALLY execute the task with file system access if enabled.", parameters: { name: z.string(), role: z.string(), task: z.string().min(1), max_retries: z.number().int().min(0).max(10).optional(), tools_enabled: z.array(z.string()).optional() }, implementation: async (p) => agentTools.agent_run_with_retry(client, pluginConfig, p.name, p.role, p.task, p.max_retries, p.tools_enabled, currentWorkingDirectory) }); tools.push(agentRunWithRetryTool); // --- Context Manager Tools (4 tools) --- const contextSummarizeTool = tool({ name: "context_summarize", description: "Summarize conversation turns to save context.", parameters: { turns: z.array(z.string()) }, implementation: async (p) => contextManager.context_summarize(p.turns) }); tools.push(contextSummarizeTool); const contextCompressTool = tool({ name: "context_compress", description: text` Compress old context entries to save tokens. This is automatically triggered when the message count exceeds ${50} (configurable). Use this manually if you want to force compression before continuing a long task. Current state: - Message count: ${fullState.messageCount} - Compression threshold: 50 - dontAskToCompress: ${String(fullState.dontAskToCompress)} `, parameters: {}, implementation: async () => { // Check if compression is needed based on message count const needsCompression = shouldCompressContext(fullState); if (!needsCompression && !fullState.dontAskToCompress) { return { skipped: true, reason: `Message count (${fullState.messageCount}) has not reached the compression threshold (50).`, message_count: fullState.messageCount, threshold: 50, }; } const result = await contextManager.context_compress(); // Reset dontAskToCompress after successful compression if (!fullState.dontAskToCompress) { fullState.dontAskToCompress = true; await savePersistedState(fullState); } return { ...result, message_count: fullState.messageCount }; }, }); tools.push(contextCompressTool); const contextGetTool = tool({ name: "context_get", description: "Get stored context entries.", parameters: {}, implementation: async () => contextManager.context_get() }); tools.push(contextGetTool); const contextClearTool = tool({ name: "context_clear", description: "Clear all stored context.", parameters: {}, implementation: async () => contextManager.context_clear() }); tools.push(contextClearTool); // --- Evaluation Tools (4 tools) --- const evalRecordTool = tool({ name: "eval_record", description: "Record an agent evaluation metric.", parameters: { agent_id: z.string(), task: z.string(), success: z.boolean(), latency_ms: z.number(), tools_used: z.array(z.string()) }, implementation: async (p) => evalTools.eval_record(p.agent_id, p.task, p.success, p.latency_ms, p.tools_used) }); tools.push(evalRecordTool); const evalGetStatsTool = tool({ name: "eval_get_stats", description: "Get agent evaluation statistics.", parameters: {}, implementation: async () => evalTools.eval_get_stats() }); tools.push(evalGetStatsTool); const evalGetHistoryTool = tool({ name: "eval_get_history", description: "Get evaluation history.", parameters: { limit: z.number().int().positive().optional() }, implementation: async (p) => evalTools.eval_get_history(p.limit) }); tools.push(evalGetHistoryTool); const evalClearTool = tool({ name: "eval_clear", description: "Clear all evaluations.", parameters: {}, implementation: async () => evalTools.eval_clear() }); tools.push(evalClearTool); // --- Git Workflow Tools (5 tools) --- const gitWorkflowCreateTool = tool({ name: "git_workflow_create", description: "Create a new git workflow branch.", parameters: { branch_name: z.string(), description: z.string().optional() }, implementation: async (p) => gitWorkflowTools.git_workflow_create(p.branch_name, p.description, workspaceRoot) }); tools.push(gitWorkflowCreateTool); const gitWorkflowOpenPRTool = tool({ name: "git_workflow_open_pr", description: "Open a PR for an active workflow.", parameters: { workflow_id: z.string() }, implementation: async (p) => gitWorkflowTools.git_workflow_open_pr(p.workflow_id, workspaceRoot) }); tools.push(gitWorkflowOpenPRTool); const gitWorkflowStatusTool = tool({ name: "git_workflow_status", description: "Get git workflow status.", parameters: { workflow_id: z.string().optional() }, implementation: async (p) => gitWorkflowTools.git_workflow_status(p.workflow_id) }); tools.push(gitWorkflowStatusTool); const gitWorkflowResolveConflictsTool = tool({ name: "git_workflow_resolve_conflicts", description: "Attempt to resolve merge conflicts.", parameters: { workflow_id: z.string(), base_content: z.string(), head_content: z.string() }, implementation: async (p) => gitWorkflowTools.git_workflow_resolve_conflicts(p.workflow_id, p.base_content, p.head_content) }); tools.push(gitWorkflowResolveConflictsTool); const gitWorkflowChangelogTool = tool({ name: "git_workflow_changelog", description: "Generate changelog from commit history.", parameters: { workflow_id: z.string().optional() }, implementation: async (p) => gitWorkflowTools.git_workflow_changelog(p.workflow_id, workspaceRoot) }); tools.push(gitWorkflowChangelogTool); // --- Knowledge Base Tools (4 tools) --- const kbScanDirTool = tool({ name: "kb_scan_directory", description: "Scan directory and index files into knowledge base.", parameters: { dir_path: z.string(), max_depth: z.number().int().positive().optional() }, implementation: async (p) => knowledgeBase.kb_scan_directory(p.dir_path, p.max_depth, workspaceRoot) }); tools.push(kbScanDirTool); const kbSearchTool = tool({ name: "kb_search", description: "Search the knowledge base.", parameters: { query: z.string() }, implementation: async (p) => knowledgeBase.kb_search(p.query, workspaceRoot) }); tools.push(kbSearchTool); // Fix B: Wire up tool result cache to actual tools (continued) const kbGetEntriesTool = tool({ name: "kb_get_entries", description: "Get all knowledge base entries.", parameters: {}, implementation: async () => { const cacheKey = generateToolCacheKey("kb_get_entries", {}); const cached = getCachedToolResult(cacheKey); if (cached) return cached; const result = await knowledgeBase.kb_get_entries(workspaceRoot); setCachedToolResult(cacheKey, result); return result; }}); tools.push(kbGetEntriesTool); const kbClearTool = tool({ name: "kb_clear", description: "Clear the knowledge base.", parameters: {}, implementation: async () => knowledgeBase.kb_clear(workspaceRoot) }); tools.push(kbClearTool); // --- Plugin Bridge Tools (4 tools) --- const pluginBridgeSendTool = tool({ name: "plugin_bridge_send", description: "Send a message to another LM Studio plugin.", parameters: { target_plugin: z.string(), tool_name: z.string(), params: z.any() }, implementation: async (p) => pluginBridge.plugin_bridge_send(p.target_plugin, p.tool_name, p.params) }); tools.push(pluginBridgeSendTool); const pluginBridgeReceiveTool = tool({ name: "plugin_bridge_receive", description: "Receive messages from other plugins.", parameters: { target_plugin: z.string().optional() }, implementation: async (p) => pluginBridge.plugin_bridge_receive(p.target_plugin) }); tools.push(pluginBridgeReceiveTool); const pluginBridgeStatusTool = tool({ name: "plugin_bridge_status", description: "Get bridge queue status.", parameters: {}, implementation: async () => pluginBridge.plugin_bridge_status() }); tools.push(pluginBridgeStatusTool); const pluginBridgeClearTool = tool({ name: "plugin_bridge_clear", description: "Clear the message queue.", parameters: { target_plugin: z.string().optional() }, implementation: async (p) => pluginBridge.plugin_bridge_clear(p.target_plugin) }); tools.push(pluginBridgeClearTool); // --- Document Parsing Tools (5 tools) --- const parsePdfTool = tool({ name: "parse_pdf", description: "Extract text and content from PDF files. Supports both standard PDFs and OCR fallback for scanned documents.", parameters: { file_path: z.string().min(1).describe("Path to the PDF file") }, implementation: async (p) => documentParsers.parse_pdf(p.file_path, workspaceRoot) }); tools.push(parsePdfTool); const parseEpubTool = tool({ name: "parse_epub", description: "Extract chapters and text content from EPUB e-books.", parameters: { file_path: z.string().min(1).describe("Path to the EPUB file") }, implementation: async (p) => documentParsers.parse_epub(p.file_path, workspaceRoot) }); tools.push(parseEpubTool); const parseHtmlTool = tool({ name: "parse_html", description: "Strip HTML tags and extract readable content from web pages or HTML files. Optionally extracts links.", parameters: { file_path: z.string().min(1).describe("Path to the HTML file"), options: z.object({ extract_links: z.boolean().optional().default(true) }).optional() }, implementation: async (p) => documentParsers.parse_html(p.file_path, p.options, workspaceRoot) }); tools.push(parseHtmlTool); const ocrImageTool = tool({ name: "ocr_image", description: "Run OCR on image files (PNG, JPG, BMP) using Tesseract.js. Returns extracted text and confidence score.", parameters: { file_path: z.string().min(1).describe("Path to the image file") }, implementation: async (p) => documentParsers.ocr_image(p.file_path, workspaceRoot) }); tools.push(ocrImageTool); const chunkTextTool = tool({ name: "chunk_text", description: "Split text into RAG-compatible chunks with configurable size and overlap. Useful for preparing documents for semantic search.", parameters: { text: z.string().min(1).describe("Input text to chunk"), options: z.object({ chunk_size: z.number().int().positive().optional().default(500), overlap: z.number().int().nonnegative().optional().default(50) }).optional() }, implementation: async (p) => documentParsers.chunk_text(p.text, p.options) }); tools.push(chunkTextTool); // Health / status tools (plugin_status, clear_plugin_caches) tools.push(...createHealthTools()); // --- Tool Groups Discovery Tool — helps the agent discover tool categories --- const listToolGroupsTool = tool({ name: "list_tool_groups", description: "List all available tool groups with their descriptions and member tools. Use this to understand which tools belong together for efficient task execution.", parameters: {}, implementation: async () => { const groups = [ { name: "File Operations", description: "Read, write, search, and navigate files and directories.", tools: ["change_directory", "pwd", "list_directory", "read_file", "read_file_range", "save_file", "create_file", "move_file", "copy_file", "delete_path", "delete_files_by_pattern", "make_directory", "find_files", "fuzzy_find_local_files", "get_file_metadata", "search_file_content", "search_in_file", "search_directory", "open_file_or_url", "preview_html"] }, { name: "File Editing", description: "Make targeted edits to file contents without rewriting.", tools: ["replace_text_in_file", "multi_replace_text", "insert_at_line", "append_file", "delete_lines_in_file"] }, { name: "Code Execution", description: "Execute code snippets or shell commands.", tools: ["run_python", "run_javascript", "execute_command", "run_test_command"] }, { name: "Web & Search", description: "Search the web, fetch URLs, and parse feeds.", tools: ["web_search", "fetch_web_content", "wikipedia_search", "rag_web_content", "rss_fetch", "atom_parse"] }, { name: "RAG & Knowledge", description: "Semantic search over local files and persistent memory.", tools: ["rag_local_files", "kb_scan_directory", "kb_search", "kb_get_entries", "kb_clear", "memory_save", "memory_search", "memory_list", "memory_delete", "memory_clear"] }, { name: "Document Parsing", description: "Extract text from PDFs, EPUBs, HTML, and images.", tools: ["parse_pdf", "parse_epub", "parse_html", "ocr_image", "chunk_text", "read_document"] }, { name: "Data Formats", description: "Convert and validate CSV, JSON, YAML data.", tools: ["csv_to_json_stream", "json_to_csv_convert", "csv_validate_schema", "csv_merge_files", "yaml_parse_file", "yaml_generate_file", "config_diff_yaml", "yaml_to_json"] }, { name: "Git & Version Control", description: "Git operations and workflow management.", tools: ["git_status", "git_diff", "git_commit", "git_log", "git_add", "git_checkout", "git_workflow_create", "git_workflow_open_pr", "git_workflow_status", "git_workflow_resolve_conflicts", "git_workflow_changelog"] }, { name: "GitHub Integration", description: "Interact with GitHub issues, PRs, and repositories.", tools: ["gh_auth", "gh_create_issue", "gh_list_issues", "gh_view_comments", "gh_create_pr", "gh_list_prs", "gh_view_pr_diff", "gh_push"] }, { name: "Browser Control", description: "Headless browser automation via Puppeteer.", tools: ["browser_session_open", "browser_session_control", "browser_session_close", "browser_open_page"] }, { name: "Media Processing", description: "Resize, convert, and analyze images/video/audio.", tools: ["image_resize", "image_convert_format", "image_extract_metadata", "image_create_thumbnail", "pdf_merge_pages", "video_transcode", "audio_extract", "media_info_get", "gif_animate_from_video"] }, { name: "Archives", description: "Create, extract, and list archive contents.", tools: ["zip_create", "zip_extract", "tar_create", "tar_extract", "archive_list_contents"] }, { name: "Agent Management", description: "Create, manage, and delegate tasks to sub-agents.", tools: ["agent_create", "agent_update", "agent_delete", "agent_assign_task", "agent_status", "agent_task_queue_status", "delegate_to_agent", "get_delegation_chain", "agent_run_with_retry"] }, { name: "Workflow & Parallel", description: "Multi-step workflows and parallel task execution.", tools: ["workflow_create", "workflow_execute", "workflow_status", "workflow_delete", "parallel_execute", "parallel_status", "parallel_cancel"] }, { name: "Context Management", description: "Summarize, compress, and manage conversation context.", tools: ["context_summarize", "context_compress", "context_get", "context_clear"] }, { name: "Automation", description: "Cron jobs, timers, time logging, and scheduling.", tools: ["cron_schedule", "cron_list", "cron_delete", "task_queue_add", "timer_start", "timer_stop", "timer_status", "time_log_create", "time_log_entry", "time_log_report", "calendar_add_event", "reminder_set"] }, { name: "Cache & Config", description: "Caching strategies and configuration management.", tools: ["cached_rag_query", "cached_web_fetch", "cached_file_read", "clear_all_caches", "get_cache_stats", "config_export", "config_import", "config_backup", "config_restore"] }, { name: "Evaluation", description: "Record and query agent evaluation metrics.", tools: ["eval_record", "eval_get_stats", "eval_get_history", "eval_clear"] }, { name: "Skills", description: "Manage reusable agent skill templates.", tools: ["skill_list", "skill_create", "skill_delete", "skill_get"] }, { name: "Plugin Bridge", description: "Send and receive messages between LM Studio plugins.", tools: ["plugin_bridge_send", "plugin_bridge_receive", "plugin_bridge_status", "plugin_bridge_clear"] }, { name: "Neo4j Graph DB", description: "Query and manage Neo4j graph database.", tools: ["neo4j_query", "neo4j_create_node", "neo4j_delete_node", "neo4j_update_node", "neo4j_create_relationship", "neo4j_delete_relationship", "neo4j_path_find", "neo4j_graph_analysis", "neo4j_test_connection", "neo4j_run_script", "neo4j_run_cypher_file"] }, { name: "System & Utility", description: "System info, clipboard, UUIDs, hashes, and utilities.", tools: ["get_system_info", "read_clipboard", "write_clipboard", "regex_test", "url_build", "hash_generate", "uuid_generate", "uuid_validate", "state_query", "plugin_status", "send_notification"] }, ]; const output = groups.map(g => { return `### ${g.name}\nDescription: ${g.description}\nTools (${g.tools.length}): ${g.tools.join(", ")}`; }).join("\n\n---\n\n"); return { message: `Found ${groups.length} tool groups. Use this to discover which tools belong together for efficient task execution.` + "\n\n" + output }; }, }); tools.push(listToolGroupsTool); // ============================================================================ // TOOL GROUPING METADATA — helps the agent understand tool categories and // call related tools in logical sequences. // ============================================================================ const TOOL_GROUPS: Record = { "File Operations": { tools: [ "change_directory", "pwd", "list_directory", "read_file", "read_file_range", "save_file", "create_file", "move_file", "copy_file", "delete_path", "delete_files_by_pattern", "make_directory", "find_files", "fuzzy_find_local_files", "get_file_metadata", "search_file_content", "search_in_file", "search_directory", "open_file_or_url", "preview_html", ], description: "Read, write, search, and navigate files and directories.", }, "File Editing": { tools: [ "replace_text_in_file", "multi_replace_text", "insert_at_line", "append_file", "delete_lines_in_file", ], description: "Make targeted edits to file contents without rewriting.", }, "Code Execution": { tools: ["run_python", "run_javascript", "execute_command", "run_test_command"], description: "Execute code snippets or shell commands.", }, "Web & Search": { tools: [ "web_search", "fetch_web_content", "wikipedia_search", "rag_web_content", "rss_fetch", "atom_parse", ], description: "Search the web, fetch URLs, and parse feeds.", }, "RAG & Knowledge": { tools: [ "rag_local_files", "kb_scan_directory", "kb_search", "kb_get_entries", "kb_clear", "memory_save", "memory_search", "memory_list", "memory_delete", "memory_clear", ], description: "Semantic search over local files and persistent memory.", }, "Document Parsing": { tools: ["parse_pdf", "parse_epub", "parse_html", "ocr_image", "chunk_text", "read_document"], description: "Extract text from PDFs, EPUBs, HTML, and images.", }, "Data Formats": { tools: [ "csv_to_json_stream", "json_to_csv_convert", "csv_validate_schema", "csv_merge_files", "yaml_parse_file", "yaml_generate_file", "config_diff_yaml", "yaml_to_json", ], description: "Convert and validate CSV, JSON, YAML data.", }, "Git & Version Control": { tools: [ "git_status", "git_diff", "git_commit", "git_log", "git_add", "git_checkout", "git_workflow_create", "git_workflow_open_pr", "git_workflow_status", "git_workflow_resolve_conflicts", "git_workflow_changelog", ], description: "Git operations and workflow management.", }, "GitHub Integration": { tools: [ "gh_auth", "gh_create_issue", "gh_list_issues", "gh_view_comments", "gh_create_pr", "gh_list_prs", "gh_view_pr_diff", "gh_push", ], description: "Interact with GitHub issues, PRs, and repositories.", }, "Browser Control": { tools: [ "browser_session_open", "browser_session_control", "browser_session_close", "browser_open_page", ], description: "Headless browser automation via Puppeteer.", }, "Media Processing": { tools: [ "image_resize", "image_convert_format", "image_extract_metadata", "image_create_thumbnail", "pdf_merge_pages", "video_transcode", "audio_extract", "media_info_get", "gif_animate_from_video", ], description: "Resize, convert, and analyze images/video/audio.", }, "Archives": { tools: ["zip_create", "zip_extract", "tar_create", "tar_extract", "archive_list_contents"], description: "Create, extract, and list archive contents.", }, "Agent Management": { tools: [ "agent_create", "agent_update", "agent_delete", "agent_assign_task", "agent_status", "agent_task_queue_status", "delegate_to_agent", "get_delegation_chain", "agent_run_with_retry", ], description: "Create, manage, and delegate tasks to sub-agents.", }, "Workflow & Parallel": { tools: [ "workflow_create", "workflow_execute", "workflow_status", "workflow_delete", "parallel_execute", "parallel_status", "parallel_cancel", ], description: "Multi-step workflows and parallel task execution.", }, "Context Management": { tools: ["context_summarize", "context_compress", "context_get", "context_clear"], description: "Summarize, compress, and manage conversation context.", }, "Automation": { tools: [ "cron_schedule", "cron_list", "cron_delete", "task_queue_add", "timer_start", "timer_stop", "timer_status", "time_log_create", "time_log_entry", "time_log_report", "calendar_add_event", "reminder_set", ], description: "Cron jobs, timers, time logging, and scheduling.", }, "Cache & Config": { tools: [ "cached_rag_query", "cached_web_fetch", "cached_file_read", "clear_all_caches", "get_cache_stats", "config_export", "config_import", "config_backup", "config_restore", ], description: "Caching strategies and configuration management.", }, "Evaluation": { tools: ["eval_record", "eval_get_stats", "eval_get_history", "eval_clear"], description: "Record and query agent evaluation metrics.", }, "Skills": { tools: ["skill_list", "skill_create", "skill_delete", "skill_get"], description: "Manage reusable agent skill templates.", }, "Plugin Bridge": { tools: [ "plugin_bridge_send", "plugin_bridge_receive", "plugin_bridge_status", "plugin_bridge_clear", ], description: "Send and receive messages between LM Studio plugins.", }, "Neo4j Graph DB": { tools: [ "neo4j_query", "neo4j_create_node", "neo4j_delete_node", "neo4j_update_node", "neo4j_create_relationship", "neo4j_delete_relationship", "neo4j_path_find", "neo4j_graph_analysis", ], description: "Query and manage Neo4j graph database.", }, "System & Utility": { tools: [ "get_system_info", "read_clipboard", "write_clipboard", "regex_test", "url_build", "hash_generate", "uuid_generate", "uuid_validate", "state_query", "plugin_status", "send_notification", ], description: "System info, clipboard, UUIDs, hashes, and utilities.", }, }; // Sort tools: casual/general-purpose first, then advanced/developer tools. // Within each category, preserve alphabetical order. const casualTools = new Set([ // File ops "change_directory", "pwd", "list_directory", "read_file", "read_file_range", "save_file", "create_file", "move_file", "copy_file", "delete_path", "delete_files_by_pattern", "make_directory", "find_files", "fuzzy_find_local_files", "get_file_metadata", "search_file_content", "search_in_file", "search_directory", // File editing "replace_text_in_file", "multi_replace_text", "insert_at_line", "append_file", "delete_lines_in_file", // Web / RAG "web_search", "fetch_web_content", "wikipedia_search", "rag_web_content", "rag_local_files", // Document parsing (from Big RAG integration) "parse_pdf", "parse_epub", "parse_html", "ocr_image", "chunk_text", // System / utility "read_clipboard", "write_clipboard", "open_file_or_url", "preview_html", "read_document", "save_memory", "send_notification", "plugin_status", ]); tools.sort((a, b) => { const aCasual = casualTools.has(a.name); const bCasual = casualTools.has(b.name); if (aCasual && !bCasual) return -1; if (!aCasual && bCasual) return 1; return a.name.localeCompare(b.name); }); // Attach grouping metadata to the tools array for agent reference. (tools as any).__toolGroups = TOOL_GROUPS; return tools; } 86:["$","div",null,{"className":"flex h-full w-full min-w-0 flex-grow flex-col items-center justify-start","children":["$","div",null,{"className":"flex w-full flex-col gap-4","children":["$","div",null,{"className":"flex min-w-0 flex-grow flex-col overflow-x-hidden rounded-md border border-border/50 dark:border-[#2B2B2B]","children":[["$","div",null,{"className":"flex h-[42px] items-center justify-between gap-4 border-b bg-secondary/30 p-2 px-4 text-sm dark:bg-[#171717]","children":[["$","div",null,{"className":"flex w-full min-w-0 items-center gap-2","children":[["$","p",null,{"className":"flex items-center gap-1.5 truncate font-medium","children":[["$","svg",null,{"stroke":"currentColor","fill":"none","strokeWidth":"2","viewBox":"0 0 24 24","strokeLinecap":"round","strokeLinejoin":"round","children":["$undefined",[["$","path","0",{"d":"M13 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V9z","children":[]}],["$","polyline","1",{"points":"13 2 13 9 20 9","children":[]}]]],"className":"$undefined","style":{"color":"$undefined"},"height":"1em","width":"1em","xmlns":"http://www.w3.org/2000/svg"}]," ","src / toolsProvider.ts"]}],"$undefined"]}],"$undefined"]}],["$","div",null,{"className":"min-h-0 w-full flex-grow overflow-y-auto","children":["$","div",null,{"className":"relative h-full w-full min-w-0 overflow-auto bg-file text-[13px] leading-5","children":["$","div",null,{"className":"relative w-full bg-file text-sm","children":[["$","$L7a",null,{"content":"$87","className":"pointer-events-auto right-2 top-2"}],"$L88"]}]}]}]]}]}]}]

timbers-toolbox

timbers-toolbox