fix(session-aware): reject multiple explicit args in exclusivePairs at factory level; add test; update build_sim tests to expect factory message

Author: cameroncooke

src/mcp/tools/simulator/__tests__/build_sim.test.ts

@@ -68,9 +68,9 @@ describe('build_sim tool', () => {
 
       expect(result.isError).toBe(true);
       expect(result.content[0].text).toContain('Parameter validation failed');
-      expect(result.content[0].text).toContain(
-        'projectPath and workspacePath are mutually exclusive',
-      );
+      expect(result.content[0].text).toContain('Mutually exclusive parameters provided');
+      expect(result.content[0].text).toContain('projectPath');
+      expect(result.content[0].text).toContain('workspacePath');
     });
 
     it('should handle empty workspacePath parameter', async () => {
@@ -158,9 +158,9 @@ describe('build_sim tool', () => {
 
       expect(result.isError).toBe(true);
       expect(result.content[0].text).toContain('Parameter validation failed');
-      expect(result.content[0].text).toContain(
-        'simulatorId and simulatorName are mutually exclusive',
-      );
+      expect(result.content[0].text).toContain('Mutually exclusive parameters provided');
+      expect(result.content[0].text).toContain('simulatorId');
+      expect(result.content[0].text).toContain('simulatorName');
     });
 
     it('should handle empty simulatorName parameter', async () => {

src/utils/__tests__/session-aware-tool-factory.test.ts

@@ -155,4 +155,36 @@ describe('createSessionAwareTool', () => {
     expect(res.isError).toBe(false);
     expect(res.content[0].text).toBe('OK');
   });
+
+  it('rejects when multiple explicit args in an exclusive pair are provided (factory-level)', async () => {
+    const internalSchemaNoXor = z.object({
+      scheme: z.string(),
+      projectPath: z.string().optional(),
+      workspacePath: z.string().optional(),
+    });
+
+    const handlerNoXor = createSessionAwareTool<z.infer<typeof internalSchemaNoXor>>({
+      internalSchema: internalSchemaNoXor,
+      logicFunction: (async () => ({
+        content: [{ type: 'text', text: 'OK' }],
+        isError: false,
+      })) as any,
+      getExecutor: () => createMockExecutor({ success: true }),
+      requirements: [{ allOf: ['scheme'], message: 'scheme is required' }],
+      exclusivePairs: [['projectPath', 'workspacePath']],
+    });
+
+    const res = await handlerNoXor({
+      scheme: 'App',
+      projectPath: '/path/a.xcodeproj',
+      workspacePath: '/path/b.xcworkspace',
+    });
+
+    expect(res.isError).toBe(true);
+    const msg = res.content[0].text;
+    expect(msg).toContain('Parameter validation failed');
+    expect(msg).toContain('Mutually exclusive parameters provided');
+    expect(msg).toContain('projectPath');
+    expect(msg).toContain('workspacePath');
+  });
 });

src/utils/typed-tool-factory.ts

@@ -95,6 +95,20 @@ export function createSessionAwareTool<TParams>(opts: {
         if (v !== null && v !== undefined) sanitizedArgs[k] = v;
       }
 
+      // Factory-level mutual exclusivity check: if user provides multiple explicit values
+      // within an exclusive group, reject early even if tool schema doesn't enforce XOR.
+      for (const pair of exclusivePairs) {
+        const provided = pair.filter((k) => Object.prototype.hasOwnProperty.call(sanitizedArgs, k));
+        if (provided.length >= 2) {
+          return createErrorResponse(
+            'Parameter validation failed',
+            `Invalid parameters:\nMutually exclusive parameters provided: ${provided.join(
+              ', ',
+            )}. Provide only one.`,
+          );
+        }
+      }
+
       // Start with session defaults merged with explicit args (args override session)
       const merged: Record<string, unknown> = { ...sessionStore.getAll(), ...sanitizedArgs };