@frontmcp/skills 1.0.0-beta.9 → 1.0.0

package/catalog/frontmcp-testing/examples/test-direct-client/openai-claude-format-test.md

@@ -0,0 +1,79 @@
+---
+name: openai-claude-format-test
+reference: test-direct-client
+level: intermediate
+description: 'Verify that tools are returned in the correct format for OpenAI and Claude clients using `connectOpenAI` and `connectClaude`.'
+tags: [testing, openai, anthropic, direct-client, direct, client]
+features:
+  - 'Using `connectOpenAI()` with `serve: false` to get an in-memory client without starting an HTTP server'
+  - "Verifying OpenAI tool format: `{ type: 'function', function: { name, parameters } }`"
+  - 'Using dynamic import for `connectClaude` to test Claude tool format: `{ name, description, input_schema }`'
+  - 'Proper cleanup with `client.close()` after each test'
+---
+
+# Testing OpenAI and Claude Tool Formats
+
+Verify that tools are returned in the correct format for OpenAI and Claude clients using `connectOpenAI` and `connectClaude`.
+
+## Code
+
+```typescript
+// src/__tests__/client-formats.spec.ts
+import { connectOpenAI } from '@frontmcp/sdk';
+import { tool } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+const AddTool = tool({
+  name: 'add',
+  description: 'Add numbers',
+  inputSchema: { a: z.number(), b: z.number() },
+  outputSchema: { sum: z.number() },
+})((input) => ({ sum: input.a + input.b }));
+
+describe('OpenAI format', () => {
+  it('should return OpenAI-formatted tools', async () => {
+    const client = await connectOpenAI({
+      info: { name: 'test', version: '1.0.0' },
+      tools: [AddTool],
+      serve: false,
+    });
+
+    const tools = await client.listTools();
+    // OpenAI format: [{ type: 'function', function: { name, parameters } }]
+    expect(tools[0].type).toBe('function');
+    expect(tools[0].function.name).toBe('add');
+    expect(tools[0].function.parameters).toBeDefined();
+
+    await client.close();
+  });
+});
+
+describe('Claude format', () => {
+  it('should return Claude-formatted tools', async () => {
+    const { connectClaude } = await import('@frontmcp/sdk');
+    const client = await connectClaude({
+      info: { name: 'test', version: '1.0.0' },
+      tools: [AddTool],
+      serve: false,
+    });
+
+    const tools = await client.listTools();
+    // Claude format: [{ name, description, input_schema }]
+    expect(tools[0].name).toBe('add');
+    expect(tools[0].input_schema).toBeDefined();
+
+    await client.close();
+  });
+});
+```
+
+## What This Demonstrates
+
+- Using `connectOpenAI()` with `serve: false` to get an in-memory client without starting an HTTP server
+- Verifying OpenAI tool format: `{ type: 'function', function: { name, parameters } }`
+- Using dynamic import for `connectClaude` to test Claude tool format: `{ name, description, input_schema }`
+- Proper cleanup with `client.close()` after each test
+
+## Related
+
+- See `test-direct-client` for the full direct client testing reference

package/catalog/frontmcp-testing/examples/test-e2e-handler/basic-e2e-test.md

@@ -0,0 +1,67 @@
+---
+name: basic-e2e-test
+reference: test-e2e-handler
+level: basic
+description: 'Set up a basic E2E test that starts a server, connects a client, and verifies tools are listed.'
+tags: [testing, e2e, handler]
+features:
+  - 'Using `TestServer.create()` to start a server from its module export'
+  - 'Connecting a client via `server.connect()` for automatic base URL wiring'
+  - 'Proper lifecycle management with `beforeAll` / `afterAll` for setup and teardown'
+  - 'Using the `toContainTool` custom matcher from `@frontmcp/testing`'
+---
+
+# Basic E2E Test with McpTestClient
+
+Set up a basic E2E test that starts a server, connects a client, and verifies tools are listed.
+
+## Code
+
+```typescript
+// src/__tests__/server.e2e.spec.ts
+import { McpTestClient, TestServer } from '@frontmcp/testing';
+import Server from '../src/main';
+
+describe('Server E2E', () => {
+  let client: McpTestClient;
+  let server: TestServer;
+
+  beforeAll(async () => {
+    server = await TestServer.create(Server);
+    client = await server.connect();
+  });
+
+  afterAll(async () => {
+    await client.close();
+    await server.dispose();
+  });
+
+  it('should list all tools', async () => {
+    const { tools } = await client.listTools();
+    expect(tools.length).toBeGreaterThan(0);
+    expect(tools).toContainTool('add_numbers');
+  });
+
+  it('should list resources', async () => {
+    const { resources } = await client.listResources();
+    expect(resources.length).toBeGreaterThanOrEqual(0);
+  });
+
+  it('should list prompts', async () => {
+    const result = await client.getPrompt('summarize', { topic: 'testing' });
+    expect(result.messages).toBeDefined();
+    expect(result.messages.length).toBeGreaterThan(0);
+  });
+});
+```
+
+## What This Demonstrates
+
+- Using `TestServer.create()` to start a server from its module export
+- Connecting a client via `server.connect()` for automatic base URL wiring
+- Proper lifecycle management with `beforeAll` / `afterAll` for setup and teardown
+- Using the `toContainTool` custom matcher from `@frontmcp/testing`
+
+## Related
+
+- See `test-e2e-handler` for the full E2E handler testing reference

package/catalog/frontmcp-testing/examples/test-e2e-handler/manual-client-with-transport.md

@@ -0,0 +1,72 @@
+---
+name: manual-client-with-transport
+reference: test-e2e-handler
+level: advanced
+description: 'Use `McpTestClient.create()` with explicit transport settings for fine-grained control over E2E tests.'
+tags: [testing, session, transport, e2e, handler, manual]
+features:
+  - 'Using `TestServer.start()` with an explicit command and port for process-based server startup'
+  - "Building a client with `McpTestClient.create().withTransport('modern').buildAndConnect()` for streamable HTTP + strict sessions"
+  - 'Using `server.info.baseUrl` to wire the client to the correct address'
+  - 'Separate `disconnect()` / `stop()` calls for client and server teardown'
+  - 'The `toBeError()` and `toHaveTextContent()` custom matchers'
+---
+
+# Manual McpTestClient with Transport Configuration
+
+Use `McpTestClient.create()` with explicit transport settings for fine-grained control over E2E tests.
+
+## Code
+
+```typescript
+// src/__tests__/advanced.e2e.spec.ts
+import { McpTestClient, TestServer } from '@frontmcp/testing';
+
+describe('Advanced E2E with Transport Config', () => {
+  let server: TestServer;
+  let client: McpTestClient;
+
+  beforeAll(async () => {
+    server = await TestServer.start({
+      command: 'npx tsx src/main.ts',
+      port: 3004,
+    });
+
+    client = await McpTestClient.create({ baseUrl: server.info.baseUrl }).withTransport('modern').buildAndConnect();
+  });
+
+  afterAll(async () => {
+    await client.disconnect();
+    await server.stop();
+  });
+
+  it('should list tools after initialization', async () => {
+    const tools = await client.tools.list();
+    expect(tools.length).toBeGreaterThan(0);
+  });
+
+  it('should handle tool errors gracefully', async () => {
+    const result = await client.tools.call('nonexistent_tool', {});
+    expect(result).toBeError();
+  });
+
+  it('should call tool and verify result shape', async () => {
+    const result = await client.tools.call('add_numbers', { a: 1, b: 2 });
+    expect(result).toBeSuccessful();
+    expect(result).toHaveTextContent('3');
+  });
+});
+```
+
+## What This Demonstrates
+
+- Using `TestServer.start()` with an explicit command and port for process-based server startup
+- Building a client with `McpTestClient.create().withTransport('modern').buildAndConnect()` for streamable HTTP + strict sessions
+- Using `server.info.baseUrl` to wire the client to the correct address
+- Separate `disconnect()` / `stop()` calls for client and server teardown
+- The `toBeError()` and `toHaveTextContent()` custom matchers
+
+## Related
+
+- See `test-e2e-handler` for the full E2E handler testing reference
+- See `setup-testing` for fixture-based E2E patterns

package/catalog/frontmcp-testing/examples/test-e2e-handler/tool-call-and-error-e2e.md

@@ -0,0 +1,73 @@
+---
+name: tool-call-and-error-e2e
+reference: test-e2e-handler
+level: intermediate
+description: 'Test successful tool calls and verify that invalid inputs produce proper error responses over the full MCP protocol.'
+tags: [testing, e2e, handler, tool, call, error]
+features:
+  - 'Calling tools via `client.callTool()` and asserting success with `toBeSuccessful()`'
+  - 'Verifying text content in tool results with `result.content[0].text`'
+  - 'Checking `result.isError` for invalid input and nonexistent tool calls'
+  - 'Testing edge cases like zero values and missing optional parameters'
+---
+
+# E2E Testing Tool Calls and Error Responses
+
+Test successful tool calls and verify that invalid inputs produce proper error responses over the full MCP protocol.
+
+## Code
+
+```typescript
+// src/__tests__/tool-calls.e2e.spec.ts
+import { McpTestClient, TestServer } from '@frontmcp/testing';
+import Server from '../src/main';
+
+describe('Tool Call E2E', () => {
+  let client: McpTestClient;
+  let server: TestServer;
+
+  beforeAll(async () => {
+    server = await TestServer.create(Server);
+    client = await server.connect();
+  });
+
+  afterAll(async () => {
+    await client.close();
+    await server.dispose();
+  });
+
+  it('should call a tool and get a successful result', async () => {
+    const result = await client.callTool('add_numbers', { a: 5, b: 3 });
+    expect(result).toBeSuccessful();
+    expect(result.content[0].text).toContain('8');
+  });
+
+  it('should return isError for invalid input', async () => {
+    const result = await client.callTool('add_numbers', { a: 'bad' });
+    expect(result.isError).toBe(true);
+  });
+
+  it('should return error for nonexistent tool', async () => {
+    const result = await client.callTool('nonexistent_tool', {});
+    expect(result.isError).toBe(true);
+  });
+
+  it('should handle tool with optional parameters', async () => {
+    const result = await client.callTool('add_numbers', { a: 10, b: 0 });
+    expect(result).toBeSuccessful();
+    expect(result.content[0].text).toContain('10');
+  });
+});
+```
+
+## What This Demonstrates
+
+- Calling tools via `client.callTool()` and asserting success with `toBeSuccessful()`
+- Verifying text content in tool results with `result.content[0].text`
+- Checking `result.isError` for invalid input and nonexistent tool calls
+- Testing edge cases like zero values and missing optional parameters
+
+## Related
+
+- See `test-e2e-handler` for the full E2E handler testing reference
+- See `test-tool-unit` for unit-level tool testing

package/catalog/frontmcp-testing/examples/test-tool-unit/basic-tool-test.md

@@ -0,0 +1,69 @@
+---
+name: basic-tool-test
+reference: test-tool-unit
+level: basic
+description: "Test a simple tool's `execute()` method with mock context and verify the output."
+tags: [testing, tool, unit]
+features:
+  - 'Creating a mock `ToolContext` with all required methods (`get`, `tryGet`, `fail`, `mark`, `notify`, `respondProgress`)'
+  - 'Assigning the mock context to the tool instance via `Object.assign`'
+  - 'Testing multiple input scenarios including edge cases (negatives, zero)'
+---
+
+# Basic Tool Unit Test
+
+Test a simple tool's `execute()` method with mock context and verify the output.
+
+## Code
+
+```typescript
+// src/tools/__tests__/add.tool.spec.ts
+import { ToolContext } from '@frontmcp/sdk';
+import { AddTool } from '../add.tool';
+
+describe('AddTool', () => {
+  let tool: AddTool;
+
+  beforeEach(() => {
+    tool = new AddTool();
+
+    const ctx = {
+      get: jest.fn(),
+      tryGet: jest.fn(),
+      fail: jest.fn((err) => {
+        throw err;
+      }),
+      mark: jest.fn(),
+      notify: jest.fn(),
+      respondProgress: jest.fn(),
+    } as unknown as ToolContext;
+
+    Object.assign(tool, ctx);
+  });
+
+  it('should add two numbers', async () => {
+    const result = await tool.execute({ a: 2, b: 3 });
+    expect(result).toEqual({ sum: 5 });
+  });
+
+  it('should handle negative numbers', async () => {
+    const result = await tool.execute({ a: -1, b: -2 });
+    expect(result).toEqual({ sum: -3 });
+  });
+
+  it('should handle zero values', async () => {
+    const result = await tool.execute({ a: 0, b: 0 });
+    expect(result).toEqual({ sum: 0 });
+  });
+});
+```
+
+## What This Demonstrates
+
+- Creating a mock `ToolContext` with all required methods (`get`, `tryGet`, `fail`, `mark`, `notify`, `respondProgress`)
+- Assigning the mock context to the tool instance via `Object.assign`
+- Testing multiple input scenarios including edge cases (negatives, zero)
+
+## Related
+
+- See `test-tool-unit` for the full tool unit testing reference

package/catalog/frontmcp-testing/examples/test-tool-unit/schema-validation-test.md

@@ -0,0 +1,82 @@
+---
+name: schema-validation-test
+reference: test-tool-unit
+level: intermediate
+description: "Validate that a tool's Zod input schema rejects invalid data before `execute()` is called."
+tags: [testing, tool, unit, schema, validation]
+features:
+  - 'Testing the Zod input schema separately from the `execute()` method'
+  - 'Using `safeParse()` to check validation results without throwing'
+  - 'Covering rejection of wrong types, missing fields, and empty input'
+  - 'Combining schema validation with execution to test the full flow'
+---
+
+# Testing Zod Schema Validation for Tool Input
+
+Validate that a tool's Zod input schema rejects invalid data before `execute()` is called.
+
+## Code
+
+```typescript
+// src/tools/__tests__/add.tool.schema.spec.ts
+import { z } from 'zod';
+import { ToolContext } from '@frontmcp/sdk';
+import { AddTool } from '../add.tool';
+
+describe('AddTool schema validation', () => {
+  const schema = z.object({ a: z.number(), b: z.number() });
+
+  it('should accept valid numeric input', () => {
+    const result = schema.safeParse({ a: 5, b: 10 });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data).toEqual({ a: 5, b: 10 });
+    }
+  });
+
+  it('should reject string values for numeric fields', () => {
+    const result = schema.safeParse({ a: 'not-a-number', b: 3 });
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject missing required fields', () => {
+    const result = schema.safeParse({ a: 5 });
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject empty input', () => {
+    const result = schema.safeParse({});
+    expect(result.success).toBe(false);
+  });
+
+  it('should coerce valid input and produce correct output', async () => {
+    const tool = new AddTool();
+    const ctx = {
+      get: jest.fn(),
+      tryGet: jest.fn(),
+      fail: jest.fn((err) => {
+        throw err;
+      }),
+      mark: jest.fn(),
+      notify: jest.fn(),
+      respondProgress: jest.fn(),
+    } as unknown as ToolContext;
+    Object.assign(tool, ctx);
+
+    const parsed = schema.parse({ a: 7, b: 3 });
+    const result = await tool.execute(parsed);
+    expect(result).toEqual({ sum: 10 });
+  });
+});
+```
+
+## What This Demonstrates
+
+- Testing the Zod input schema separately from the `execute()` method
+- Using `safeParse()` to check validation results without throwing
+- Covering rejection of wrong types, missing fields, and empty input
+- Combining schema validation with execution to test the full flow
+
+## Related
+
+- See `test-tool-unit` for the full tool unit testing reference

package/catalog/frontmcp-testing/examples/test-tool-unit/tool-error-handling-test.md

@@ -0,0 +1,92 @@
+---
+name: tool-error-handling-test
+reference: test-tool-unit
+level: advanced
+description: 'Test that a tool throws the correct MCP error classes with proper error codes and JSON-RPC error shapes.'
+tags: [testing, json-rpc, tool, unit, error, handling]
+features:
+  - 'Verifying specific error classes with `toBeInstanceOf` instead of just checking that something threw'
+  - 'Asserting MCP error codes from `MCP_ERROR_CODES` constants'
+  - 'Validating the JSON-RPC error shape returned by `toJsonRpcError()`'
+  - 'Testing both success and failure paths in the same suite'
+---
+
+# Testing Tool Error Handling and Error Classes
+
+Test that a tool throws the correct MCP error classes with proper error codes and JSON-RPC error shapes.
+
+## Code
+
+```typescript
+// src/tools/__tests__/lookup.tool.spec.ts
+import { ToolContext } from '@frontmcp/sdk';
+import { ResourceNotFoundError, MCP_ERROR_CODES } from '@frontmcp/sdk';
+import { LookupTool } from '../lookup.tool';
+
+describe('LookupTool error handling', () => {
+  let tool: LookupTool;
+
+  beforeEach(() => {
+    tool = new LookupTool();
+
+    const ctx = {
+      get: jest.fn(),
+      tryGet: jest.fn(),
+      fail: jest.fn((err) => {
+        throw err;
+      }),
+      mark: jest.fn(),
+      notify: jest.fn(),
+      respondProgress: jest.fn(),
+    } as unknown as ToolContext;
+
+    Object.assign(tool, ctx);
+  });
+
+  it('should throw ResourceNotFoundError for missing resource', async () => {
+    await expect(tool.execute({ id: 'nonexistent' })).rejects.toThrow(ResourceNotFoundError);
+  });
+
+  it('should produce correct MCP error code', async () => {
+    try {
+      await tool.execute({ id: 'nonexistent' });
+      fail('Expected an error to be thrown');
+    } catch (err) {
+      expect(err).toBeInstanceOf(ResourceNotFoundError);
+      expect((err as ResourceNotFoundError).mcpErrorCode).toBe(MCP_ERROR_CODES.RESOURCE_NOT_FOUND);
+    }
+  });
+
+  it('should produce valid JSON-RPC error shape', async () => {
+    try {
+      await tool.execute({ id: 'nonexistent' });
+      fail('Expected an error to be thrown');
+    } catch (err) {
+      const rpc = (err as ResourceNotFoundError).toJsonRpcError();
+      expect(rpc).toEqual({
+        code: -32002,
+        message: expect.any(String),
+        data: expect.objectContaining({ uri: expect.any(String) }),
+      });
+    }
+  });
+
+  it('should succeed for valid resource id', async () => {
+    const result = await tool.execute({ id: 'existing-123' });
+    expect(result).toBeDefined();
+    expect(result.content).toBeDefined();
+  });
+});
+```
+
+## What This Demonstrates
+
+- Verifying specific error classes with `toBeInstanceOf` instead of just checking that something threw
+- Asserting MCP error codes from `MCP_ERROR_CODES` constants
+- Validating the JSON-RPC error shape returned by `toJsonRpcError()`
+- Testing both success and failure paths in the same suite
+
+## Related
+
+- See `test-tool-unit` for the full tool unit testing reference
+- See `setup-testing` for error class testing patterns

package/catalog/frontmcp-testing/references/setup-testing.md

@@ -1,3 +1,8 @@
+---
+name: setup-testing
+description: Configure Jest, write unit and E2E tests, and enforce 95%+ coverage for FrontMCP applications
+---
+
 # Set Up Testing for FrontMCP Applications
 
 This skill covers testing FrontMCP applications at three levels: unit tests for individual tools/resources/prompts, E2E tests exercising the full MCP protocol, and manual testing with `frontmcp dev`.
@@ -311,6 +316,8 @@ test('prompts return well-formed messages', async ({ mcp }) => {
 
 For more control, use `McpTestClient` and `TestServer` directly:
 
+> **Note:** `npx tsx src/main.ts` is correct **only inside E2E tests** (the test framework uses it internally via `resolveServerCommand`). For development and running the server outside of tests, always use `frontmcp dev` (or your package.json `dev` script). Never run `npx tsx src/main.ts` directly for development.
+
 ```typescript
 // advanced.e2e.spec.ts
 import { McpTestClient, TestServer } from '@frontmcp/testing';
@@ -544,6 +551,16 @@ node scripts/fix-unused-imports.mjs feature/my-branch
 | Istanbul shows 0% coverage for async methods | TypeScript compilation source-map mismatch              | Known issue with `ts-jest` and certain async patterns; check `tsconfig.spec.json` source-map settings |
 | Auth E2E test returns 401 unexpectedly       | Token not set or expired                                | Call `mcp.setAuthToken(token)` before the tool call; use `auth.createToken()` with valid claims       |
 
+## Examples
+
+| Example                                                                                         | Level        | Description                                                                                                                                       |
+| ----------------------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`fixture-based-e2e-test`](../examples/setup-testing/fixture-based-e2e-test.md)                 | Advanced     | Write E2E tests using the fixture API from `@frontmcp/testing` that manages server lifecycle automatically and uses MCP-specific custom matchers. |
+| [`jest-config-with-coverage`](../examples/setup-testing/jest-config-with-coverage.md)           | Basic        | Set up a Jest configuration file that enforces 95%+ coverage across all metrics for a FrontMCP library.                                           |
+| [`unit-test-tool-resource-prompt`](../examples/setup-testing/unit-test-tool-resource-prompt.md) | Intermediate | Write unit tests for the three core MCP primitives, verifying that outputs match the expected MCP response shapes.                                |
+
+> See all examples in [`examples/setup-testing/`](../examples/setup-testing/)
+
 ## Reference
 
 - [Testing Documentation](https://docs.agentfront.dev/frontmcp/testing/overview)

package/catalog/frontmcp-testing/references/test-auth.md

@@ -1,3 +1,8 @@
+---
+name: test-auth
+description: Test authenticated MCP servers with TestTokenFactory, MockOAuthServer, and role-based access
+---
+
 # Testing with Authentication
 
 ```typescript
@@ -86,3 +91,13 @@ describe('OAuth Flow', () => {
   });
 });
 ```
+
+## Examples
+
+| Example                                                                     | Level        | Description                                                                                               |
+| --------------------------------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------------- |
+| [`oauth-flow-test`](../examples/test-auth/oauth-flow-test.md)               | Advanced     | Use `MockOAuthServer` to simulate an OAuth identity provider and test the authorization code flow.        |
+| [`role-based-access-test`](../examples/test-auth/role-based-access-test.md) | Intermediate | Verify that tools enforce role-based access by testing admin and user tokens against protected endpoints. |
+| [`token-factory-test`](../examples/test-auth/token-factory-test.md)         | Basic        | Use `TestTokenFactory` to create tokens and verify authenticated and unauthenticated requests.            |
+
+> See all examples in [`examples/test-auth/`](../examples/test-auth/)

package/catalog/frontmcp-testing/references/test-browser-build.md

@@ -1,3 +1,8 @@
+---
+name: test-browser-build
+description: Validate browser build output for Node.js-free bundles and test with Playwright
+---
+
 # Testing Browser Build
 
 After building with `frontmcp build --target browser`, validate the output:
@@ -55,3 +60,12 @@ test('browser client can call a tool', async ({ page }) => {
   expect(result).toContain('8');
 });
 ```
+
+## Examples
+
+| Example                                                                                    | Level    | Description                                                                                      |
+| ------------------------------------------------------------------------------------------ | -------- | ------------------------------------------------------------------------------------------------ |
+| [`browser-bundle-validation`](../examples/test-browser-build/browser-bundle-validation.md) | Basic    | Verify that the browser build produces a valid bundle without Node.js-only module references.    |
+| [`playwright-browser-test`](../examples/test-browser-build/playwright-browser-test.md)     | Advanced | Use Playwright to test a browser-based MCP client that loads and calls tools from an MCP server. |
+
+> See all examples in [`examples/test-browser-build/`](../examples/test-browser-build/)

package/catalog/frontmcp-testing/references/test-cli-binary.md

@@ -1,3 +1,8 @@
+---
+name: test-cli-binary
+description: Test CLI binary and SEA build for startup, health check, and JS bundle import
+---
+
 # Testing CLI Binary / SEA Build
 
 After building with `frontmcp build --target cli`, test the binary:
@@ -46,3 +51,12 @@ describe('JS Bundle', () => {
   });
 });
 ```
+
+## Examples
+
+| Example                                                                         | Level        | Description                                                                                                        |
+| ------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------------------ |
+| [`binary-startup-test`](../examples/test-cli-binary/binary-startup-test.md)     | Basic        | Verify that a compiled CLI binary starts correctly and responds to health checks.                                  |
+| [`js-bundle-import-test`](../examples/test-cli-binary/js-bundle-import-test.md) | Intermediate | Verify that the compiled JS bundle can be imported and exports the expected modules after a `frontmcp build` step. |
+
+> See all examples in [`examples/test-cli-binary/`](../examples/test-cli-binary/)

package/catalog/frontmcp-testing/references/test-direct-client.md

@@ -1,3 +1,8 @@
+---
+name: test-direct-client
+description: In-memory testing with create() and connectOpenAI/connectClaude without HTTP overhead
+---
+
 # Testing with Direct Client (No HTTP)
 
 Uses `connect()` or `create()` for in-memory testing without HTTP overhead.
@@ -60,3 +65,12 @@ describe('Direct Client Testing', () => {
   });
 });
 ```
+
+## Examples
+
+| Example                                                                                    | Level        | Description                                                                                                                   |
+| ------------------------------------------------------------------------------------------ | ------------ | ----------------------------------------------------------------------------------------------------------------------------- |
+| [`basic-create-test`](../examples/test-direct-client/basic-create-test.md)                 | Basic        | Test tools in-memory without any HTTP overhead using the `create()` function from `@frontmcp/sdk`.                            |
+| [`openai-claude-format-test`](../examples/test-direct-client/openai-claude-format-test.md) | Intermediate | Verify that tools are returned in the correct format for OpenAI and Claude clients using `connectOpenAI` and `connectClaude`. |
+
+> See all examples in [`examples/test-direct-client/`](../examples/test-direct-client/)