retestkit 1.4.1

package/src/resources/subscriptions.ts

@@ -0,0 +1,37 @@
+import type { Logger } from "../logger.js";
+
+export interface ResourceSubscriptions {
+  subscribe(uri: string): void;
+  unsubscribe(uri: string): void;
+  isSubscribed(uri: string): boolean;
+  getSubscribers(): string[];
+  clear(): void;
+}
+
+export function createResourceSubscriptions(logger: Logger): ResourceSubscriptions {
+  const subscriptions = new Set<string>();
+
+  return {
+    subscribe(uri: string): void {
+      subscriptions.add(uri);
+      logger.debug("Resource subscribed", { uri });
+    },
+
+    unsubscribe(uri: string): void {
+      subscriptions.delete(uri);
+      logger.debug("Resource unsubscribed", { uri });
+    },
+
+    isSubscribed(uri: string): boolean {
+      return subscriptions.has(uri);
+    },
+
+    getSubscribers(): string[] {
+      return Array.from(subscriptions);
+    },
+
+    clear(): void {
+      subscriptions.clear();
+    },
+  };
+}

package/src/sampling/index.test.ts

@@ -0,0 +1,414 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { z } from "zod";
+import { createSamplingClient } from "./index.js";
+import type { Logger } from "../logger.js";
+import type { ClientCapabilities } from "../types/capabilities.js";
+import type { SamplingRequest, SamplingResponse } from "./types.js";
+
+describe("sampling", () => {
+  let mockLogger: Logger;
+
+  beforeEach(() => {
+    mockLogger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      setLevel: vi.fn(),
+      withCorrelation: vi.fn().mockReturnThis(),
+    } as unknown as Logger;
+  });
+
+  const capabilitiesWithSampling: ClientCapabilities = {
+    sampling: true,
+    elicitation: false,
+    logging: false,
+    progress: true,
+    resourcesListChanged: false,
+    resourcesSubscribe: false,
+    protocolVersion: "2025-06-18",
+  };
+
+  const capabilitiesWithoutSampling: ClientCapabilities = {
+    sampling: false,
+    elicitation: false,
+    logging: false,
+    progress: false,
+    resourcesListChanged: false,
+    resourcesSubscribe: false,
+    protocolVersion: "2025-06-18",
+  };
+
+  describe("createSamplingClient", () => {
+    it("reports sampling availability correctly", () => {
+      const clientWith = createSamplingClient(
+        vi.fn(),
+        capabilitiesWithSampling,
+        mockLogger
+      );
+
+      const clientWithout = createSamplingClient(
+        vi.fn(),
+        capabilitiesWithoutSampling,
+        mockLogger
+      );
+
+      expect(clientWith.hasSampling()).toBe(true);
+      expect(clientWithout.hasSampling()).toBe(false);
+    });
+  });
+
+  describe("createMessage", () => {
+    const testSchema = z.object({
+      action: z.string(),
+      value: z.number(),
+    });
+
+    it("returns fallback when sampling unavailable", async () => {
+      const requestSampling = vi.fn();
+      const client = createSamplingClient(
+        requestSampling,
+        capabilitiesWithoutSampling,
+        mockLogger
+      );
+
+      const result = await client.createMessage({
+        systemPrompt: "You are a test assistant",
+        userPrompt: "Do something",
+        schema: testSchema,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("Sampling not available");
+      expect(result.promptResource).toBeDefined();
+      expect(requestSampling).not.toHaveBeenCalled();
+    });
+
+    it("parses valid JSON response successfully", async () => {
+      const mockResponse: SamplingResponse = {
+        model: "test-model",
+        stopReason: "end_turn",
+        content: {
+          type: "text",
+          text: JSON.stringify({ action: "test", value: 42 }),
+        },
+      };
+
+      const requestSampling = vi.fn().mockResolvedValue(mockResponse);
+      const client = createSamplingClient(
+        requestSampling,
+        capabilitiesWithSampling,
+        mockLogger
+      );
+
+      const result = await client.createMessage({
+        systemPrompt: "You are a test assistant",
+        userPrompt: "Do something",
+        schema: testSchema,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual({ action: "test", value: 42 });
+    });
+
+    it("handles JSON wrapped in markdown code blocks", async () => {
+      const mockResponse: SamplingResponse = {
+        model: "test-model",
+        stopReason: "end_turn",
+        content: {
+          type: "text",
+          text: '```json\n{"action": "test", "value": 42}\n```',
+        },
+      };
+
+      const requestSampling = vi.fn().mockResolvedValue(mockResponse);
+      const client = createSamplingClient(
+        requestSampling,
+        capabilitiesWithSampling,
+        mockLogger
+      );
+
+      const result = await client.createMessage({
+        systemPrompt: "You are a test assistant",
+        userPrompt: "Do something",
+        schema: testSchema,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual({ action: "test", value: 42 });
+    });
+
+    it("handles JSON wrapped in generic code blocks", async () => {
+      const mockResponse: SamplingResponse = {
+        model: "test-model",
+        stopReason: "end_turn",
+        content: {
+          type: "text",
+          text: '```\n{"action": "test", "value": 42}\n```',
+        },
+      };
+
+      const requestSampling = vi.fn().mockResolvedValue(mockResponse);
+      const client = createSamplingClient(
+        requestSampling,
+        capabilitiesWithSampling,
+        mockLogger
+      );
+
+      const result = await client.createMessage({
+        systemPrompt: "You are a test assistant",
+        userPrompt: "Do something",
+        schema: testSchema,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual({ action: "test", value: 42 });
+    });
+
+    it("retries on invalid JSON when retryOnFailure is true", async () => {
+      const requestSampling = vi
+        .fn()
+        .mockResolvedValueOnce({
+          model: "test-model",
+          stopReason: "end_turn",
+          content: { type: "text", text: "not valid json" },
+        })
+        .mockResolvedValueOnce({
+          model: "test-model",
+          stopReason: "end_turn",
+          content: {
+            type: "text",
+            text: JSON.stringify({ action: "test", value: 42 }),
+          },
+        });
+
+      const client = createSamplingClient(
+        requestSampling,
+        capabilitiesWithSampling,
+        mockLogger
+      );
+
+      const result = await client.createMessage({
+        systemPrompt: "You are a test assistant",
+        userPrompt: "Do something",
+        schema: testSchema,
+        retryOnFailure: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(requestSampling).toHaveBeenCalledTimes(2);
+    });
+
+    it("does not retry when retryOnFailure is false", async () => {
+      const requestSampling = vi.fn().mockResolvedValue({
+        model: "test-model",
+        stopReason: "end_turn",
+        content: { type: "text", text: "not valid json" },
+      });
+
+      const client = createSamplingClient(
+        requestSampling,
+        capabilitiesWithSampling,
+        mockLogger
+      );
+
+      const result = await client.createMessage({
+        systemPrompt: "You are a test assistant",
+        userPrompt: "Do something",
+        schema: testSchema,
+        retryOnFailure: false,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Failed to parse response as JSON");
+      expect(requestSampling).toHaveBeenCalledTimes(1);
+    });
+
+    it("retries on schema validation failure", async () => {
+      const requestSampling = vi
+        .fn()
+        .mockResolvedValueOnce({
+          model: "test-model",
+          stopReason: "end_turn",
+          content: {
+            type: "text",
+            text: JSON.stringify({ action: "test", value: "not a number" }),
+          },
+        })
+        .mockResolvedValueOnce({
+          model: "test-model",
+          stopReason: "end_turn",
+          content: {
+            type: "text",
+            text: JSON.stringify({ action: "test", value: 42 }),
+          },
+        });
+
+      const client = createSamplingClient(
+        requestSampling,
+        capabilitiesWithSampling,
+        mockLogger
+      );
+
+      const result = await client.createMessage({
+        systemPrompt: "You are a test assistant",
+        userPrompt: "Do something",
+        schema: testSchema,
+        retryOnFailure: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual({ action: "test", value: 42 });
+    });
+
+    it("fails after retry exhausted", async () => {
+      const requestSampling = vi.fn().mockResolvedValue({
+        model: "test-model",
+        stopReason: "end_turn",
+        content: { type: "text", text: "still not valid json" },
+      });
+
+      const client = createSamplingClient(
+        requestSampling,
+        capabilitiesWithSampling,
+        mockLogger
+      );
+
+      const result = await client.createMessage({
+        systemPrompt: "You are a test assistant",
+        userPrompt: "Do something",
+        schema: testSchema,
+        retryOnFailure: true,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Retry failed");
+    });
+
+    it("handles request errors gracefully", async () => {
+      const requestSampling = vi
+        .fn()
+        .mockRejectedValue(new Error("Network error"));
+
+      const client = createSamplingClient(
+        requestSampling,
+        capabilitiesWithSampling,
+        mockLogger
+      );
+
+      const result = await client.createMessage({
+        systemPrompt: "You are a test assistant",
+        userPrompt: "Do something",
+        schema: testSchema,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe("Network error");
+    });
+
+    it("uses custom maxTokens and temperature", async () => {
+      const requestSampling = vi.fn().mockResolvedValue({
+        model: "test-model",
+        stopReason: "end_turn",
+        content: {
+          type: "text",
+          text: JSON.stringify({ action: "test", value: 42 }),
+        },
+      });
+
+      const client = createSamplingClient(
+        requestSampling,
+        capabilitiesWithSampling,
+        mockLogger
+      );
+
+      await client.createMessage({
+        systemPrompt: "You are a test assistant",
+        userPrompt: "Do something",
+        schema: testSchema,
+        maxTokens: 1000,
+        temperature: 0.5,
+      });
+
+      const request = requestSampling.mock.calls[0][0] as SamplingRequest;
+      expect(request.maxTokens).toBe(1000);
+      expect(request.temperature).toBe(0.5);
+    });
+
+    it("includes system prefix in the system prompt", async () => {
+      const requestSampling = vi.fn().mockResolvedValue({
+        model: "test-model",
+        stopReason: "end_turn",
+        content: {
+          type: "text",
+          text: JSON.stringify({ action: "test", value: 42 }),
+        },
+      });
+
+      const client = createSamplingClient(
+        requestSampling,
+        capabilitiesWithSampling,
+        mockLogger
+      );
+
+      await client.createMessage({
+        systemPrompt: "You are a test assistant",
+        userPrompt: "Do something",
+        schema: testSchema,
+      });
+
+      const request = requestSampling.mock.calls[0][0] as SamplingRequest;
+      expect(request.systemPrompt).toContain("[WEBTEST-SYSTEM]");
+      expect(request.systemPrompt).toContain("You are a test assistant");
+    });
+
+    it("sets includeContext to thisServer", async () => {
+      const requestSampling = vi.fn().mockResolvedValue({
+        model: "test-model",
+        stopReason: "end_turn",
+        content: {
+          type: "text",
+          text: JSON.stringify({ action: "test", value: 42 }),
+        },
+      });
+
+      const client = createSamplingClient(
+        requestSampling,
+        capabilitiesWithSampling,
+        mockLogger
+      );
+
+      await client.createMessage({
+        systemPrompt: "You are a test assistant",
+        userPrompt: "Do something",
+        schema: testSchema,
+      });
+
+      const request = requestSampling.mock.calls[0][0] as SamplingRequest;
+      expect(request.includeContext).toBe("thisServer");
+    });
+
+    it("returns rawResponse on success", async () => {
+      const rawJson = JSON.stringify({ action: "test", value: 42 });
+      const requestSampling = vi.fn().mockResolvedValue({
+        model: "test-model",
+        stopReason: "end_turn",
+        content: { type: "text", text: rawJson },
+      });
+
+      const client = createSamplingClient(
+        requestSampling,
+        capabilitiesWithSampling,
+        mockLogger
+      );
+
+      const result = await client.createMessage({
+        systemPrompt: "You are a test assistant",
+        userPrompt: "Do something",
+        schema: testSchema,
+      });
+
+      expect(result.rawResponse).toBe(rawJson);
+    });
+  });
+});