@nexvora/mcp-server 0.3.1 → 0.3.3

package/src/__tests__/integration/agentstack.integration.test.ts

@@ -1,259 +0,0 @@
-import { http, HttpResponse } from "msw";
-import { setupServer } from "msw/node";
-
-import { nexvora_agentstack_answer } from "../../tools/nexvora_agentstack_answer.js";
-import { nexvora_agentstack_ask } from "../../tools/nexvora_agentstack_ask.js";
-import { nexvora_agentstack_search } from "../../tools/nexvora_agentstack_search.js";
-import {
-  BASE_URL,
-  REFRESH_RESPONSE,
-  makeClient,
-  makeClientWithStore,
-  silentAuditHandler,
-} from "./helpers.js";
-
-const QUESTION_PAGE = {
-  content: [
-    {
-      id: "q-001",
-      title: "How do I optimise a Spring Boot startup time?",
-      bountyCoins: 20,
-      status: "OPEN",
-      createdAt: new Date().toISOString(),
-      answers: [],
-    },
-  ],
-  page: 0,
-  size: 10,
-  totalElements: 1,
-  totalPages: 1,
-};
-
-const QUESTION_RESPONSE = {
-  id: "q-new-001",
-  title: "What is the best MCP framework?",
-  bountyCoins: 10,
-  status: "OPEN",
-};
-
-const ANSWER_RESPONSE = {
-  id: "a-001",
-  questionId: "q-001",
-  content: "Use Spring AI with MCP adapter.",
-  status: "SUBMITTED",
-};
-
-const server = setupServer(silentAuditHandler);
-
-beforeAll(() => server.listen({ onUnhandledRequest: "warn" }));
-afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
-
-// ── nexvora_agentstack_search ────────────────────────────────────────────────
-
-describe("nexvora_agentstack_search integration", () => {
-  it("happy path: returns formatted question listing", async () => {
-    server.use(
-      http.get(`${BASE_URL}/agentstack/questions`, () => HttpResponse.json(QUESTION_PAGE)),
-    );
-
-    const result = await nexvora_agentstack_search.handler(
-      { status: "OPEN", page: 0, size: 10 },
-      makeClient(),
-    );
-
-    expect(result).toContain("AgentStack Questions");
-    expect(result).toContain("Spring Boot startup");
-    expect(result).toContain("20");
-  });
-
-  it("error path: returns friendly message on 401", async () => {
-    server.use(
-      http.get(`${BASE_URL}/agentstack/questions`, () =>
-        new Response("Unauthorized", { status: 401 }),
-      ),
-    );
-
-    const result = await nexvora_agentstack_search.handler(
-      { status: "OPEN", page: 0, size: 10 },
-      makeClient(),
-    );
-
-    expect(result).toContain("Not authenticated");
-  });
-
-  it("appends domainTag to query string when provided", async () => {
-    let receivedUrl = "";
-    server.use(
-      http.get(`${BASE_URL}/agentstack/questions`, ({ request }) => {
-        receivedUrl = request.url;
-        return HttpResponse.json({ ...QUESTION_PAGE, content: [] });
-      }),
-    );
-
-    await nexvora_agentstack_search.handler(
-      { status: "OPEN", page: 0, size: 10, domainTag: "spring" },
-      makeClient(),
-    );
-
-    expect(receivedUrl).toContain("domainTag=spring");
-  });
-
-  it("auth refresh: retries after 401 with refreshed token", async () => {
-    const { client, cleanup } = makeClientWithStore();
-
-    let callCount = 0;
-    server.use(
-      http.get(`${BASE_URL}/agentstack/questions`, () => {
-        if (++callCount === 1) return new Response("Unauthorized", { status: 401 });
-        return HttpResponse.json(QUESTION_PAGE);
-      }),
-      http.post(`${BASE_URL}/auth/refresh`, () => HttpResponse.json(REFRESH_RESPONSE)),
-    );
-
-    try {
-      const result = await nexvora_agentstack_search.handler(
-        { status: "OPEN", page: 0, size: 10 },
-        client,
-      );
-      expect(result).toContain("Spring Boot startup");
-      expect(callCount).toBe(2);
-    } finally {
-      cleanup();
-    }
-  });
-});
-
-// ── nexvora_agentstack_ask ────────────────────────────────────────────────────
-
-describe("nexvora_agentstack_ask integration", () => {
-  it("happy path: posts question and returns confirmation", async () => {
-    server.use(
-      http.post(`${BASE_URL}/agentstack/questions`, () =>
-        HttpResponse.json(QUESTION_RESPONSE),
-      ),
-    );
-
-    const result = await nexvora_agentstack_ask.handler(
-      { title: "What is the best MCP framework?", body: "Details here", bountyCoins: 0 },
-      makeClient(),
-    );
-
-    expect(result).toContain("Question Posted");
-    expect(result).toContain("q-new-001");
-    expect(result).toContain("What is the best MCP framework?");
-  });
-
-  it("error path: returns insufficient-balance message when wallet too low", async () => {
-    server.use(
-      http.get(`${BASE_URL}/wallet`, () =>
-        HttpResponse.json({ coinBalance: 5 }),
-      ),
-    );
-
-    const result = await nexvora_agentstack_ask.handler(
-      { title: "Bounty Q", body: "body", bountyCoins: 50 },
-      makeClient(),
-    );
-
-    expect(result).toContain("Insufficient balance");
-    expect(result).toContain("5");   // current balance
-    expect(result).toContain("50");  // required bounty
-  });
-
-  it("auth refresh: retries question post after 401", async () => {
-    const { client, cleanup } = makeClientWithStore();
-
-    let callCount = 0;
-    server.use(
-      http.post(`${BASE_URL}/agentstack/questions`, () => {
-        if (++callCount === 1) return new Response("Unauthorized", { status: 401 });
-        return HttpResponse.json(QUESTION_RESPONSE);
-      }),
-      http.post(`${BASE_URL}/auth/refresh`, () => HttpResponse.json(REFRESH_RESPONSE)),
-    );
-
-    try {
-      const result = await nexvora_agentstack_ask.handler(
-        { title: "test", body: "body", bountyCoins: 0 },
-        client,
-      );
-      expect(result).toContain("Question Posted");
-      expect(callCount).toBe(2);
-    } finally {
-      cleanup();
-    }
-  });
-});
-
-// ── nexvora_agentstack_answer ─────────────────────────────────────────────────
-
-describe("nexvora_agentstack_answer integration", () => {
-  it("happy path: submits answer and returns confirmation", async () => {
-    server.use(
-      http.post(`${BASE_URL}/agentstack/questions/q-001/answer`, () =>
-        HttpResponse.json(ANSWER_RESPONSE),
-      ),
-    );
-
-    const result = await nexvora_agentstack_answer.handler(
-      {
-        questionId: "q-001",
-        content: "Use Spring AI with MCP adapter.",
-        agentId: "00000000-0000-0000-0000-000000000001",
-      },
-      makeClient(),
-    );
-
-    expect(result).toContain("Answer Submitted");
-    expect(result).toContain("a-001");
-  });
-
-  it("error path: returns 404 message when question not found", async () => {
-    server.use(
-      http.post(`${BASE_URL}/agentstack/questions/q-missing/answer`, () =>
-        new Response("Not Found", { status: 404 }),
-      ),
-    );
-
-    const result = await nexvora_agentstack_answer.handler(
-      {
-        questionId: "q-missing",
-        content: "answer",
-        agentId: "00000000-0000-0000-0000-000000000001",
-      },
-      makeClient(),
-    );
-
-    expect(result).toContain("q-missing");
-    expect(result).toContain("not found");
-  });
-
-  it("auth refresh: retries after 401", async () => {
-    const { client, cleanup } = makeClientWithStore();
-
-    let callCount = 0;
-    server.use(
-      http.post(`${BASE_URL}/agentstack/questions/q-001/answer`, () => {
-        if (++callCount === 1) return new Response("Unauthorized", { status: 401 });
-        return HttpResponse.json(ANSWER_RESPONSE);
-      }),
-      http.post(`${BASE_URL}/auth/refresh`, () => HttpResponse.json(REFRESH_RESPONSE)),
-    );
-
-    try {
-      const result = await nexvora_agentstack_answer.handler(
-        {
-          questionId: "q-001",
-          content: "answer",
-          agentId: "00000000-0000-0000-0000-000000000001",
-        },
-        client,
-      );
-      expect(result).toContain("Answer Submitted");
-      expect(callCount).toBe(2);
-    } finally {
-      cleanup();
-    }
-  });
-});

package/src/__tests__/integration/auth_refresh.integration.test.ts

@@ -1,227 +0,0 @@
-import * as fs from "node:fs";
-
-import { http, HttpResponse } from "msw";
-import { setupServer } from "msw/node";
-
-import { SessionExpiredError } from "../../NexvoraClient.js";
-import { nexvora_submit_task } from "../../tools/nexvora_submit_task.js";
-import {
-  BASE_URL,
-  ACCESS_TOKEN,
-  REFRESH_RESPONSE,
-  makeClientWithStore,
-  silentAuditHandler,
-} from "./helpers.js";
-
-const TASK_RESPONSE = {
-  id: "task-auth-001",
-  status: "COMPLETED",
-  result: "Auth refresh worked.",
-  coinsCharged: 3,
-};
-
-const server = setupServer(silentAuditHandler);
-
-beforeAll(() => server.listen({ onUnhandledRequest: "warn" }));
-afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
-
-// ── Proactive refresh (token near expiry) ─────────────────────────────────────
-
-describe("proactive token refresh", () => {
-  it("refreshes before API call when token expires within 60 seconds", async () => {
-    const nowSecs = Math.floor(Date.now() / 1000);
-    const { client, cleanup } = makeClientWithStore({ expiresAt: nowSecs + 30 });
-
-    let refreshCalled = false;
-    let taskAuthHeader = "";
-
-    server.use(
-      http.post(`${BASE_URL}/auth/refresh`, () => {
-        refreshCalled = true;
-        return HttpResponse.json(REFRESH_RESPONSE);
-      }),
-      http.post(`${BASE_URL}/tasks`, ({ request }) => {
-        taskAuthHeader = request.headers.get("Authorization") ?? "";
-        return HttpResponse.json(TASK_RESPONSE);
-      }),
-    );
-
-    try {
-      await nexvora_submit_task.handler({ prompt: "test", model: "PLATFORM_CHOICE" }, client);
-      expect(refreshCalled).toBe(true);
-      expect(taskAuthHeader).toBe(`Bearer ${REFRESH_RESPONSE.accessToken}`);
-    } finally {
-      cleanup();
-    }
-  });
-
-  it("skips refresh when token is valid beyond the 60-second window", async () => {
-    const nowSecs = Math.floor(Date.now() / 1000);
-    const { client, cleanup } = makeClientWithStore({ expiresAt: nowSecs + 3600 });
-
-    let refreshCalled = false;
-    server.use(
-      http.post(`${BASE_URL}/auth/refresh`, () => {
-        refreshCalled = true;
-        return HttpResponse.json(REFRESH_RESPONSE);
-      }),
-      http.post(`${BASE_URL}/tasks`, () => HttpResponse.json(TASK_RESPONSE)),
-    );
-
-    try {
-      await nexvora_submit_task.handler({ prompt: "test", model: "PLATFORM_CHOICE" }, client);
-      expect(refreshCalled).toBe(false);
-    } finally {
-      cleanup();
-    }
-  });
-});
-
-// ── Reactive refresh (401 → refresh → retry) ──────────────────────────────────
-
-describe("reactive token refresh on 401", () => {
-  it("retries the original request with the new token after receiving 401", async () => {
-    const { client, cleanup } = makeClientWithStore();
-
-    let taskCallCount = 0;
-    let lastAuthHeader = "";
-
-    server.use(
-      http.post(`${BASE_URL}/tasks`, ({ request }) => {
-        lastAuthHeader = request.headers.get("Authorization") ?? "";
-        if (++taskCallCount === 1) return new Response("Unauthorized", { status: 401 });
-        return HttpResponse.json(TASK_RESPONSE);
-      }),
-      http.post(`${BASE_URL}/auth/refresh`, () => HttpResponse.json(REFRESH_RESPONSE)),
-    );
-
-    try {
-      const result = await nexvora_submit_task.handler(
-        { prompt: "test", model: "PLATFORM_CHOICE" },
-        client,
-      );
-      expect(result).toMatchObject({ id: "task-auth-001" });
-      expect(taskCallCount).toBe(2);
-      expect(lastAuthHeader).toBe(`Bearer ${REFRESH_RESPONSE.accessToken}`);
-    } finally {
-      cleanup();
-    }
-  });
-
-  it("throws SessionExpiredError when the refresh endpoint itself returns 401", async () => {
-    const { client, cleanup } = makeClientWithStore();
-
-    server.use(
-      http.post(`${BASE_URL}/tasks`, () => new Response("Unauthorized", { status: 401 })),
-      http.post(`${BASE_URL}/auth/refresh`, () => new Response("Unauthorized", { status: 401 })),
-    );
-
-    try {
-      await expect(
-        nexvora_submit_task.handler({ prompt: "test", model: "PLATFORM_CHOICE" }, client),
-      ).rejects.toBeInstanceOf(SessionExpiredError);
-    } finally {
-      cleanup();
-    }
-  });
-
-  it("does NOT retry on 401 when no configStore is present (bare client)", async () => {
-    // makeClient() creates a bare client without a configStore
-    const { NexvoraClient } = await import("../../NexvoraClient.js");
-    const client = new NexvoraClient({ baseUrl: BASE_URL, accessToken: ACCESS_TOKEN });
-
-    let refreshCalled = false;
-    server.use(
-      http.post(`${BASE_URL}/tasks`, () => new Response("Unauthorized", { status: 401 })),
-      http.post(`${BASE_URL}/auth/refresh`, () => {
-        refreshCalled = true;
-        return HttpResponse.json(REFRESH_RESPONSE);
-      }),
-    );
-
-    // Should throw NexvoraApiError(401), not retry
-    const { NexvoraApiError } = await import("../../NexvoraClient.js");
-    await expect(
-      nexvora_submit_task.handler({ prompt: "test", model: "PLATFORM_CHOICE" }, client),
-    ).rejects.toBeInstanceOf(NexvoraApiError);
-
-    expect(refreshCalled).toBe(false);
-  });
-});
-
-// ── Config store persistence ───────────────────────────────────────────────────
-
-describe("config store updated after refresh", () => {
-  it("writes new accessToken, refreshToken, and expiresAt to disk after refresh", async () => {
-    const { client, configPath, cleanup } = makeClientWithStore();
-
-    server.use(
-      http.post(`${BASE_URL}/tasks`, ({ request }) => {
-        const auth = request.headers.get("Authorization") ?? "";
-        if (auth.includes("int-test-access-token")) {
-          return new Response("Unauthorized", { status: 401 });
-        }
-        return HttpResponse.json(TASK_RESPONSE);
-      }),
-      http.post(`${BASE_URL}/auth/refresh`, () => HttpResponse.json(REFRESH_RESPONSE)),
-    );
-
-    try {
-      await nexvora_submit_task.handler({ prompt: "test", model: "PLATFORM_CHOICE" }, client);
-
-      const saved = JSON.parse(fs.readFileSync(configPath, "utf8")) as Record<string, unknown>;
-      expect(saved.accessToken).toBe(REFRESH_RESPONSE.accessToken);
-      expect(saved.refreshToken).toBe(REFRESH_RESPONSE.refreshToken);
-      expect(saved.expiresAt).toBe(REFRESH_RESPONSE.expiresAt);
-    } finally {
-      cleanup();
-    }
-  });
-});
-
-// ── Concurrent refresh deduplication ─────────────────────────────────────────
-
-describe("concurrent refresh deduplication", () => {
-  it("issues only one refresh request when multiple concurrent calls receive 401", async () => {
-    const { client, cleanup } = makeClientWithStore();
-
-    let refreshCallCount = 0;
-    let taskCallCount = 0;
-
-    server.use(
-      http.post(`${BASE_URL}/tasks`, ({ request }) => {
-        const auth = request.headers.get("Authorization") ?? "";
-        taskCallCount++;
-        // Return 401 as long as the original token is used
-        if (auth.includes("int-test-access-token")) {
-          return new Response("Unauthorized", { status: 401 });
-        }
-        return HttpResponse.json({ ...TASK_RESPONSE, id: `task-${taskCallCount}` });
-      }),
-      http.post(`${BASE_URL}/auth/refresh`, async () => {
-        refreshCallCount++;
-        return HttpResponse.json(REFRESH_RESPONSE);
-      }),
-    );
-
-    try {
-      // Fire three concurrent task calls — all will see 401 before refresh completes
-      const results = await Promise.all([
-        nexvora_submit_task.handler({ prompt: "p1", model: "PLATFORM_CHOICE" }, client),
-        nexvora_submit_task.handler({ prompt: "p2", model: "PLATFORM_CHOICE" }, client),
-        nexvora_submit_task.handler({ prompt: "p3", model: "PLATFORM_CHOICE" }, client),
-      ]);
-
-      // Only one refresh must have occurred despite three concurrent 401s
-      expect(refreshCallCount).toBe(1);
-
-      // All three requests must have succeeded
-      for (const result of results) {
-        expect(result).toMatchObject({ status: "COMPLETED" });
-      }
-    } finally {
-      cleanup();
-    }
-  });
-});

package/src/__tests__/integration/consulting.integration.test.ts

@@ -1,213 +0,0 @@
-import { jest } from "@jest/globals";
-import { http, HttpResponse } from "msw";
-import { setupServer } from "msw/node";
-
-import { nexvora_consulting_book } from "../../tools/nexvora_consulting_book.js";
-import { nexvora_consulting_search } from "../../tools/nexvora_consulting_search.js";
-import {
-  BASE_URL,
-  REFRESH_RESPONSE,
-  WALLET_RESPONSE,
-  makeClient,
-  makeClientWithStore,
-  silentAuditHandler,
-} from "./helpers.js";
-
-const LISTING_ID = "00000000-0000-0000-0000-000000000042";
-
-const CONSULTING_PAGE = {
-  content: [
-    {
-      id: LISTING_ID,
-      agentId: "00000000-0000-0000-0000-000000000010",
-      agentName: "ArchitectBot",
-      description: "Expert Spring Boot architecture consultant.",
-      hourlyRateCoins: 60,
-      availableHours: ["09:00-12:00", "14:00-18:00"],
-      timezone: "UTC",
-      domainTags: ["java", "spring"],
-    },
-  ],
-  page: 0,
-  size: 10,
-  totalElements: 1,
-  totalPages: 1,
-};
-
-const LISTING_DETAIL = {
-  id: LISTING_ID,
-  agentName: "ArchitectBot",
-  hourlyRateCoins: 60,
-};
-
-const BOOKING_RESPONSE = {
-  id: "booking-001",
-  listingId: LISTING_ID,
-  scheduledAt: "2026-06-01T10:00:00Z",
-  durationMinutes: 30,
-  totalCostCoins: 30,
-  status: "CONFIRMED",
-};
-
-// Use a fixed fake epoch for consistent Date.now() across tests
-const FAKE_NOW = 1_748_340_000_000;
-// scheduledAt that is always 1 hour in the future relative to FAKE_NOW
-const FUTURE_AT = new Date(FAKE_NOW + 3_600_000).toISOString();
-
-const server = setupServer(silentAuditHandler);
-
-beforeAll(() => server.listen({ onUnhandledRequest: "warn" }));
-beforeEach(() => jest.useFakeTimers({ now: FAKE_NOW }));
-afterEach(() => {
-  server.resetHandlers();
-  jest.useRealTimers();
-});
-afterAll(() => server.close());
-
-// ── nexvora_consulting_search ─────────────────────────────────────────────────
-
-describe("nexvora_consulting_search integration", () => {
-  it("happy path: returns formatted listing cards", async () => {
-    server.use(
-      http.get(`${BASE_URL}/consulting`, () => HttpResponse.json(CONSULTING_PAGE)),
-    );
-
-    const result = await nexvora_consulting_search.handler({}, makeClient());
-
-    expect(result).toContain("Consulting Listings");
-    expect(result).toContain("ArchitectBot");
-    expect(result).toContain("60");  // coins per hour
-  });
-
-  it("error path: returns friendly message on 401", async () => {
-    server.use(
-      http.get(`${BASE_URL}/consulting`, () =>
-        new Response("Unauthorized", { status: 401 }),
-      ),
-    );
-
-    const result = await nexvora_consulting_search.handler({}, makeClient());
-
-    expect(result).toContain("Not authenticated");
-  });
-
-  it("auth refresh: retries after 401 and returns listings", async () => {
-    const { client, cleanup } = makeClientWithStore();
-
-    let callCount = 0;
-    server.use(
-      http.get(`${BASE_URL}/consulting`, () => {
-        if (++callCount === 1) return new Response("Unauthorized", { status: 401 });
-        return HttpResponse.json(CONSULTING_PAGE);
-      }),
-      http.post(`${BASE_URL}/auth/refresh`, () => HttpResponse.json(REFRESH_RESPONSE)),
-    );
-
-    try {
-      const result = await nexvora_consulting_search.handler({}, client);
-      expect(result).toContain("ArchitectBot");
-      expect(callCount).toBe(2);
-    } finally {
-      cleanup();
-    }
-  });
-});
-
-// ── nexvora_consulting_book ───────────────────────────────────────────────────
-
-describe("nexvora_consulting_book integration", () => {
-  it("preview mode (confirm=false): returns cost breakdown without booking", async () => {
-    server.use(
-      http.get(`${BASE_URL}/consulting/${LISTING_ID}`, () => HttpResponse.json(LISTING_DETAIL)),
-      http.get(`${BASE_URL}/wallet`, () => HttpResponse.json(WALLET_RESPONSE)),
-    );
-
-    const result = await nexvora_consulting_book.handler(
-      { listingId: LISTING_ID, scheduledAt: FUTURE_AT, durationMinutes: 30, confirm: false },
-      makeClient(),
-    );
-
-    expect(result).toContain("Booking Preview");
-    expect(result).toContain("ArchitectBot");
-    expect(result).toContain("30 coins"); // 60/hr × 0.5hr = 30
-    expect(result).toContain("confirm: true");
-  });
-
-  it("confirm mode (confirm=true): creates booking and returns confirmation", async () => {
-    server.use(
-      http.get(`${BASE_URL}/consulting/${LISTING_ID}`, () => HttpResponse.json(LISTING_DETAIL)),
-      http.get(`${BASE_URL}/wallet`, () => HttpResponse.json(WALLET_RESPONSE)),
-      http.post(`${BASE_URL}/consulting/${LISTING_ID}/bookings`, () =>
-        HttpResponse.json(BOOKING_RESPONSE, { status: 201 }),
-      ),
-    );
-
-    const result = await nexvora_consulting_book.handler(
-      { listingId: LISTING_ID, scheduledAt: FUTURE_AT, durationMinutes: 30, confirm: true },
-      makeClient(),
-    );
-
-    expect(result).toContain("Booking Confirmed");
-    expect(result).toContain("booking-001");
-    expect(result).toContain("30 coins");
-  });
-
-  it("error path: returns slot-conflict message on 409", async () => {
-    server.use(
-      http.get(`${BASE_URL}/consulting/${LISTING_ID}`, () => HttpResponse.json(LISTING_DETAIL)),
-      http.get(`${BASE_URL}/wallet`, () => HttpResponse.json(WALLET_RESPONSE)),
-      http.post(`${BASE_URL}/consulting/${LISTING_ID}/bookings`, () =>
-        new Response("Conflict", { status: 409 }),
-      ),
-    );
-
-    const result = await nexvora_consulting_book.handler(
-      { listingId: LISTING_ID, scheduledAt: FUTURE_AT, durationMinutes: 30, confirm: true },
-      makeClient(),
-    );
-
-    expect(result).toContain("no longer available");
-  });
-
-  it("error path: returns not-found message when listing ID is unknown", async () => {
-    const unknownId = "00000000-ffff-0000-0000-000000000000";
-    server.use(
-      http.get(`${BASE_URL}/consulting/${unknownId}`, () =>
-        new Response("Not Found", { status: 404 }),
-      ),
-      http.get(`${BASE_URL}/wallet`, () => HttpResponse.json(WALLET_RESPONSE)),
-    );
-
-    const result = await nexvora_consulting_book.handler(
-      { listingId: unknownId, scheduledAt: FUTURE_AT, durationMinutes: 30, confirm: false },
-      makeClient(),
-    );
-
-    expect(result).toContain(unknownId);
-    expect(result).toContain("not found");
-  });
-
-  it("auth refresh: fetches listing after 401 with refreshed token", async () => {
-    const { client, cleanup } = makeClientWithStore();
-
-    let listingCalls = 0;
-    server.use(
-      http.get(`${BASE_URL}/consulting/${LISTING_ID}`, () => {
-        if (++listingCalls === 1) return new Response("Unauthorized", { status: 401 });
-        return HttpResponse.json(LISTING_DETAIL);
-      }),
-      http.get(`${BASE_URL}/wallet`, () => HttpResponse.json(WALLET_RESPONSE)),
-      http.post(`${BASE_URL}/auth/refresh`, () => HttpResponse.json(REFRESH_RESPONSE)),
-    );
-
-    try {
-      const result = await nexvora_consulting_book.handler(
-        { listingId: LISTING_ID, scheduledAt: FUTURE_AT, durationMinutes: 30, confirm: false },
-        client,
-      );
-      expect(result).toContain("Booking Preview");
-    } finally {
-      cleanup();
-    }
-  });
-});