toolcraft 0.0.5 → 0.0.6

package/node_modules/tiny-mcp-client/src/jsonrpc-types.compile-check.ts

@@ -0,0 +1,66 @@
+import type {
+  JsonRpcErrorObject,
+  JsonRpcErrorResponse,
+  JsonRpcNotification,
+  JsonRpcRequest,
+  JsonRpcResponse,
+  JsonRpcSuccessResponse,
+  RequestId,
+} from "./index.js";
+
+const requestIdFromNumber: RequestId = 1;
+const requestIdFromString: RequestId = "request-1";
+
+// @ts-expect-error MCP does not allow null request ids.
+const requestIdFromNull: RequestId = null;
+
+const request: JsonRpcRequest = {
+  jsonrpc: "2.0",
+  id: requestIdFromNumber,
+  method: "tools/list",
+  params: { cursor: "next" },
+};
+
+const notification: JsonRpcNotification = {
+  jsonrpc: "2.0",
+  method: "notifications/initialized",
+};
+
+// @ts-expect-error Notifications must not define an id.
+const notificationWithId: JsonRpcNotification = { jsonrpc: "2.0", id: requestIdFromString, method: "notifications/initialized" };
+
+const successResponse: JsonRpcSuccessResponse = {
+  jsonrpc: "2.0",
+  id: requestIdFromNumber,
+  result: { tools: [] },
+};
+
+const errorObject: JsonRpcErrorObject = {
+  code: -32601,
+  message: "Method not found",
+  data: { method: request.method },
+};
+
+const errorResponse: JsonRpcErrorResponse = {
+  jsonrpc: "2.0",
+  id: requestIdFromString,
+  error: errorObject,
+};
+
+const responses: JsonRpcResponse[] = [successResponse, errorResponse];
+
+type AssertAssignable<To, ignoredFrom extends To> = true;
+
+type ignoredResponseIncludesSuccess = AssertAssignable<
+  JsonRpcResponse,
+  JsonRpcSuccessResponse
+>;
+type ignoredResponseIncludesError = AssertAssignable<
+  JsonRpcResponse,
+  JsonRpcErrorResponse
+>;
+
+void requestIdFromNull;
+void notification;
+void notificationWithId;
+void responses;

package/node_modules/tiny-mcp-client/src/mcp-client-http-transport.integration.test.ts

@@ -0,0 +1,222 @@
+import { describe, expect, it, vi } from "vitest";
+import { HttpTransport, McpClient } from "./internal.js";
+
+interface JsonRpcRequest {
+  jsonrpc: string;
+  id?: number | string | null;
+  method: string;
+  params?: unknown;
+}
+
+interface RecordedPostRequest {
+  methodName: string;
+  sessionId: string | null;
+}
+
+const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const parseJsonRpcRequest = (body: BodyInit | null | undefined): JsonRpcRequest => {
+  if (typeof body !== "string") {
+    throw new Error("Expected HTTP POST body to be a JSON string");
+  }
+
+  const parsed = JSON.parse(body) as unknown;
+  if (!isObjectRecord(parsed) || typeof parsed.method !== "string") {
+    throw new Error("Expected HTTP POST body to contain a JSON-RPC request object");
+  }
+
+  return parsed as JsonRpcRequest;
+};
+
+const requireRequestId = (request: JsonRpcRequest): number | string => {
+  if (request.id === undefined || request.id === null) {
+    throw new Error(`Expected JSON-RPC request "${request.method}" to include an id`);
+  }
+
+  return request.id;
+};
+
+describe("McpClient HTTP transport integration", () => {
+  it("initializes, lists tools, calls tool, tracks session, and sends DELETE on close", async () => {
+    const sessionId = "session-http-integration-1";
+    const recordedPostRequests: RecordedPostRequest[] = [];
+    const deleteSessionIds: Array<string | null> = [];
+
+    const mockFetch = vi.fn(async (_input: string | URL, init?: RequestInit): Promise<Response> => {
+      const method = init?.method ?? "GET";
+
+      if (method === "GET") {
+        return new Response(null, { status: 405 });
+      }
+
+      const headers = new Headers(init?.headers);
+
+      if (method === "DELETE") {
+        deleteSessionIds.push(headers.get("mcp-session-id"));
+        return new Response(null, { status: 204 });
+      }
+
+      if (method !== "POST") {
+        throw new Error(`Unexpected HTTP method: ${method}`);
+      }
+
+      const request = parseJsonRpcRequest(init?.body);
+      recordedPostRequests.push({
+        methodName: request.method,
+        sessionId: headers.get("mcp-session-id"),
+      });
+
+      if (request.method === "initialize") {
+        return new Response(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: requireRequestId(request),
+            result: {
+              protocolVersion: "2025-03-26",
+              capabilities: {
+                tools: {},
+              },
+              serverInfo: {
+                name: "mock-http-server",
+                version: "1.0.0",
+              },
+            },
+          }),
+          {
+            status: 200,
+            headers: {
+              "Content-Type": "application/json",
+              "Mcp-Session-Id": sessionId,
+            },
+          }
+        );
+      }
+
+      if (request.method === "notifications/initialized") {
+        return new Response(null, { status: 202 });
+      }
+
+      if (request.method === "tools/list") {
+        return new Response(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: requireRequestId(request),
+            result: {
+              tools: [
+                {
+                  name: "echo",
+                  inputSchema: {
+                    type: "object",
+                    properties: {
+                      message: {
+                        type: "string",
+                      },
+                    },
+                    required: ["message"],
+                  },
+                },
+              ],
+            },
+          }),
+          {
+            status: 200,
+            headers: {
+              "Content-Type": "application/json",
+            },
+          }
+        );
+      }
+
+      if (request.method === "tools/call") {
+        if (
+          !isObjectRecord(request.params) ||
+          request.params.name !== "echo" ||
+          !isObjectRecord(request.params.arguments) ||
+          typeof request.params.arguments.message !== "string"
+        ) {
+          throw new Error("Expected tools/call params with name=echo and string arguments.message");
+        }
+
+        return new Response(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: requireRequestId(request),
+            result: {
+              content: [
+                {
+                  type: "text",
+                  text: request.params.arguments.message,
+                },
+              ],
+            },
+          }),
+          {
+            status: 200,
+            headers: {
+              "Content-Type": "application/json",
+            },
+          }
+        );
+      }
+
+      throw new Error(`Unexpected JSON-RPC method: ${request.method}`);
+    });
+
+    const client = new McpClient({
+      clientInfo: {
+        name: "http-integration-test-client",
+        version: "1.0.0",
+      },
+    });
+    const transport = new HttpTransport({
+      url: "https://example.com/mcp",
+      fetch: mockFetch,
+    });
+
+    try {
+      await client.connect(transport);
+
+      const toolsResult = await client.listTools();
+      expect(toolsResult.tools).toHaveLength(1);
+      expect(toolsResult.tools[0]).toMatchObject({
+        name: "echo",
+      });
+
+      const callResult = await client.callTool({
+        name: "echo",
+        arguments: {
+          message: "hello from HTTP integration",
+        },
+      });
+
+      expect(callResult).toEqual({
+        content: [{ type: "text", text: "hello from HTTP integration" }],
+      });
+
+      await client.close();
+
+      await vi.waitFor(() => {
+        expect(deleteSessionIds).toEqual([sessionId]);
+      });
+
+      expect(recordedPostRequests.map((request) => request.methodName)).toEqual([
+        "initialize",
+        "notifications/initialized",
+        "tools/list",
+        "tools/call",
+      ]);
+
+      const sessionByMethod = new Map(
+        recordedPostRequests.map((request) => [request.methodName, request.sessionId] as const)
+      );
+
+      expect(sessionByMethod.get("initialize")).toBeNull();
+      expect(sessionByMethod.get("notifications/initialized")).toBe(sessionId);
+      expect(sessionByMethod.get("tools/list")).toBe(sessionId);
+      expect(sessionByMethod.get("tools/call")).toBe(sessionId);
+    } finally {
+      await client.close();
+    }
+  });
+});