Simplify tool filter validation logic and add ambiguous filter test

- Remove unnecessary validation in #matchesToolFilter
- Malformed filter strings naturally fail to match
- Add test case for ambiguous filter names

Author: peteski22

src/client.ts

@@ -840,28 +840,26 @@ export class McpdClient {
    * Check if a tool matches the tool filter.
    *
    * Supports two formats:
-   * - Raw tool name: "get_current_time" (matches tool name only)
-   * - Server-prefixed name: "time__get_current_time" (server + TOOL_SEPARATOR + tool)
+   * - Raw tool name: "get_current_time" (matches across all servers)
+   * - Server-prefixed: "time__get_current_time" (matches specific server + tool)
+   *
+   * When a filter contains "__", it's first checked as server-prefixed (exact match).
+   * If that fails, it's checked as a raw tool name. This handles tools whose names
+   * contain "__" (e.g., "my__special__tool").
    *
    * @param tool The tool to check.
    * @param tools List of tool names/patterns to match against.
    * @returns True if the tool matches any item in the filter.
    */
   #matchesToolFilter(tool: AgentFunction, tools: string[]): boolean {
     return tools.some((filterItem) => {
-      const separatorIndex = filterItem.indexOf(TOOL_SEPARATOR);
-      if (separatorIndex !== -1) {
-        const leftPart = filterItem.slice(0, separatorIndex).trim();
-        const rightPart = filterItem
-          .slice(separatorIndex + TOOL_SEPARATOR.length)
-          .trim();
-
-        if (leftPart && rightPart && filterItem === tool.name) {
-          return true;
-        }
+      if (filterItem.indexOf(TOOL_SEPARATOR) === -1) {
+        // Match against raw tool name
+        return filterItem === tool._toolName;
       }
 
-      return filterItem === tool._toolName;
+      // Try prefixed match first, then fall back to raw match
+      return filterItem === tool.name || filterItem === tool._toolName;
     });
   }
 }

tests/unit/client.test.ts

@@ -761,6 +761,75 @@ describe("McpdClient", () => {
       expect(prefixedFilter).toHaveLength(1);
       expect(prefixedFilter[0]?.name).toBe("test__my__special__tool");
     });
+
+    it("should prefer prefixed format when filter is ambiguous", async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ["my", "other"],
+      });
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          servers: [
+            {
+              name: "my",
+              status: "ok",
+              latency: "1ms",
+              lastChecked: "2025-10-07T15:00:00Z",
+              lastSuccessful: "2025-10-07T15:00:00Z",
+            },
+            {
+              name: "other",
+              status: "ok",
+              latency: "1ms",
+              lastChecked: "2025-10-07T15:00:00Z",
+              lastSuccessful: "2025-10-07T15:00:00Z",
+            },
+          ],
+        }),
+      });
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          tools: [
+            {
+              name: "special__tool",
+              description: "Tool from 'my' server",
+              inputSchema: { type: "object", properties: {} },
+            },
+          ],
+        }),
+      });
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          tools: [
+            {
+              name: "my__special__tool",
+              description: "Tool from 'other' server",
+              inputSchema: { type: "object", properties: {} },
+            },
+          ],
+        }),
+      });
+
+      const tools = await client.getAgentTools({
+        tools: ["my__special__tool"],
+      });
+
+      expect(tools).toHaveLength(2);
+
+      const prefixedMatch = tools.find((t) => t._serverName === "my");
+      expect(prefixedMatch?._toolName).toBe("special__tool");
+      expect(prefixedMatch?.name).toBe("my__special__tool");
+
+      const rawMatch = tools.find((t) => t._serverName === "other");
+      expect(rawMatch?._toolName).toBe("my__special__tool");
+      expect(rawMatch?.name).toBe("other__my__special__tool");
+    });
   });
 
   describe("clearAgentToolsCache()", () => {