opencode-toolbox 0.5.1 → 0.7.0

package/README.md

@@ -63,7 +63,7 @@ Create `~/.config/opencode/toolbox.jsonc`:
 
 ## Usage
 
-The plugin exposes four tools:
+The plugin exposes five tools:
 
 ### toolbox_search_bm25
 
@@ -215,6 +215,41 @@ The plugin automatically creates a `/toolbox-status` slash command on first laun
 
 Use it in OpenCode by typing `/toolbox-status` to get a formatted status report.
 
+### toolbox_perf
+
+Get detailed performance metrics for the toolbox plugin:
+
+```
+toolbox_perf({})
+```
+
+Returns performance data including initialization times, search latencies, and execution stats:
+
+```json
+{
+  "init": {
+    "duration": 1234.56,
+    "serverCount": 6,
+    "toolCount": 42
+  },
+  "timers": {
+    "search.bm25": { "count": 15, "total": 45.2, "avg": 3.01, "min": 1.2, "max": 8.5 },
+    "search.regex": { "count": 5, "total": 12.1, "avg": 2.42, "min": 1.1, "max": 4.2 },
+    "tool.execute": { "count": 10, "total": 892.3, "avg": 89.23, "min": 12.5, "max": 245.8 }
+  },
+  "indexStats": {
+    "documentCount": 42,
+    "avgDocLength": 15.3
+  },
+  "config": {
+    "initMode": "eager",
+    "connectionTimeout": 5000,
+    "requestTimeout": 30000,
+    "retryAttempts": 2
+  }
+}
+```
+
 ## Search Modes
 
 ### BM25 (Natural Language)

package/dist/index.js

@@ -32816,8 +32816,16 @@ var ServerConfigSchema = exports_external2.discriminatedUnion("type", [
   LocalServerConfigSchema,
   RemoteServerConfigSchema
 ]);
+var ConnectionConfigSchema = exports_external2.object({
+  connectTimeout: exports_external2.number().min(100).max(60000).default(5000),
+  requestTimeout: exports_external2.number().min(100).max(300000).default(30000),
+  retryAttempts: exports_external2.number().min(0).max(10).default(2),
+  retryDelay: exports_external2.number().min(0).max(30000).default(1000)
+});
 var SettingsConfigSchema = exports_external2.object({
-  defaultLimit: exports_external2.number().min(1).max(20).default(5)
+  defaultLimit: exports_external2.number().min(1).max(20).default(5),
+  initMode: exports_external2.enum(["eager", "lazy"]).default("eager"),
+  connection: ConnectionConfigSchema.optional()
 });
 var ConfigSchema = exports_external2.object({
   mcp: exports_external2.record(exports_external2.string(), ServerConfigSchema),
@@ -37627,6 +37635,9 @@ class RemoteMCPClient {
     return this.toolsCache;
   }
 }
+// src/mcp-client/manager.ts
+import { EventEmitter } from "events";
+
 // src/catalog/catalog.ts
 function normalizeTool(serverName, tool3) {
   const id = {
@@ -37674,15 +37685,178 @@ function buildSearchableText(serverName, tool3, args) {
 function normalizeTools(serverName, tools) {
   return tools.map((tool3) => normalizeTool(serverName, tool3));
 }
+// src/profiler/profiler.ts
+function percentile(sorted, p) {
+  if (sorted.length === 0)
+    return 0;
+  const index = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, index)];
+}
+function calculateStats(measurements) {
+  if (measurements.length === 0)
+    return null;
+  const sorted = [...measurements].sort((a, b) => a - b);
+  const total = sorted.reduce((sum, v) => sum + v, 0);
+  return {
+    count: sorted.length,
+    min: sorted[0],
+    max: sorted[sorted.length - 1],
+    avg: total / sorted.length,
+    p50: percentile(sorted, 50),
+    p95: percentile(sorted, 95),
+    p99: percentile(sorted, 99),
+    total
+  };
+}
+
+class Profiler {
+  marks = new Map;
+  measures = new Map;
+  serverMetrics = new Map;
+  initStartTime = null;
+  initEndTime = null;
+  initState = "idle";
+  indexBuildTime = null;
+  toolCount = 0;
+  incrementalUpdates = 0;
+  startTime = performance.now();
+  mark(name) {
+    this.marks.set(name, performance.now());
+  }
+  measure(name, startMark) {
+    const start = this.marks.get(startMark);
+    if (start === undefined) {
+      return -1;
+    }
+    const duration5 = performance.now() - start;
+    const existing = this.measures.get(name) || [];
+    existing.push(duration5);
+    this.measures.set(name, existing);
+    return duration5;
+  }
+  record(name, duration5) {
+    const existing = this.measures.get(name) || [];
+    existing.push(duration5);
+    this.measures.set(name, existing);
+  }
+  getStats(name) {
+    const measurements = this.measures.get(name);
+    if (!measurements)
+      return null;
+    return calculateStats(measurements);
+  }
+  initStart() {
+    this.initStartTime = performance.now();
+    this.initState = "initializing";
+  }
+  initComplete(state) {
+    this.initEndTime = performance.now();
+    this.initState = state;
+  }
+  recordServerConnect(name, connectTime, toolCount, status, error92) {
+    this.serverMetrics.set(name, {
+      name,
+      connectTime,
+      toolCount,
+      status,
+      error: error92
+    });
+  }
+  recordIndexBuild(duration5, toolCount) {
+    this.indexBuildTime = duration5;
+    this.toolCount = toolCount;
+  }
+  recordIncrementalUpdate(toolCount) {
+    this.incrementalUpdates++;
+    this.toolCount += toolCount;
+  }
+  getInitState() {
+    return this.initState;
+  }
+  getInitDuration() {
+    if (this.initStartTime === null)
+      return null;
+    if (this.initEndTime !== null) {
+      return this.initEndTime - this.initStartTime;
+    }
+    return performance.now() - this.initStartTime;
+  }
+  export() {
+    return {
+      timestamp: new Date().toISOString(),
+      uptime: performance.now() - this.startTime,
+      initialization: {
+        startTime: this.initStartTime || 0,
+        endTime: this.initEndTime,
+        duration: this.getInitDuration(),
+        state: this.initState,
+        servers: Array.from(this.serverMetrics.values())
+      },
+      indexing: {
+        buildTime: this.indexBuildTime,
+        toolCount: this.toolCount,
+        incrementalUpdates: this.incrementalUpdates
+      },
+      searches: {
+        bm25: this.getStats("search.bm25"),
+        regex: this.getStats("search.regex")
+      },
+      executions: this.getStats("tool.execute")
+    };
+  }
+  reset() {
+    this.marks.clear();
+    this.measures.clear();
+    this.serverMetrics.clear();
+    this.initStartTime = null;
+    this.initEndTime = null;
+    this.initState = "idle";
+    this.indexBuildTime = null;
+    this.toolCount = 0;
+    this.incrementalUpdates = 0;
+  }
+  startTimer(name) {
+    const start = performance.now();
+    return () => {
+      const duration5 = performance.now() - start;
+      this.record(name, duration5);
+      return duration5;
+    };
+  }
+}
+var globalProfiler = new Profiler;
 // src/mcp-client/manager.ts
-class MCPManager {
+var DEFAULT_CONNECTION_CONFIG = {
+  connectTimeout: 5000,
+  requestTimeout: 30000,
+  retryAttempts: 2,
+  retryDelay: 1000
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function withTimeout(promise4, ms, errorMessage) {
+  return Promise.race([
+    promise4,
+    new Promise((_, reject) => setTimeout(() => reject(new Error(errorMessage)), ms))
+  ]);
+}
+
+class MCPManager extends EventEmitter {
   servers;
   clients;
   clientFactory;
+  connectionConfig;
+  initState = "idle";
+  initPromise = null;
+  serversPending = 0;
+  serversCompleted = 0;
   constructor(options) {
+    super();
     this.servers = new Map;
     this.clients = new Map;
     this.clientFactory = options?.clientFactory || this.defaultClientFactory.bind(this);
+    this.connectionConfig = { ...DEFAULT_CONNECTION_CONFIG, ...options?.connectionConfig };
   }
   defaultClientFactory(name, config3) {
     if (config3.type === "local") {
@@ -37694,40 +37868,135 @@ class MCPManager {
     }
   }
   async initialize(servers) {
+    if (this.initState !== "idle") {
+      return this.initPromise || Promise.resolve();
+    }
+    globalProfiler.initStart();
+    this.initState = "initializing";
+    this.serversPending = Object.keys(servers).length;
+    this.serversCompleted = 0;
     const promises = Object.entries(servers).map(async ([name, config3]) => {
-      return this.connectServer(name, config3);
+      return this.connectServerWithRetry(name, config3);
     });
-    await Promise.all(promises);
+    this.initPromise = Promise.all(promises).then(() => {
+      this.finalizeInit();
+    });
+    return this.initPromise;
+  }
+  initializeBackground(servers) {
+    this.initialize(servers).catch(() => {});
+  }
+  finalizeInit() {
+    const allServers = Array.from(this.servers.values());
+    const connected = allServers.filter((s) => s.status === "connected");
+    const failed = allServers.filter((s) => s.status === "error");
+    if (connected.length === allServers.length) {
+      this.initState = "ready";
+    } else if (connected.length > 0) {
+      this.initState = "degraded";
+    } else {
+      this.initState = "degraded";
+    }
+    globalProfiler.initComplete(this.initState);
+    this.emit("init:complete", this.initState);
+  }
+  async connectServerWithRetry(name, config3) {
+    const maxAttempts = this.connectionConfig.retryAttempts + 1;
+    let lastError = null;
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      try {
+        await this.connectServer(name, config3);
+        return;
+      } catch (error92) {
+        lastError = error92 instanceof Error ? error92 : new Error(String(error92));
+        if (attempt < maxAttempts) {
+          await sleep(this.connectionConfig.retryDelay);
+        }
+      }
+    }
+    this.servers.set(name, {
+      name,
+      config: config3,
+      tools: [],
+      status: "error",
+      error: lastError?.message || "Connection failed after retries"
+    });
+    globalProfiler.recordServerConnect(name, -1, 0, "error", lastError?.message);
+    this.emit("server:error", name, lastError?.message || "Unknown error");
+    this.checkPartialReady();
   }
   async connectServer(name, config3) {
+    const startTime = performance.now();
     this.servers.set(name, {
       name,
       config: config3,
       tools: [],
       status: "connecting"
     });
-    try {
-      const client = this.clientFactory(name, config3);
-      await client.connect();
-      const tools = await client.listTools();
-      const catalogTools = normalizeTools(name, tools);
-      this.servers.set(name, {
-        name,
-        config: config3,
-        tools: catalogTools,
-        status: "connected"
-      });
-      this.clients.set(name, client);
-    } catch (error92) {
-      this.servers.set(name, {
-        name,
-        config: config3,
-        tools: [],
-        status: "error",
-        error: error92 instanceof Error ? error92.message : String(error92)
-      });
+    const client = this.clientFactory(name, config3);
+    await withTimeout(client.connect(), this.connectionConfig.connectTimeout, `Connection to ${name} timed out after ${this.connectionConfig.connectTimeout}ms`);
+    const tools = await withTimeout(client.listTools(), this.connectionConfig.requestTimeout, `Listing tools from ${name} timed out after ${this.connectionConfig.requestTimeout}ms`);
+    const catalogTools = normalizeTools(name, tools);
+    const connectTime = performance.now() - startTime;
+    this.servers.set(name, {
+      name,
+      config: config3,
+      tools: catalogTools,
+      status: "connected"
+    });
+    this.clients.set(name, client);
+    globalProfiler.recordServerConnect(name, connectTime, catalogTools.length, "connected");
+    this.emit("server:connected", name, catalogTools);
+    this.checkPartialReady();
+  }
+  checkPartialReady() {
+    this.serversCompleted++;
+    if (this.initState === "initializing") {
+      const connected = Array.from(this.servers.values()).filter((s) => s.status === "connected");
+      if (connected.length === 1 && this.serversCompleted < this.serversPending) {
+        this.initState = "partial";
+        this.emit("init:partial");
+      }
     }
   }
+  isReady() {
+    return this.initState === "ready" || this.initState === "partial" || this.initState === "degraded";
+  }
+  isComplete() {
+    return this.initState === "ready" || this.initState === "degraded";
+  }
+  getInitState() {
+    return this.initState;
+  }
+  async waitForReady() {
+    if (this.isComplete()) {
+      return this.initState;
+    }
+    if (this.initPromise) {
+      await this.initPromise;
+      return this.initState;
+    }
+    return this.initState;
+  }
+  waitForPartial() {
+    if (this.isReady()) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      const onPartial = () => {
+        this.off("init:partial", onPartial);
+        this.off("init:complete", onComplete);
+        resolve();
+      };
+      const onComplete = () => {
+        this.off("init:partial", onPartial);
+        this.off("init:complete", onComplete);
+        resolve();
+      };
+      this.on("init:partial", onPartial);
+      this.on("init:complete", onComplete);
+    });
+  }
   getAllTools() {
     const allTools = [];
     for (const [name, server] of this.servers) {
@@ -37751,7 +38020,7 @@ class MCPManager {
     if (!client) {
       throw new Error(`MCP client not found for server: ${serverName}`);
     }
-    return client.callTool(toolName, args);
+    return withTimeout(client.callTool(toolName, args), this.connectionConfig.requestTimeout, `Tool execution timed out after ${this.connectionConfig.requestTimeout}ms`);
   }
   getServer(name) {
     return this.servers.get(name);
@@ -37764,12 +38033,17 @@ class MCPManager {
     await Promise.all(promises);
     this.servers.clear();
     this.clients.clear();
+    this.initState = "idle";
+    this.initPromise = null;
   }
 }
 // src/search/bm25.ts
 function tokenize(text) {
   return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((token) => token.length > 0);
 }
+function yieldToEventLoop() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
 
 class BM25Index {
   documents;
@@ -37777,6 +38051,7 @@ class BM25Index {
   docLengths;
   avgDocLength = 0;
   totalDocs = 0;
+  totalTokens = 0;
   k1 = 1.2;
   b = 0.75;
   constructor() {
@@ -37785,20 +38060,82 @@ class BM25Index {
     this.docLengths = new Map;
   }
   indexTools(tools) {
-    this.documents.clear();
-    this.docFreqs.clear();
-    this.docLengths.clear();
+    this.clear();
+    this.addToolsBatch(tools);
+  }
+  async indexToolsAsync(tools, chunkSize = 50) {
+    this.clear();
+    await this.addToolsAsync(tools, chunkSize);
+  }
+  addToolsBatch(tools) {
     for (const tool3 of tools) {
-      const tokens = tokenize(tool3.searchableText);
-      this.documents.set(tool3.idString, { tokens, tool: tool3 });
-      this.docLengths.set(tool3.idString, tokens.length);
-      const uniqueTokens = new Set(tokens);
-      for (const token of uniqueTokens) {
-        this.docFreqs.set(token, (this.docFreqs.get(token) || 0) + 1);
+      this.addToolInternal(tool3);
+    }
+    this.recalculateAvgDocLength();
+  }
+  async addToolsAsync(tools, chunkSize = 50) {
+    for (let i = 0;i < tools.length; i += chunkSize) {
+      const chunk = tools.slice(i, i + chunkSize);
+      for (const tool3 of chunk) {
+        this.addToolInternal(tool3);
+      }
+      if (i + chunkSize < tools.length) {
+        await yieldToEventLoop();
       }
     }
-    this.totalDocs = this.documents.size;
-    this.avgDocLength = Array.from(this.docLengths.values()).reduce((sum, len) => sum + len, 0) / this.totalDocs;
+    this.recalculateAvgDocLength();
+  }
+  addTool(tool3) {
+    this.addToolInternal(tool3);
+    this.recalculateAvgDocLengthIncremental();
+  }
+  addToolInternal(tool3) {
+    if (this.documents.has(tool3.idString)) {
+      return;
+    }
+    const tokens = tokenize(tool3.searchableText);
+    this.documents.set(tool3.idString, { tokens, tool: tool3 });
+    this.docLengths.set(tool3.idString, tokens.length);
+    this.totalTokens += tokens.length;
+    this.totalDocs++;
+    const uniqueTokens = new Set(tokens);
+    for (const token of uniqueTokens) {
+      this.docFreqs.set(token, (this.docFreqs.get(token) || 0) + 1);
+    }
+  }
+  removeTool(idString) {
+    const doc3 = this.documents.get(idString);
+    if (!doc3)
+      return false;
+    const uniqueTokens = new Set(doc3.tokens);
+    for (const token of uniqueTokens) {
+      const freq = this.docFreqs.get(token) || 0;
+      if (freq <= 1) {
+        this.docFreqs.delete(token);
+      } else {
+        this.docFreqs.set(token, freq - 1);
+      }
+    }
+    this.totalTokens -= doc3.tokens.length;
+    this.documents.delete(idString);
+    this.docLengths.delete(idString);
+    this.totalDocs--;
+    this.recalculateAvgDocLengthIncremental();
+    return true;
+  }
+  recalculateAvgDocLength() {
+    if (this.totalDocs === 0) {
+      this.avgDocLength = 0;
+      return;
+    }
+    this.avgDocLength = this.totalTokens / this.totalDocs;
+  }
+  recalculateAvgDocLengthIncremental() {
+    if (this.totalDocs === 0) {
+      this.avgDocLength = 0;
+      return;
+    }
+    this.avgDocLength = this.totalTokens / this.totalDocs;
   }
   search(query, limit = 5) {
     const queryTokens = tokenize(query);
@@ -37854,10 +38191,21 @@ class BM25Index {
     this.docLengths.clear();
     this.avgDocLength = 0;
     this.totalDocs = 0;
+    this.totalTokens = 0;
   }
   get size() {
     return this.totalDocs;
   }
+  has(idString) {
+    return this.documents.has(idString);
+  }
+  getStats() {
+    return {
+      docCount: this.totalDocs,
+      termCount: this.docFreqs.size,
+      avgDocLength: this.avgDocLength
+    };
+  }
 }
 // src/search/regex.ts
 var MAX_REGEX_LENGTH = 200;
@@ -37964,7 +38312,79 @@ Pass arguments as JSON string matching the tool's schema.`;
 var STATUS_DESC = `Get toolbox status including plugin initialization, MCP server connections, and tool counts.
 
 Shows success/total metrics to highlight failures. Use to check if toolbox is working correctly.`;
+var PERF_DESC = `Get detailed performance metrics for the toolbox plugin.
+
+Shows initialization times, search latencies, execution stats, and per-server metrics.`;
+var TEST_DESC = `Test all toolbox tools with minimal predefined prompts.
+
+Executes every registered tool with super simple inputs to verify they work. Returns pass/fail for each tool.`;
+var TEST_PROMPTS = {
+  time_get_current_time: {},
+  time_convert_time: { source_timezone: "UTC", time: "12:00", target_timezone: "America/New_York" },
+  brave_brave_web_search: { query: "test", count: 1 },
+  brave_brave_local_search: { query: "coffee", count: 1 },
+  brave_brave_video_search: { query: "test", count: 1 },
+  brave_brave_image_search: { query: "test", count: 1 },
+  brave_brave_news_search: { query: "test", count: 1 },
+  brave_brave_summarizer: { key: "test" },
+  brightdata_search_engine: { query: "hello", engine: "google", count: 1 },
+  brightdata_search_engine_batch: { queries: [{ query: "test", engine: "google", count: 1 }] },
+  brightdata_scrape_as_markdown: { url: "https://example.com" },
+  brightdata_scrape_as_html: { url: "https://example.com" },
+  brightdata_scrape_batch: { urls: ["https://example.com"] },
+  brightdata_extract: { url: "https://example.com" },
+  brightdata_session_stats: {},
+  brightdata_web_data_reuter_news: { url: "https://www.reuters.com/technology/" },
+  brightdata_web_data_github_repository_file: { url: "https://github.com/octocat/Hello-World/blob/master/README" },
+  "tavily_tavily-search": { query: "test", maxResults: 1 },
+  "tavily_tavily-extract": { urls: ["https://example.com"] },
+  "tavily_tavily-map": { url: "https://example.com" },
+  "context7_resolve-library-id": { libraryName: "react" },
+  octocode_githubSearchRepositories: { query: "test", maxResults: 1 },
+  octocode_githubSearchCode: { query: "function test", maxResults: 1 },
+  octocode_githubViewRepoStructure: { owner: "octocat", repo: "Hello-World" },
+  perplexity_perplexity_ask: { query: "What is 1+1?" },
+  perplexity_perplexity_search: { query: "test", maxResults: 1 }
+};
+function generateMinimalArgs(schema2) {
+  const args = {};
+  if (schema2.type !== "object" || !schema2.properties) {
+    return args;
+  }
+  const properties = schema2.properties;
+  const required3 = schema2.required || [];
+  for (const propName of required3) {
+    const prop = properties[propName];
+    if (!prop)
+      continue;
+    const enumValues = prop.enum;
+    switch (prop.type) {
+      case "string":
+        args[propName] = prop.default ?? enumValues?.[0] ?? "test";
+        break;
+      case "number":
+      case "integer":
+        args[propName] = prop.default ?? prop.minimum ?? 1;
+        break;
+      case "boolean":
+        args[propName] = prop.default ?? false;
+        break;
+      case "array":
+        args[propName] = prop.default ?? [];
+        break;
+      case "object":
+        args[propName] = prop.default ?? {};
+        break;
+      default:
+        args[propName] = prop.default ?? null;
+    }
+  }
+  return args;
+}
+var isTestEnv = !!process.env.BUN_TEST;
 function log(level, message, extra) {
+  if (isTestEnv)
+    return;
   const timestamp = new Date().toISOString();
   const extraStr = extra ? ` ${JSON.stringify(extra)}` : "";
   const line = `${timestamp} [${level.toUpperCase()}] ${message}${extraStr}
@@ -37972,6 +38392,8 @@ function log(level, message, extra) {
   mkdir(LOG_DIR, { recursive: true }).then(() => appendFile(LOG_FILE_PATH, line)).catch(() => {});
 }
 function ensureCommandFile() {
+  if (isTestEnv)
+    return;
   access(COMMAND_FILE_PATH).catch(() => {
     mkdir(COMMAND_DIR, { recursive: true }).then(() => writeFile(COMMAND_FILE_PATH, COMMAND_CONTENT)).then(() => log("info", "Created /toolbox-status command file")).catch(() => {});
   });
@@ -37980,37 +38402,25 @@ var SYSTEM_PROMPT_BASE = `# Extended Toolbox
 
 You have access to an extended toolbox with additional capabilities (web search, time utilities, code search, etc.).
 
-## Rule
-ALWAYS search before saying "I cannot do that" or "I don't have access to."
-DO NOT try to execute a tool without having the tool's exact tool schema. If you don't have the tool's schema
-  then run toolbox_search_* to get them.
+## Rules
+1. ALWAYS toolbox_search_* before saying "I cannot do that" or "I don't have access to."
+2. ALWAYS toolbox_search_* if you think that user wants you to use some tools
+3. ALWAYS toolbox_search_* if you think that user may refer specific tool name which is not exist in the context
 
 ## Workflow
 1. Search: toolbox_search_bm25({ text: "what you need" }) or toolbox_search_regex({ pattern: "prefix_.*" })
 2. Execute: toolbox_execute({ name: "tool_name", arguments: '{"key": "value"}' })`;
-function generateSystemPrompt(mcpManager) {
-  const servers = mcpManager.getAllServers();
-  if (servers.length === 0) {
-    return SYSTEM_PROMPT_BASE;
-  }
-  const toolboxSchema = {};
-  for (const server of servers) {
-    if (server.status === "connected" && server.tools.length > 0) {
-      toolboxSchema[server.name] = server.tools.map((t) => t.idString);
-    }
-  }
-  if (Object.keys(toolboxSchema).length === 0) {
+function generateSystemPrompt(configuredServers) {
+  if (configuredServers.length === 0) {
     return SYSTEM_PROMPT_BASE;
   }
   return `${SYSTEM_PROMPT_BASE}
 
-## Toolbox Schema
-Tool names use \`<server>_<tool>\` format. Pass exact names to toolbox_execute().
-\`\`\`json
-${JSON.stringify(toolboxSchema, null, 2)}
-\`\`\``;
+## Registered MCP Servers
+- ${configuredServers.join(", ")}`;
 }
 var ToolboxPlugin = async (ctx) => {
+  const pluginLoadStart = performance.now();
   const { client } = ctx;
   const configPath = process.env.OPENCODE_TOOLBOX_CONFIG || DEFAULT_CONFIG_PATH;
   const configResult = await loadConfig(configPath);
@@ -38020,53 +38430,64 @@ var ToolboxPlugin = async (ctx) => {
     return {};
   }
   const config3 = configResult.data;
-  const mcpManager = new MCPManager;
+  const initMode = config3.settings?.initMode || "eager";
+  const connectionConfig = {
+    connectTimeout: config3.settings?.connection?.connectTimeout || 5000,
+    requestTimeout: config3.settings?.connection?.requestTimeout || 30000,
+    retryAttempts: config3.settings?.connection?.retryAttempts || 2,
+    retryDelay: config3.settings?.connection?.retryDelay || 1000
+  };
+  const mcpManager = new MCPManager({ connectionConfig });
   const bm25Index = new BM25Index;
-  let initialized = false;
   let searchCount = 0;
   let executionCount = 0;
   let executionSuccessCount = 0;
   ensureCommandFile();
   const serverNames = Object.keys(config3.mcp);
+  const pluginLoadDuration = performance.now() - pluginLoadStart;
   log("info", `Toolbox plugin loaded successfully`, {
     configPath,
+    logPath: LOG_FILE_PATH,
     serverCount: serverNames.length,
-    servers: serverNames
+    servers: serverNames,
+    initMode,
+    loadDurationMs: Math.round(pluginLoadDuration * 100) / 100
+  });
+  mcpManager.on("server:connected", (serverName, tools) => {
+    const startTime = performance.now();
+    bm25Index.addToolsBatch(tools);
+    const indexTime = performance.now() - startTime;
+    globalProfiler.recordIncrementalUpdate(tools.length);
+    log("info", `Server ${serverName} connected, indexed ${tools.length} tools in ${indexTime.toFixed(2)}ms`);
+  });
+  mcpManager.on("server:error", (serverName, error92) => {
+    log("warn", `Server ${serverName} failed: ${error92}`);
+  });
+  mcpManager.on("init:complete", (state) => {
+    const duration5 = globalProfiler.getInitDuration();
+    const servers = mcpManager.getAllServers();
+    const connectedServers = servers.filter((s) => s.status === "connected");
+    log("info", `Initialization complete in ${duration5?.toFixed(2)}ms: ${connectedServers.length}/${servers.length} servers, ${bm25Index.size} tools indexed`, {
+      state,
+      totalServers: servers.length,
+      connectedServers: connectedServers.length,
+      totalTools: bm25Index.size
+    });
   });
+  if (initMode === "eager") {
+    mcpManager.initializeBackground(config3.mcp);
+    log("info", "Started eager background initialization");
+  }
   async function ensureInitialized() {
-    if (initialized)
+    if (mcpManager.isReady()) {
       return;
-    try {
-      log("info", "Initializing MCP servers...");
+    }
+    if (initMode === "lazy" && mcpManager.getInitState() === "idle") {
+      log("info", "Starting lazy initialization on first use");
       await mcpManager.initialize(config3.mcp);
-      const allTools = mcpManager.getAllCatalogTools();
-      bm25Index.indexTools(allTools);
-      initialized = true;
-      const servers = mcpManager.getAllServers();
-      const connectedServers = servers.filter((s) => s.status === "connected");
-      const failedServers = servers.filter((s) => s.status === "error");
-      const initMsg = `Initialization complete: ${connectedServers.length}/${servers.length} servers connected, ${allTools.length} tools indexed`;
-      log("info", initMsg, {
-        totalServers: servers.length,
-        connectedServers: connectedServers.length,
-        failedServers: failedServers.length,
-        totalTools: allTools.length,
-        servers: servers.map((s) => ({
-          name: s.name,
-          status: s.status,
-          toolCount: s.tools.length,
-          error: s.error || null
-        }))
-      });
-      if (failedServers.length > 0) {
-        const warnMsg = `${failedServers.length} server(s) failed to connect: ${failedServers.map((s) => s.name).join(", ")}`;
-        log("warn", warnMsg);
-      }
-    } catch (error92) {
-      const errorMsg = `Failed to initialize MCP servers: ${error92 instanceof Error ? error92.message : String(error92)}`;
-      log("error", errorMsg);
-      throw error92;
+      return;
     }
+    await mcpManager.waitForPartial();
   }
   return {
     tool: {
@@ -38077,9 +38498,11 @@ var ToolboxPlugin = async (ctx) => {
           limit: tool.schema.number().optional().describe("Maximum number of results to return (default: 5)")
         },
         async execute(args) {
+          const timer = globalProfiler.startTimer("search.bm25");
           try {
             await ensureInitialized();
           } catch (error92) {
+            timer();
             return JSON.stringify({
               success: false,
               error: `Failed to initialize: ${error92 instanceof Error ? error92.message : String(error92)}`
@@ -38089,11 +38512,13 @@ var ToolboxPlugin = async (ctx) => {
           const searchLimit = args.limit || config3.settings?.defaultLimit || 5;
           const allTools = mcpManager.getAllCatalogTools();
           const results = bm25Index.search(args.text, searchLimit);
-          log("info", `BM25 search completed: "${args.text}" -> ${results.length} results`, {
+          const duration5 = timer();
+          log("info", `BM25 search completed: "${args.text}" -> ${results.length} results in ${duration5.toFixed(2)}ms`, {
             searchType: "bm25",
             query: args.text,
             resultsCount: results.length,
-            limit: searchLimit
+            limit: searchLimit,
+            durationMs: duration5
           });
           return formatSearchResults(results, allTools);
         }
@@ -38105,9 +38530,11 @@ var ToolboxPlugin = async (ctx) => {
           limit: tool.schema.number().optional().describe("Maximum number of results to return (default: 5)")
         },
         async execute(args) {
+          const timer = globalProfiler.startTimer("search.regex");
           try {
             await ensureInitialized();
           } catch (error92) {
+            timer();
             return JSON.stringify({
               success: false,
               error: `Failed to initialize: ${error92 instanceof Error ? error92.message : String(error92)}`
@@ -38117,6 +38544,7 @@ var ToolboxPlugin = async (ctx) => {
           const searchLimit = args.limit || config3.settings?.defaultLimit || 5;
           const allTools = mcpManager.getAllCatalogTools();
           const result = searchWithRegex(allTools, args.pattern, searchLimit);
+          const duration5 = timer();
           if ("error" in result) {
             log("warn", `Regex search failed: "${args.pattern}" -> ${result.error}`);
             return JSON.stringify({
@@ -38124,11 +38552,12 @@ var ToolboxPlugin = async (ctx) => {
               error: result.error
             });
           }
-          log("info", `Regex search completed: "${args.pattern}" -> ${result.length} results`, {
+          log("info", `Regex search completed: "${args.pattern}" -> ${result.length} results in ${duration5.toFixed(2)}ms`, {
             searchType: "regex",
             pattern: args.pattern,
             resultsCount: result.length,
-            limit: searchLimit
+            limit: searchLimit,
+            durationMs: duration5
           });
           return formatSearchResults(result, allTools);
         }
@@ -38140,9 +38569,11 @@ var ToolboxPlugin = async (ctx) => {
           arguments: tool.schema.string().optional().describe("JSON-encoded arguments for the tool, matching its schema. Use '{}' or omit for tools with no required arguments.")
         },
         async execute(args) {
+          const timer = globalProfiler.startTimer("tool.execute");
           try {
             await ensureInitialized();
           } catch (error92) {
+            timer();
             return JSON.stringify({
               success: false,
               error: `Failed to initialize: ${error92 instanceof Error ? error92.message : String(error92)}`
@@ -38150,6 +38581,7 @@ var ToolboxPlugin = async (ctx) => {
           }
           const parsed = parseToolName(args.name);
           if (!parsed) {
+            timer();
             log("warn", `Invalid tool name format: ${args.name}`, {
               toolName: args.name
             });
@@ -38163,6 +38595,7 @@ var ToolboxPlugin = async (ctx) => {
             try {
               toolArgs = JSON.parse(args.arguments);
             } catch (error92) {
+              timer();
               log("warn", `Failed to parse arguments as JSON for ${args.name}`, {
                 toolName: args.name,
                 arguments: args.arguments
@@ -38175,11 +38608,10 @@ var ToolboxPlugin = async (ctx) => {
           }
           executionCount++;
           try {
-            const startTime = Date.now();
             const result = await mcpManager.callTool(parsed.serverName, parsed.toolName, toolArgs);
-            const duration5 = Date.now() - startTime;
+            const duration5 = timer();
             executionSuccessCount++;
-            log("info", `Tool executed successfully: ${args.name}`, {
+            log("info", `Tool executed successfully: ${args.name} in ${duration5.toFixed(2)}ms`, {
               server: parsed.serverName,
               tool: parsed.toolName,
               durationMs: duration5
@@ -38189,11 +38621,13 @@ var ToolboxPlugin = async (ctx) => {
               result
             });
           } catch (error92) {
+            const duration5 = timer();
             const errorMsg = `Tool execution failed: ${error92 instanceof Error ? error92.message : String(error92)}`;
             log("error", errorMsg, {
               server: parsed.serverName,
               tool: parsed.toolName,
-              error: errorMsg
+              error: errorMsg,
+              durationMs: duration5
             });
             return JSON.stringify({
               success: false,
@@ -38206,7 +38640,7 @@ var ToolboxPlugin = async (ctx) => {
         description: STATUS_DESC,
         args: {},
         async execute() {
-          if (!initialized) {
+          if (!mcpManager.isReady()) {
             try {
               await ensureInitialized();
             } catch (error92) {
@@ -38222,9 +38656,13 @@ var ToolboxPlugin = async (ctx) => {
           const failedServers = servers.filter((s) => s.status === "error");
           const connectingServers = servers.filter((s) => s.status === "connecting");
           const totalTools = mcpManager.getAllCatalogTools().length;
+          const initDuration = globalProfiler.getInitDuration();
           const status = {
             plugin: {
-              initialized: true,
+              initialized: mcpManager.isComplete(),
+              initState: mcpManager.getInitState(),
+              initMode,
+              initDurationMs: initDuration ? Math.round(initDuration) : null,
               configPath,
               uptime: process.uptime(),
               searches: searchCount,
@@ -38248,7 +38686,7 @@ var ToolboxPlugin = async (ctx) => {
             },
             tools: {
               total: totalTools,
-              available: totalTools,
+              indexed: bm25Index.size,
               serversWithTools: servers.filter((s) => s.tools.length > 0).length
             },
             health: {
@@ -38263,15 +38701,154 @@ var ToolboxPlugin = async (ctx) => {
           });
           return JSON.stringify(status, null, 2);
         }
+      }),
+      toolbox_perf: tool({
+        description: PERF_DESC,
+        args: {},
+        async execute() {
+          const report = globalProfiler.export();
+          return JSON.stringify({
+            ...report,
+            indexStats: bm25Index.getStats(),
+            config: {
+              initMode,
+              connectionTimeout: connectionConfig.connectTimeout,
+              requestTimeout: connectionConfig.requestTimeout,
+              retryAttempts: connectionConfig.retryAttempts
+            }
+          }, null, 2);
+        }
+      }),
+      toolbox_test: tool({
+        description: TEST_DESC,
+        args: {
+          timeout: tool.schema.number().optional().describe("Timeout per tool in ms (default: 10000)")
+        },
+        async execute(args) {
+          const startTime = performance.now();
+          const output = [];
+          output.push("=".repeat(80));
+          output.push("TOOLBOX TEST - Full Execution Log");
+          output.push("=".repeat(80));
+          output.push("");
+          try {
+            await ensureInitialized();
+          } catch (error92) {
+            output.push(`[FATAL] Failed to initialize: ${error92 instanceof Error ? error92.message : String(error92)}`);
+            return output.join(`
+`);
+          }
+          const allTools = mcpManager.getAllCatalogTools();
+          const timeout = args.timeout || 1e4;
+          output.push(`[INFO] Found ${allTools.length} tools to test`);
+          output.push(`[INFO] Timeout per tool: ${timeout}ms`);
+          output.push(`[INFO] Started at: ${new Date().toISOString()}`);
+          output.push("");
+          let passed = 0;
+          let failed = 0;
+          let timedOut = 0;
+          let skipped = 0;
+          for (let i = 0;i < allTools.length; i++) {
+            const catalogTool = allTools[i];
+            const toolId = catalogTool.idString;
+            const testNum = i + 1;
+            output.push("-".repeat(80));
+            output.push(`[TEST ${testNum}/${allTools.length}] ${toolId}`);
+            output.push("-".repeat(80));
+            const parsed = parseToolName(toolId);
+            if (!parsed) {
+              output.push(`[SKIP] Invalid tool name format`);
+              output.push("");
+              skipped++;
+              continue;
+            }
+            output.push(`[INFO] Server: ${parsed.serverName}`);
+            output.push(`[INFO] Tool: ${parsed.toolName}`);
+            output.push(`[INFO] Description: ${catalogTool.description || "(no description)"}`);
+            output.push("");
+            let testArgs;
+            let argsSource;
+            const predefinedArgs = TEST_PROMPTS[toolId];
+            if (predefinedArgs !== undefined) {
+              testArgs = predefinedArgs;
+              argsSource = "PREDEFINED";
+            } else {
+              testArgs = generateMinimalArgs(catalogTool.inputSchema);
+              argsSource = Object.keys(testArgs).length > 0 ? "GENERATED" : "EMPTY";
+            }
+            output.push(`[INPUT] Arguments source: ${argsSource}`);
+            output.push(`[INPUT] Request payload:`);
+            output.push(JSON.stringify(testArgs, null, 2).split(`
+`).map((line) => "        " + line).join(`
+`));
+            output.push("");
+            const toolStart = performance.now();
+            try {
+              const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error("TIMEOUT")), timeout);
+              });
+              const execPromise = mcpManager.callTool(parsed.serverName, parsed.toolName, testArgs);
+              const result = await Promise.race([execPromise, timeoutPromise]);
+              const duration5 = Math.round(performance.now() - toolStart);
+              output.push(`[OUTPUT] Response received in ${duration5}ms:`);
+              const resultStr = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+              output.push(resultStr.split(`
+`).map((line) => "        " + line).join(`
+`));
+              output.push("");
+              output.push(`[PASS] \u2713 Test passed in ${duration5}ms`);
+              passed++;
+            } catch (error92) {
+              const duration5 = Math.round(performance.now() - toolStart);
+              const errorMsg = error92 instanceof Error ? error92.message : String(error92);
+              if (errorMsg === "TIMEOUT") {
+                output.push(`[OUTPUT] No response - timed out after ${timeout}ms`);
+                output.push("");
+                output.push(`[TIMEOUT] \u2717 Test timed out after ${duration5}ms`);
+                timedOut++;
+              } else {
+                output.push(`[OUTPUT] Error response:`);
+                output.push(`        ${errorMsg}`);
+                output.push("");
+                output.push(`[FAIL] \u2717 Test failed in ${duration5}ms`);
+                output.push(`[FAIL] Error: ${errorMsg}`);
+                failed++;
+              }
+            }
+            output.push("");
+          }
+          const totalDuration = Math.round(performance.now() - startTime);
+          const total = allTools.length;
+          const successRate = total > 0 ? Math.round(passed / total * 100) : 0;
+          output.push("=".repeat(80));
+          output.push("TEST SUMMARY");
+          output.push("=".repeat(80));
+          output.push("");
+          output.push(`Total tests:    ${total}`);
+          output.push(`Passed:         ${passed} \u2713`);
+          output.push(`Failed:         ${failed} \u2717`);
+          output.push(`Timed out:      ${timedOut} \u23F1`);
+          output.push(`Skipped:        ${skipped} \u2298`);
+          output.push("");
+          output.push(`Success rate:   ${successRate}%`);
+          output.push(`Total duration: ${totalDuration}ms`);
+          output.push(`Finished at:    ${new Date().toISOString()}`);
+          output.push("");
+          output.push("=".repeat(80));
+          log("info", `Toolbox test completed: ${passed}/${total} passed in ${totalDuration}ms`, {
+            passed,
+            failed,
+            timedOut,
+            skipped,
+            total
+          });
+          return output.join(`
+`);
+        }
       })
     },
     "experimental.chat.system.transform": async (_input, output) => {
-      try {
-        await ensureInitialized();
-        output.system.push(generateSystemPrompt(mcpManager));
-      } catch {
-        output.system.push(SYSTEM_PROMPT_BASE);
-      }
+      output.system.push(generateSystemPrompt(serverNames));
     }
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-toolbox",
-  "version": "0.5.1",
+  "version": "0.7.0",
   "description": "Tool Search Tool Plugin for OpenCode - search and execute tools from MCP servers on-demand",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -16,7 +16,11 @@
     "dev": "bun --hot src/index.ts",
     "test": "bun test",
     "test:coverage": "bun test --coverage",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "bench": "bun run bench:search && bun run bench:init && bun run bench:concurrent",
+    "bench:search": "bun run bench/search.bench.ts",
+    "bench:init": "bun run bench/init.bench.ts",
+    "bench:concurrent": "bun run bench/concurrent.bench.ts"
   },
   "files": [
     "dist",