@mcp-web/client 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,8 @@
+import type { z } from "zod";
+import type { ContentSchema, ImageContentSchema, MCPWebClientConfigSchema, TextContentSchema } from "./schemas.js";
+export type MCPWebClientConfig = z.input<typeof MCPWebClientConfigSchema>;
+export type MCPWebClientConfigOutput = z.infer<typeof MCPWebClientConfigSchema>;
+export type TextContent = z.infer<typeof TextContentSchema>;
+export type ImageContent = z.infer<typeof ImageContentSchema>;
+export type Content = z.infer<typeof ContentSchema>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EACV,aAAa,EACb,kBAAkB,EAClB,wBAAwB,EACxB,iBAAiB,EAClB,MAAM,cAAc,CAAC;AAEtB,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const camelToSnakeCase: (str: string) => string;
+export declare const camelToSnakeCaseProps: (obj: Record<string, unknown>) => Record<string, unknown>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,GAAI,KAAK,MAAM,WAAgE,CAAC;AAE7G,eAAO,MAAM,qBAAqB,GAAI,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAE1F,CAAC"}

package/dist/utils.js

@@ -0,0 +1,5 @@
+export const camelToSnakeCase = (str) => str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+export const camelToSnakeCaseProps = (obj) => {
+    return Object.fromEntries(Object.entries(obj).map(([key, value]) => [camelToSnakeCase(key), value]));
+};
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,GAAW,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,CAAC,IAAI,MAAM,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;AAE7G,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,GAA4B,EAA2B,EAAE;IAC7F,OAAO,MAAM,CAAC,WAAW,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAA;AACtG,CAAC,CAAC"}

package/esbuild.standalone.mjs

@@ -0,0 +1,17 @@
+import { build } from 'esbuild';
+
+await build({
+  entryPoints: ['src/index.ts'],
+  bundle: true,
+  platform: 'node',
+  target: 'node22',
+  format: 'esm',
+  outfile: 'dist/standalone.js',
+  banner: {
+    js: '#!/usr/bin/env node',
+  },
+  minify: false,
+  sourcemap: false,
+});
+
+console.log('✓ Built standalone bundle: dist/standalone.js');

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@mcp-web/client",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "@mcp-web/client": "./dist/index.js"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.0",
+    "zod": "~4.1.12",
+    "@mcp-web/types": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.9",
+    "esbuild": "^0.24.2",
+    "typescript": "~5.9.3"
+  },
+  "scripts": {
+    "dev": "tsc --watch",
+    "build": "tsc && node esbuild.standalone.mjs",
+    "build:standalone": "node esbuild.standalone.mjs",
+    "clean": "rm -rf dist",
+    "start": "node dist/index.js"
+  }
+}

package/src/client.test.ts

@@ -0,0 +1,259 @@
+import { expect, test } from 'bun:test';
+import { ClientNotConextualizedErrorCode, QueryDoneErrorCode } from '@mcp-web/types';
+import { MCPWebClient } from './client.js';
+
+// Store original fetch for tests that need to mock it
+const originalFetch = globalThis.fetch;
+
+test('MCPWebClient initializes with config', () => {
+  const client = new MCPWebClient({
+    serverUrl: 'http://localhost:3002',
+  });
+
+  expect(client).toBeDefined();
+});
+
+test('contextualize creates new client instance with query', () => {
+  const client = new MCPWebClient({
+    serverUrl: 'http://localhost:3002',
+  });
+
+  const query = {
+    uuid: 'test-query-123',
+    prompt: 'Test prompt',
+    context: [],
+  };
+
+  const contextClient = client.contextualize(query);
+
+  expect(contextClient).toBeDefined();
+  expect(contextClient !== client).toBe(true);
+});
+
+test('callTool validates restrictTools', async () => {
+  const client = new MCPWebClient({
+    serverUrl: 'http://localhost:3002',
+  });
+
+  const query = {
+    uuid: 'test-query',
+    prompt: 'test',
+    context: [],
+    tools: [
+      {
+        name: 'allowed-tool',
+        description: 'Allowed tool',
+        handler: () => {},
+      },
+    ],
+    restrictTools: true,
+  };
+
+  const contextClient = client.contextualize(query);
+
+  // Should throw when calling a tool not in the allowed list
+  expect(async () => {
+    await contextClient.callTool('forbidden-tool', {});
+  }).toThrow('not allowed');
+});
+
+test('callTool allows tools when restrictTools is false', async () => {
+  // Mock fetch to return success - Deno has native fetch!
+  globalThis.fetch = (async () => {
+    return new Response(
+      JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        result: { data: 'success' },
+      }),
+      { status: 200, headers: { 'Content-Type': 'application/json' } }
+    );
+  }) as unknown as typeof fetch;
+
+  const client = new MCPWebClient({
+    serverUrl: 'http://localhost:3002',
+  });
+
+  const query = {
+    uuid: 'test-query',
+    prompt: 'test',
+    context: [],
+    tools: [
+      {
+        name: 'allowed-tool',
+        description: 'Allowed tool',
+        handler: () => {},
+      },
+    ],
+    restrictTools: false, // Not restricting tools
+  };
+
+  const contextClient = client.contextualize(query);
+
+  // Should succeed even with forbidden tool
+  const result = await contextClient.callTool('any-tool', {});
+  expect(result).toBeDefined();
+
+  globalThis.fetch = originalFetch;
+});
+
+test('callTool includes query context in request', async () => {
+  let capturedBody: unknown;
+
+  // Mock fetch and capture the request body
+  globalThis.fetch = (async (input: Request | URL | string, init?: RequestInit) => {
+    // Capture the body from init if it's a string
+    if (init && typeof init.body === 'string') {
+      capturedBody = JSON.parse(init.body);
+    } else if (input instanceof Request) {
+      // If input is a Request object, clone and read it
+      capturedBody = await input.clone().json();
+    }
+
+    return new Response(
+      JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        result: { data: 'success' },
+      }),
+      { status: 200, headers: { 'Content-Type': 'application/json' } }
+    );
+  }) as unknown as typeof fetch;
+
+  const client = new MCPWebClient({
+    serverUrl: 'http://localhost:3002',
+  });
+
+  const query = {
+    uuid: 'test-query-123',
+    prompt: 'test',
+    context: [],
+  };
+
+  const contextClient = client.contextualize(query);
+  await contextClient.callTool('test_tool', { arg: 'value' });
+
+  // Verify _meta was included in request body
+  expect(capturedBody).toBeDefined();
+  const requestBody = capturedBody as Record<string, unknown>;
+  expect(requestBody.params).toBeDefined();
+  const params = requestBody.params as Record<string, unknown>;
+  expect(params._meta).toBeDefined();
+  const metaParams = params._meta as Record<string, unknown>;
+  expect(metaParams.queryId).toBe('test-query-123');
+
+  globalThis.fetch = originalFetch;
+});
+
+test('listTools returns query tools when available', async () => {
+  const client = new MCPWebClient({
+    serverUrl: 'http://localhost:3002',
+  });
+
+  const query = {
+    uuid: 'test-query',
+    prompt: 'test',
+    context: [],
+    tools: [
+      {
+        name: 'tool1',
+        description: 'Tool 1',
+        handler: () => {},
+        inputSchema: { type: 'object' as const, properties: {} },
+      },
+      {
+        name: 'tool2',
+        description: 'Tool 2',
+        handler: () => {},
+      },
+    ],
+  };
+
+  const contextClient = client.contextualize(query);
+  const result = await contextClient.listTools();
+
+  expect(result.tools.length).toBe(2);
+  expect(result.tools[0].name).toBe('tool1');
+  expect(result.tools[1].name).toBe('tool2');
+});
+
+test('complete marks query as completed and prevents further calls', async () => {
+  globalThis.fetch = (async () => {
+    return new Response(JSON.stringify({}), { status: 200 });
+  }) as unknown as typeof fetch;
+
+  const client = new MCPWebClient({
+    serverUrl: 'http://localhost:3002',
+  });
+
+  const query = {
+    uuid: 'test-query',
+    prompt: 'test',
+    context: [],
+  };
+
+  const contextClient = client.contextualize(query);
+
+  // Complete the query
+  await contextClient.complete('Done!');
+
+  // Should throw when trying to call tools after completion
+  expect(async () => {
+    await contextClient.callTool('test_tool', {});
+  }).toThrow(QueryDoneErrorCode);
+
+  // Should throw when trying to complete again
+  expect(async () => {
+    await contextClient.complete('Done again!');
+  }).toThrow(QueryDoneErrorCode);
+
+  globalThis.fetch = originalFetch;
+});
+
+test('sendProgress throws on non-contextualized client', async () => {
+  const client = new MCPWebClient({
+    serverUrl: 'http://localhost:3002',
+  });
+
+  expect(async () => {
+    await client.sendProgress('test');
+  }).toThrow(ClientNotConextualizedErrorCode);
+});
+
+test('complete throws on non-contextualized client', async () => {
+  const client = new MCPWebClient({
+    serverUrl: 'http://localhost:3002',
+  });
+
+  expect(async () => {
+    await client.complete('test');
+  }).toThrow(ClientNotConextualizedErrorCode);
+});
+
+test('fail marks query as failed and prevents further operations', async () => {
+  globalThis.fetch = (async () => {
+    return new Response(JSON.stringify({}), { status: 200 });
+  }) as unknown as typeof fetch;
+
+  const client = new MCPWebClient({
+    serverUrl: 'http://localhost:3002',
+  });
+
+  const query = {
+    uuid: 'test-query',
+    prompt: 'test',
+    context: [],
+  };
+
+  const contextClient = client.contextualize(query);
+
+  // Fail the query
+  await contextClient.fail('Something went wrong');
+
+  // Should throw when trying to call tools after failure
+  expect(async () => {
+    await contextClient.callTool('test_tool', {});
+  }).toThrow(QueryDoneErrorCode);
+
+  globalThis.fetch = originalFetch;
+});