opencode-toolbox 0.5.0 → 0.6.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
 
@@ -207,17 +207,49 @@ Returns a comprehensive status object:
 
 ### /toolbox-status Slash Command
 
-The plugin automatically creates and maintains a `/toolbox-status` slash command:
+The plugin automatically creates a `/toolbox-status` slash command on first launch:
 
 ```
 ~/.config/opencode/command/toolbox-status.md
 ```
 
-- **Auto-created** on first plugin launch
-- **Auto-updated** when plugin version changes (tracked via `toolbox_version` in frontmatter)
-
 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

@@ -19267,7 +19267,7 @@ function tool(input) {
 }
 tool.schema = exports_external;
 // src/plugin.ts
-import { appendFile, mkdir, writeFile, readFile } from "fs/promises";
+import { appendFile, mkdir, writeFile, access } from "fs/promises";
 
 // node_modules/zod/v4/classic/external.js
 var exports_external2 = {};
@@ -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,39 +37868,134 @@ 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 = [];
@@ -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;
@@ -37911,69 +38259,18 @@ function generateSignature(tool3) {
   }).join(", ");
   return `${tool3.id.name}(${argList})`;
 }
-// package.json
-var package_default = {
-  name: "opencode-toolbox",
-  version: "0.5.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",
-  type: "module",
-  exports: {
-    ".": {
-      import: "./dist/index.js",
-      types: "./dist/index.d.ts"
-    }
-  },
-  scripts: {
-    build: "bun build src/index.ts --outdir dist --target bun",
-    dev: "bun --hot src/index.ts",
-    test: "bun test",
-    "test:coverage": "bun test --coverage",
-    typecheck: "tsc --noEmit"
-  },
-  files: [
-    "dist",
-    "README.md"
-  ],
-  keywords: [
-    "opencode",
-    "plugin",
-    "tool-search",
-    "mcp"
-  ],
-  license: "MIT",
-  devDependencies: {
-    "@types/bun": "latest",
-    typescript: "^5.9.3"
-  },
-  peerDependencies: {
-    typescript: "^5"
-  },
-  dependencies: {
-    "@modelcontextprotocol/sdk": "^1.25.1",
-    "@opencode-ai/plugin": "latest",
-    "jsonc-parser": "^3.3.1",
-    zod: "^4.3.5"
-  }
-};
-
 // src/plugin.ts
-var PLUGIN_VERSION = package_default.version;
 var DEFAULT_CONFIG_PATH = `${process.env.HOME}/.config/opencode/toolbox.jsonc`;
 var LOG_FILE_PATH = `${process.env.HOME}/.local/share/opencode/toolbox.log`;
 var LOG_DIR = `${process.env.HOME}/.local/share/opencode`;
 var COMMAND_DIR = `${process.env.HOME}/.config/opencode/command`;
 var COMMAND_FILE_PATH = `${COMMAND_DIR}/toolbox-status.md`;
-function getCommandContent() {
-  return `---
+var COMMAND_CONTENT = `---
 description: Check toolbox plugin status and server health
-toolbox_version: ${PLUGIN_VERSION}
 ---
-Run toolbox_status({}) and show me the results in a readable format.
+Run toolbox_status({}) tool and show me the results in a readable format.
 Highlight any failed servers or issues.
 `;
-}
 function parseToolName(fullName) {
   const underscoreIndex = fullName.indexOf("_");
   if (underscoreIndex === -1) {
@@ -38015,7 +38312,13 @@ 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 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}
@@ -38023,27 +38326,20 @@ function log(level, message, extra) {
   mkdir(LOG_DIR, { recursive: true }).then(() => appendFile(LOG_FILE_PATH, line)).catch(() => {});
 }
 function ensureCommandFile() {
-  const content = getCommandContent();
-  readFile(COMMAND_FILE_PATH, "utf-8").then((existing) => {
-    const versionMatch = existing.match(/toolbox_version:\s*([^\n]+)/);
-    const existingVersion = versionMatch?.[1]?.trim() ?? null;
-    if (existingVersion !== PLUGIN_VERSION) {
-      return writeFile(COMMAND_FILE_PATH, content).then(() => {
-        log("info", `Updated /toolbox-status command (${existingVersion} -> ${PLUGIN_VERSION})`);
-      });
-    }
-  }).catch(() => {
-    mkdir(COMMAND_DIR, { recursive: true }).then(() => writeFile(COMMAND_FILE_PATH, content)).then(() => log("info", `Created /toolbox-status command (v${PLUGIN_VERSION})`)).catch(() => {});
+  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(() => {});
   });
 }
 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_.*" })
@@ -38064,13 +38360,12 @@ function generateSystemPrompt(mcpManager) {
   }
   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
+${Object.entries(toolboxSchema).map(([server, tools]) => `- ${server}: ${tools.map((t) => t.split("_").slice(1).join("_")).join(", ")}`).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);
@@ -38080,53 +38375,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: {
@@ -38137,9 +38443,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)}`
@@ -38149,11 +38457,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);
         }
@@ -38165,9 +38475,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)}`
@@ -38177,6 +38489,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({
@@ -38184,11 +38497,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);
         }
@@ -38200,9 +38514,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)}`
@@ -38210,6 +38526,7 @@ var ToolboxPlugin = async (ctx) => {
           }
           const parsed = parseToolName(args.name);
           if (!parsed) {
+            timer();
             log("warn", `Invalid tool name format: ${args.name}`, {
               toolName: args.name
             });
@@ -38223,6 +38540,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
@@ -38235,11 +38553,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
@@ -38249,11 +38566,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,
@@ -38266,7 +38585,7 @@ var ToolboxPlugin = async (ctx) => {
         description: STATUS_DESC,
         args: {},
         async execute() {
-          if (!initialized) {
+          if (!mcpManager.isReady()) {
             try {
               await ensureInitialized();
             } catch (error92) {
@@ -38282,9 +38601,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,
@@ -38308,7 +38631,7 @@ var ToolboxPlugin = async (ctx) => {
             },
             tools: {
               total: totalTools,
-              available: totalTools,
+              indexed: bm25Index.size,
               serversWithTools: servers.filter((s) => s.tools.length > 0).length
             },
             health: {
@@ -38323,15 +38646,32 @@ 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);
+        }
       })
     },
     "experimental.chat.system.transform": async (_input, output) => {
-      try {
-        await ensureInitialized();
-        output.system.push(generateSystemPrompt(mcpManager));
-      } catch {
-        output.system.push(SYSTEM_PROMPT_BASE);
+      if (!mcpManager.isReady() && initMode === "eager") {
+        try {
+          await mcpManager.waitForPartial();
+        } catch {}
       }
+      output.system.push(generateSystemPrompt(mcpManager));
     }
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-toolbox",
-  "version": "0.5.0",
+  "version": "0.6.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",