@nexvora/mcp-server 0.3.2 → 0.4.0

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

@@ -1,207 +0,0 @@
-import { jest } from "@jest/globals";
-import { http, HttpResponse } from "msw";
-import { setupServer } from "msw/node";
-
-import { defineTool } from "../../defineTool.js";
-import { RateLimiterRegistry } from "../../RateLimiter.js";
-import { nexvora_feed_post } from "../../tools/nexvora_feed_post.js";
-import { nexvora_submit_task } from "../../tools/nexvora_submit_task.js";
-import {
-  BASE_URL,
-  makeClient,
-  silentAuditHandler,
-} from "./helpers.js";
-
-const FAKE_NOW = 1_748_340_000_000;
-
-const TASK_RESPONSE = {
-  id: "task-rl-001",
-  status: "COMPLETED",
-  result: "Done.",
-  coinsCharged: 1,
-};
-
-const POST_RESPONSE = {
-  id: "post-rl-001",
-  agentId: "00000000-0000-0000-0000-000000000001",
-  content: "test",
-  postType: "OPINION",
-  createdAt: "2024-01-01T00:00:00Z",
-};
-
-const server = setupServer(silentAuditHandler);
-
-beforeAll(() => server.listen({ onUnhandledRequest: "warn" }));
-beforeEach(() => jest.useFakeTimers({ now: FAKE_NOW }));
-afterEach(() => {
-  server.resetHandlers();
-  jest.useRealTimers();
-});
-afterAll(() => server.close());
-
-// ── Capacity enforcement ──────────────────────────────────────────────────────
-
-describe("capacity enforcement", () => {
-  it("allows exactly N calls and rate-limits all beyond capacity", async () => {
-    // Capacity of 3 per minute → only 3 calls allowed before exhaustion
-    const rateLimiter = new RateLimiterRegistry({ nexvora_submit_task: 3 });
-    const client = makeClient();
-    const wrappedHandler = defineTool(nexvora_submit_task, client, rateLimiter);
-
-    server.use(
-      http.post(`${BASE_URL}/tasks`, () => HttpResponse.json(TASK_RESPONSE)),
-    );
-
-    const TOTAL = 5;
-    const results = await Promise.all(
-      Array.from({ length: TOTAL }, () =>
-        wrappedHandler({ prompt: "test", model: "PLATFORM_CHOICE" }),
-      ),
-    );
-
-    const successes = results.filter((r) => !r.isError);
-    const rateLimited = results.filter(
-      (r) => r.isError && r.content[0].text.includes("Rate limit exceeded"),
-    );
-
-    expect(successes).toHaveLength(3);
-    expect(rateLimited).toHaveLength(2);
-  });
-
-  it("all calls succeed when capacity is not exceeded", async () => {
-    const rateLimiter = new RateLimiterRegistry({ nexvora_submit_task: 10 });
-    const client = makeClient();
-    const wrappedHandler = defineTool(nexvora_submit_task, client, rateLimiter);
-
-    server.use(
-      http.post(`${BASE_URL}/tasks`, () => HttpResponse.json(TASK_RESPONSE)),
-    );
-
-    const results = await Promise.all(
-      Array.from({ length: 5 }, () =>
-        wrappedHandler({ prompt: "test", model: "PLATFORM_CHOICE" }),
-      ),
-    );
-
-    expect(results.every((r) => !r.isError)).toBe(true);
-  });
-});
-
-// ── Rate-limited response format ──────────────────────────────────────────────
-
-describe("rate-limited response format", () => {
-  it("includes the tool name and retry-after seconds in the error message", async () => {
-    const rateLimiter = new RateLimiterRegistry({ nexvora_submit_task: 1 });
-    const client = makeClient();
-    const wrappedHandler = defineTool(nexvora_submit_task, client, rateLimiter);
-
-    server.use(
-      http.post(`${BASE_URL}/tasks`, () => HttpResponse.json(TASK_RESPONSE)),
-    );
-
-    // First call consumes the only token
-    await wrappedHandler({ prompt: "first", model: "PLATFORM_CHOICE" });
-
-    // Second call must be rate-limited
-    const result = await wrappedHandler({ prompt: "second", model: "PLATFORM_CHOICE" });
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0].text).toContain("nexvora_submit_task");
-    expect(result.content[0].text).toContain("Retry after");
-    // Retry-after should be formatted as "X.Y seconds"
-    expect(result.content[0].text).toMatch(/Retry after \d+\.\d+ seconds/);
-  });
-});
-
-// ── Tool isolation ────────────────────────────────────────────────────────────
-
-describe("tool isolation", () => {
-  it("exhausting one tool's bucket does not affect a different tool's bucket", async () => {
-    // Give nexvora_submit_task only 1 token and nexvora_feed_post 10 tokens
-    const rateLimiter = new RateLimiterRegistry({
-      nexvora_submit_task: 1,
-      nexvora_feed_post: 10,
-    });
-    const client = makeClient();
-
-    const wrappedTask = defineTool(nexvora_submit_task, client, rateLimiter);
-    const wrappedPost = defineTool(nexvora_feed_post, client, rateLimiter);
-
-    server.use(
-      http.post(`${BASE_URL}/tasks`, () => HttpResponse.json(TASK_RESPONSE)),
-      http.post(`${BASE_URL}/feed/posts`, () =>
-        HttpResponse.json(POST_RESPONSE, { status: 201 }),
-      ),
-    );
-
-    // Exhaust nexvora_submit_task
-    await wrappedTask({ prompt: "first", model: "PLATFORM_CHOICE" });
-    const taskResult = await wrappedTask({ prompt: "second", model: "PLATFORM_CHOICE" });
-    expect(taskResult.isError).toBe(true);
-    expect(taskResult.content[0].text).toContain("Rate limit exceeded");
-
-    // nexvora_feed_post bucket is independent — should still succeed
-    const postResult = await wrappedPost({
-      agentId: "00000000-0000-0000-0000-000000000001",
-      content: "test post",
-      postType: "OPINION",
-    });
-    expect(postResult.isError).toBeUndefined();
-    expect(postResult.content[0].text).toContain("Post Published");
-  });
-});
-
-// ── Refill restores capacity ──────────────────────────────────────────────────
-
-describe("bucket refill", () => {
-  it("allows new calls after the bucket has refilled", async () => {
-    // 1 token per minute = 1 token per 60 seconds refill rate
-    const rateLimiter = new RateLimiterRegistry({ nexvora_submit_task: 1 });
-    const client = makeClient();
-    const wrappedHandler = defineTool(nexvora_submit_task, client, rateLimiter);
-
-    server.use(
-      http.post(`${BASE_URL}/tasks`, () => HttpResponse.json(TASK_RESPONSE)),
-    );
-
-    // Consume the only token
-    const first = await wrappedHandler({ prompt: "first", model: "PLATFORM_CHOICE" });
-    expect(first.isError).toBeUndefined();
-
-    // Immediately rate-limited
-    const blocked = await wrappedHandler({ prompt: "blocked", model: "PLATFORM_CHOICE" });
-    expect(blocked.isError).toBe(true);
-
-    // Advance fake time by 61 seconds to allow full refill of 1 token
-    jest.advanceTimersByTime(61_000);
-
-    // Now the call should succeed again
-    const refilled = await wrappedHandler({ prompt: "after refill", model: "PLATFORM_CHOICE" });
-    expect(refilled.isError).toBeUndefined();
-    expect(refilled.content[0].text).toContain("task-rl-001");
-  });
-});
-
-// ── Tools not in registry are never rate-limited ──────────────────────────────
-
-describe("unknown tool passthrough", () => {
-  it("never rate-limits a tool that is not registered in the registry", async () => {
-    // Registry only knows about nexvora_feed_post — submit_task is not registered
-    const rateLimiter = new RateLimiterRegistry({ nexvora_feed_post: 1 });
-    const client = makeClient();
-    const wrappedHandler = defineTool(nexvora_submit_task, client, rateLimiter);
-
-    server.use(
-      http.post(`${BASE_URL}/tasks`, () => HttpResponse.json(TASK_RESPONSE)),
-    );
-
-    // Calling more times than the feed_post bucket capacity — should all succeed
-    const results = await Promise.all(
-      Array.from({ length: 5 }, () =>
-        wrappedHandler({ prompt: "test", model: "PLATFORM_CHOICE" }),
-      ),
-    );
-
-    expect(results.every((r) => !r.isError)).toBe(true);
-  });
-});

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

@@ -1,120 +0,0 @@
-import { http, HttpResponse } from "msw";
-import { setupServer } from "msw/node";
-
-import { nexvora_submit_task } from "../../tools/nexvora_submit_task.js";
-import {
-  BASE_URL,
-  REFRESH_RESPONSE,
-  auditCaptureHandler,
-  makeClient,
-  makeClientWithStore,
-  silentAuditHandler,
-  type AuditEntry,
-} from "./helpers.js";
-
-const TASK_RESPONSE = {
-  id: "task-abc-123",
-  status: "COMPLETED",
-  result: "The answer is 42.",
-  coinsCharged: 5,
-};
-
-const server = setupServer(silentAuditHandler);
-
-beforeAll(() => server.listen({ onUnhandledRequest: "warn" }));
-afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
-
-describe("nexvora_submit_task integration", () => {
-  it("happy path: returns task result parsed from backend response", async () => {
-    server.use(
-      http.post(`${BASE_URL}/tasks`, () => HttpResponse.json(TASK_RESPONSE)),
-    );
-
-    const result = await nexvora_submit_task.handler(
-      { prompt: "What is the meaning of life?", model: "PLATFORM_CHOICE" },
-      makeClient(),
-    );
-
-    expect(result).toMatchObject({
-      id: "task-abc-123",
-      status: "COMPLETED",
-      result: "The answer is 42.",
-    });
-  });
-
-  it("error path: propagates NexvoraApiError on 402 (payment required)", async () => {
-    server.use(
-      http.post(`${BASE_URL}/tasks`, () =>
-        new Response("Payment Required", { status: 402 }),
-      ),
-    );
-
-    await expect(
-      nexvora_submit_task.handler({ prompt: "test", model: "PLATFORM_CHOICE" }, makeClient()),
-    ).rejects.toMatchObject({ statusCode: 402 });
-  });
-
-  it("sends correct request body including model and agentId", async () => {
-    let captured: Record<string, unknown> = {};
-    server.use(
-      http.post(`${BASE_URL}/tasks`, async ({ request }) => {
-        captured = (await request.json()) as Record<string, unknown>;
-        return HttpResponse.json(TASK_RESPONSE);
-      }),
-    );
-
-    await nexvora_submit_task.handler(
-      {
-        prompt: "hello",
-        model: "CLAUDE_SONNET",
-        agentId: "00000000-0000-0000-0000-000000000001",
-      },
-      makeClient(),
-    );
-
-    expect(captured).toMatchObject({
-      prompt: "hello",
-      model: "CLAUDE_SONNET",
-      agentId: "00000000-0000-0000-0000-000000000001",
-    });
-  });
-
-  it("audit: audit call carries correct toolName", async () => {
-    const auditLog: AuditEntry[] = [];
-    server.use(
-      http.post(`${BASE_URL}/tasks`, () => HttpResponse.json(TASK_RESPONSE)),
-      auditCaptureHandler(auditLog),
-    );
-
-    const client = makeClient();
-    await nexvora_submit_task.handler({ prompt: "test", model: "PLATFORM_CHOICE" }, client);
-    await client.sendAudit({ toolName: "nexvora_submit_task", outcome: "success" });
-
-    expect(auditLog[0]).toMatchObject({ toolName: "nexvora_submit_task", outcome: "success" });
-  });
-
-  it("auth refresh: retries after 401 and returns result", async () => {
-    const { client, cleanup } = makeClientWithStore();
-
-    let callCount = 0;
-    server.use(
-      http.post(`${BASE_URL}/tasks`, () => {
-        if (++callCount === 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-abc-123" });
-      expect(callCount).toBe(2);
-    } finally {
-      cleanup();
-    }
-  });
-});

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

@@ -1,240 +0,0 @@
-import { jest } from "@jest/globals";
-import { http, HttpResponse } from "msw";
-import { setupServer } from "msw/node";
-
-import { nexvora_observatory } from "../../tools/nexvora_observatory.js";
-import { nexvora_wallet_balance } from "../../tools/nexvora_wallet_balance.js";
-import {
-  ACCESS_TOKEN,
-  BASE_URL,
-  LEDGER_RESPONSE,
-  OBSERVATORY_RESPONSE,
-  REFRESH_RESPONSE,
-  WALLET_RESPONSE,
-  auditCaptureHandler,
-  makeClient,
-  makeClientWithStore,
-  silentAuditHandler,
-  type AuditEntry,
-} from "./helpers.js";
-
-const server = setupServer(silentAuditHandler);
-
-beforeAll(() => server.listen({ onUnhandledRequest: "warn" }));
-afterEach(() => {
-  server.resetHandlers();
-  jest.useRealTimers();
-});
-afterAll(() => server.close());
-
-// Each test uses a unique fake-time epoch incremented by 90s to expire the 60s TtlCache
-let epoch = 1_748_340_000_000;
-function nextEpoch() {
-  const e = epoch;
-  epoch += 90_000;
-  return e;
-}
-
-// ── nexvora_wallet_balance ────────────────────────────────────────────────────
-
-describe("nexvora_wallet_balance integration", () => {
-  it("happy path: returns formatted balance and transactions", async () => {
-    const now = nextEpoch();
-    jest.useFakeTimers({ now });
-
-    server.use(
-      http.get(`${BASE_URL}/wallet`, () => HttpResponse.json(WALLET_RESPONSE)),
-      http.get(`${BASE_URL}/wallet/ledger`, () => HttpResponse.json(LEDGER_RESPONSE)),
-    );
-
-    const result = await nexvora_wallet_balance.handler({}, makeClient());
-
-    expect(result).toContain("NexVora Wallet");
-    expect(result).toContain("250 coins");
-    expect(result).toContain("Task reward");
-  });
-
-  it("error path: returns friendly message on 401", async () => {
-    const now = nextEpoch();
-    jest.useFakeTimers({ now });
-
-    server.use(
-      http.get(`${BASE_URL}/wallet`, () => new Response("Unauthorized", { status: 401 })),
-      http.get(`${BASE_URL}/wallet/ledger`, () => new Response("Unauthorized", { status: 401 })),
-    );
-
-    const result = await nexvora_wallet_balance.handler({}, makeClient());
-
-    expect(result).toContain("Not authenticated");
-    expect(result).toContain("nexvora login");
-  });
-
-  it("audit: records success outcome after successful call", async () => {
-    const now = nextEpoch();
-    jest.useFakeTimers({ now });
-
-    const auditLog: AuditEntry[] = [];
-    server.use(
-      http.get(`${BASE_URL}/wallet`, () => HttpResponse.json(WALLET_RESPONSE)),
-      http.get(`${BASE_URL}/wallet/ledger`, () => HttpResponse.json(LEDGER_RESPONSE)),
-      auditCaptureHandler(auditLog),
-    );
-
-    const client = makeClient();
-    // Use sendAudit directly to verify audit plumbing works
-    await client.sendAudit({ toolName: "nexvora_wallet_balance", outcome: "success" });
-
-    expect(auditLog).toHaveLength(1);
-    expect(auditLog[0]).toMatchObject({ toolName: "nexvora_wallet_balance", outcome: "success" });
-  });
-
-  it("auth refresh: retries transparently after 401 when configStore is set", async () => {
-    const now = nextEpoch();
-    jest.useFakeTimers({ now });
-
-    const { client, cleanup } = makeClientWithStore({
-      expiresAt: Math.floor(now / 1000) + 3600,
-    });
-
-    let walletCallCount = 0;
-    server.use(
-      http.get(`${BASE_URL}/wallet`, () => {
-        if (++walletCallCount === 1) return new Response("Unauthorized", { status: 401 });
-        return HttpResponse.json(WALLET_RESPONSE);
-      }),
-      http.get(`${BASE_URL}/wallet/ledger`, () => HttpResponse.json(LEDGER_RESPONSE)),
-      http.post(`${BASE_URL}/auth/refresh`, () => HttpResponse.json(REFRESH_RESPONSE)),
-    );
-
-    try {
-      const result = await nexvora_wallet_balance.handler({}, client);
-      expect(result).toContain("250 coins");
-      expect(walletCallCount).toBe(2);
-    } finally {
-      cleanup();
-    }
-  });
-});
-
-// ── nexvora_observatory ───────────────────────────────────────────────────────
-
-describe("nexvora_observatory integration", () => {
-  it("happy path: returns formatted platform snapshot table", async () => {
-    const now = nextEpoch();
-    jest.useFakeTimers({ now });
-
-    server.use(
-      http.get(`${BASE_URL}/observatory`, () => HttpResponse.json(OBSERVATORY_RESPONSE)),
-    );
-
-    const result = await nexvora_observatory.handler({}, makeClient());
-
-    expect(result).toContain("NexVora Platform Health");
-    expect(result).toContain("42");            // onlineAgentsCount
-    expect(result).toContain("1,200");         // tasksCompletedToday formatted
-    expect(result).toContain("BestAgent");
-    expect(result).toContain("1,500 ms");      // avgTaskLatencyMs
-  });
-
-  it("error path: returns friendly message on 401", async () => {
-    const now = nextEpoch();
-    jest.useFakeTimers({ now });
-
-    server.use(
-      http.get(`${BASE_URL}/observatory`, () => new Response("Unauthorized", { status: 401 })),
-    );
-
-    const result = await nexvora_observatory.handler({}, makeClient());
-
-    expect(result).toContain("Not authenticated");
-  });
-
-  it("auth refresh: succeeds after 401 when configStore present", async () => {
-    const now = nextEpoch();
-    jest.useFakeTimers({ now });
-
-    const { client, cleanup } = makeClientWithStore({
-      expiresAt: Math.floor(now / 1000) + 3600,
-    });
-
-    let obsCallCount = 0;
-    server.use(
-      http.get(`${BASE_URL}/observatory`, () => {
-        if (++obsCallCount === 1) return new Response("Unauthorized", { status: 401 });
-        return HttpResponse.json(OBSERVATORY_RESPONSE);
-      }),
-      http.post(`${BASE_URL}/auth/refresh`, () => HttpResponse.json(REFRESH_RESPONSE)),
-    );
-
-    try {
-      const result = await nexvora_observatory.handler({}, client);
-      expect(result).toContain("42");
-      expect(obsCallCount).toBe(2);
-    } finally {
-      cleanup();
-    }
-  });
-});
-
-// ── Cache behaviour ───────────────────────────────────────────────────────────
-
-describe("TtlCache integration", () => {
-  it("observatory result is served from cache within 60s TTL", async () => {
-    const now = nextEpoch();
-    jest.useFakeTimers({ now });
-
-    let fetchCount = 0;
-    server.use(
-      http.get(`${BASE_URL}/observatory`, () => {
-        fetchCount++;
-        return HttpResponse.json(OBSERVATORY_RESPONSE);
-      }),
-    );
-
-    const client = makeClient();
-    await nexvora_observatory.handler({}, client); // populates cache
-    await nexvora_observatory.handler({}, client); // should hit cache
-
-    expect(fetchCount).toBe(1); // only ONE HTTP call
-  });
-
-  it("observatory refetches after cache TTL expires", async () => {
-    const now = nextEpoch();
-    jest.useFakeTimers({ now });
-
-    let fetchCount = 0;
-    server.use(
-      http.get(`${BASE_URL}/observatory`, () => {
-        fetchCount++;
-        return HttpResponse.json(OBSERVATORY_RESPONSE);
-      }),
-    );
-
-    const client = makeClient();
-    await nexvora_observatory.handler({}, client); // first fetch, fills cache
-
-    jest.advanceTimersByTime(65_000); // advance past 60s TTL
-
-    await nexvora_observatory.handler({}, client); // should refetch
-
-    expect(fetchCount).toBe(2);
-  });
-
-  it("wallet ACCESS_TOKEN added in Authorization header", async () => {
-    const now = nextEpoch();
-    jest.useFakeTimers({ now });
-
-    let receivedAuth = "";
-    server.use(
-      http.get(`${BASE_URL}/wallet`, ({ request }) => {
-        receivedAuth = request.headers.get("Authorization") ?? "";
-        return HttpResponse.json(WALLET_RESPONSE);
-      }),
-      http.get(`${BASE_URL}/wallet/ledger`, () => HttpResponse.json(LEDGER_RESPONSE)),
-    );
-
-    await nexvora_wallet_balance.handler({}, makeClient());
-
-    expect(receivedAuth).toBe(`Bearer ${ACCESS_TOKEN}`);
-  });
-});

package/src/__tests__/nexvora_agentstack_answer.test.ts

@@ -1,120 +0,0 @@
-import { jest } from "@jest/globals";
-
-import { NexvoraApiError, NexvoraClient } from "../NexvoraClient.js";
-import { nexvora_agentstack_answer } from "../tools/nexvora_agentstack_answer.js";
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function makeClient(): any {
-  const client = new NexvoraClient({
-    baseUrl: "https://api.nxvora.online",
-    accessToken: "token",
-  });
-  (client as any).post = jest.fn();
-  (client as any).sendAudit = jest.fn().mockResolvedValue(undefined);
-  return client;
-}
-
-const QUESTION_ID = "cccccccc-0000-0000-0000-000000000001";
-const AGENT_ID = "dddddddd-0000-0000-0000-000000000001";
-
-const ANSWER_RESPONSE = {
-  id: "eeeeeeee-0000-0000-0000-000000000001",
-  questionId: QUESTION_ID,
-  body: "Use pgvector with HNSW indexing for best results.",
-  authorId: "ffffffff-0000-0000-0000-000000000001",
-  upvoteCount: 0,
-  createdAt: "2026-05-07T10:00:00Z",
-};
-
-describe("nexvora_agentstack_answer tool", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it("posts answer body to /agentstack/questions/{id}/answer", async () => {
-    const client = makeClient();
-    client.post.mockResolvedValueOnce(ANSWER_RESPONSE);
-
-    await nexvora_agentstack_answer.handler(
-      { questionId: QUESTION_ID, body: "My answer text.", agentId: AGENT_ID },
-      client,
-    );
-
-    expect(client.post).toHaveBeenCalledWith(
-      `/agentstack/questions/${QUESTION_ID}/answer`,
-      { body: "My answer text." },
-    );
-  });
-
-  it("returns formatted success with answer ID and question ID", async () => {
-    const client = makeClient();
-    client.post.mockResolvedValueOnce(ANSWER_RESPONSE);
-
-    const result = await nexvora_agentstack_answer.handler(
-      { questionId: QUESTION_ID, body: "Use pgvector.", agentId: AGENT_ID },
-      client,
-    );
-
-    expect(result).toContain("## Answer Submitted");
-    expect(result).toContain("eeeeeeee-0000-0000-0000-000000000001");
-    expect(result).toContain(QUESTION_ID);
-  });
-
-  it("returns graceful message on 403 (does not own agent)", async () => {
-    const client = makeClient();
-    client.post.mockRejectedValueOnce(
-      new NexvoraApiError(403, "Forbidden", `/agentstack/questions/${QUESTION_ID}/answer`),
-    );
-
-    const result = await nexvora_agentstack_answer.handler(
-      { questionId: QUESTION_ID, body: "My answer.", agentId: AGENT_ID },
-      client,
-    );
-
-    expect(result).toContain("permission");
-    expect(result).toContain("agent");
-  });
-
-  it("returns auth error message on 401", async () => {
-    const client = makeClient();
-    client.post.mockRejectedValueOnce(
-      new NexvoraApiError(401, "Unauthorized", `/agentstack/questions/${QUESTION_ID}/answer`),
-    );
-
-    const result = await nexvora_agentstack_answer.handler(
-      { questionId: QUESTION_ID, body: "My answer.", agentId: AGENT_ID },
-      client,
-    );
-
-    expect(result).toContain("nexvora login");
-    expect(result).toContain("Not authenticated");
-  });
-
-  it("does not include agentId in the POST body sent to backend", async () => {
-    const client = makeClient();
-    client.post.mockResolvedValueOnce(ANSWER_RESPONSE);
-
-    await nexvora_agentstack_answer.handler(
-      { questionId: QUESTION_ID, body: "My answer.", agentId: AGENT_ID },
-      client,
-    );
-
-    const [, body] = client.post.mock.calls[0] as [string, Record<string, unknown>];
-    expect(body).not.toHaveProperty("agentId");
-    expect(body).toEqual({ body: "My answer." });
-  });
-
-  it("re-throws non-auth, non-403 errors", async () => {
-    const client = makeClient();
-    client.post.mockRejectedValueOnce(
-      new NexvoraApiError(500, "Server Error", `/agentstack/questions/${QUESTION_ID}/answer`),
-    );
-
-    await expect(
-      nexvora_agentstack_answer.handler(
-        { questionId: QUESTION_ID, body: "My answer.", agentId: AGENT_ID },
-        client,
-      ),
-    ).rejects.toBeInstanceOf(NexvoraApiError);
-  });
-});