@frontmcp/skills 1.1.2 → 1.2.0

package/catalog/frontmcp-guides/examples/example-knowledge-base/vector-search-and-resources.md

@@ -2,14 +2,20 @@
 name: vector-search-and-resources
 reference: example-knowledge-base
 level: intermediate
-description: 'Shows a semantic search tool with embedding generation and a resource template for retrieving documents by ID using URI parameters.'
-tags: [guides, openai, semantic-search, knowledge-base, knowledge, base]
+description: Shows a semantic search tool with embedding generation and a resource template for retrieving documents by ID using URI parameters.
+tags:
+  - guides
+  - vectoriadb
+  - semantic-search
+  - knowledge-base
+  - knowledge
+  - base
 features:
-  - 'Semantic search tool that generates query embeddings via `this.fetch()` to OpenAI'
-  - 'Using `this.mark()` for execution phase tracing'
+  - Semantic search tool that delegates embedding generation to VectoriaDB via `store.search(query, topK)`
+  - Using `this.mark()` for execution phase tracing
   - "Resource template with `uriTemplate: 'kb://documents/{documentId}'` for parameterized URIs"
   - 'Typed params via `ResourceContext<{ documentId: string }>` for type-safe URI parameters'
-  - 'Returning `ReadResourceResult` with proper MCP protocol structure'
+  - Returning `ReadResourceResult` with proper MCP protocol structure
 ---
 
 # Knowledge Base: Semantic Search Tool and Resource Template
@@ -22,7 +28,7 @@ Shows a semantic search tool with embedding generation and a resource template f
 // src/search/tools/search-docs.tool.ts
 import { Tool, ToolContext, z } from '@frontmcp/sdk';
 
-import { VECTOR_STORE } from '../../ingestion/providers/vector-store.provider';
+import { VectorStoreProvider } from '../../ingestion/providers/vector-store.provider';
 
 @Tool({
   name: 'search_docs',
@@ -45,46 +51,29 @@ import { VECTOR_STORE } from '../../ingestion/providers/vector-store.provider';
 })
 export class SearchDocsTool extends ToolContext {
   async execute(input: { query: string; topK: number }) {
-    const store = this.get(VECTOR_STORE);
-
-    // Mark execution phases for observability
-    this.mark('embedding-query');
-    const queryEmbedding = await this.generateQueryEmbedding(input.query);
+    const store = this.get(VectorStoreProvider);
 
+    // VectoriaDB handles embedding generation internally — pass the raw query.
     this.mark('searching');
-    const chunks = await store.search(queryEmbedding, input.topK);
+    const matches = await store.search(input.query, input.topK);
 
-    const results = chunks.map((chunk) => ({
-      documentId: chunk.documentId,
-      content: chunk.content,
-      score: chunk.metadata.score ? parseFloat(chunk.metadata.score) : 0,
-      title: chunk.metadata.title ?? 'Untitled',
+    const results = matches.map((m) => ({
+      documentId: m.metadata.documentId,
+      content: m.metadata.content,
+      score: m.score,
+      title: m.metadata.title ?? 'Untitled',
     }));
 
     return { results, total: results.length };
   }
-
-  private async generateQueryEmbedding(query: string): Promise<number[]> {
-    const response = await this.fetch('https://api.openai.com/v1/embeddings', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
-      },
-      body: JSON.stringify({ input: query, model: 'text-embedding-3-small' }),
-    });
-    const data = await response.json();
-    return data.data[0].embedding;
-  }
 }
 ```
 
 ```typescript
 // src/search/resources/doc.resource.ts
-import type { ReadResourceResult } from '@frontmcp/protocol';
-import { ResourceContext, ResourceTemplate } from '@frontmcp/sdk';
+import { ReadResourceResult, ResourceContext, ResourceNotFoundError, ResourceTemplate } from '@frontmcp/sdk';
 
-import { VECTOR_STORE } from '../../ingestion/providers/vector-store.provider';
+import { VectorStoreProvider } from '../../ingestion/providers/vector-store.provider';
 
 @ResourceTemplate({
   name: 'document',
@@ -94,20 +83,20 @@ import { VECTOR_STORE } from '../../ingestion/providers/vector-store.provider';
 })
 export class DocResource extends ResourceContext<{ documentId: string }> {
   async execute(uri: string, params: { documentId: string }): Promise<ReadResourceResult> {
-    const store = this.get(VECTOR_STORE);
-    const chunks = await store.getByDocumentId(params.documentId);
+    const store = this.get(VectorStoreProvider);
+    const matches = await store.getByDocumentId(params.documentId);
 
-    if (chunks.length === 0) {
-      this.fail(new Error(`Document not found: ${params.documentId}`));
+    if (matches.length === 0) {
+      // Use a typed MCP error so the protocol response carries the correct JSON-RPC code.
+      throw new ResourceNotFoundError(uri);
     }
 
     const document = {
       documentId: params.documentId,
-      title: chunks[0].metadata.title ?? 'Untitled',
-      chunks: chunks.map((c) => ({
-        chunkIndex: c.metadata.chunkIndex,
-        content: c.content,
-      })),
+      title: matches[0].metadata.title ?? 'Untitled',
+      chunks: matches
+        .map((m) => ({ chunkIndex: m.metadata.chunkIndex, content: m.metadata.content }))
+        .sort((a, b) => a.chunkIndex - b.chunkIndex),
     };
 
     return {
@@ -125,7 +114,7 @@ export class DocResource extends ResourceContext<{ documentId: string }> {
 
 ## What This Demonstrates
 
-- Semantic search tool that generates query embeddings via `this.fetch()` to OpenAI
+- Semantic search tool that delegates embedding generation to VectoriaDB via `store.search(query, topK)`
 - Using `this.mark()` for execution phase tracing
 - Resource template with `uriTemplate: 'kb://documents/{documentId}'` for parameterized URIs
 - Typed params via `ResourceContext<{ documentId: string }>` for type-safe URI parameters

package/catalog/frontmcp-guides/examples/example-task-manager/auth-and-crud-tools.md

@@ -2,19 +2,25 @@
 name: auth-and-crud-tools
 reference: example-task-manager
 level: basic
-description: 'Shows how to create CRUD tools with authentication, using `this.context.session` for user isolation and `this.get()` for dependency injection.'
-tags: [guides, auth, session, task-manager, task, manager]
+description: Shows how to create CRUD tools with authentication, using `this.auth?.user.sub` (the FrontMcpAuthContext exposed on every execution context) for user isolation and `this.get()` for dependency injection.
+tags:
+  - guides
+  - auth
+  - session
+  - task-manager
+  - task
+  - manager
 features:
-  - 'Using `this.context.session?.userId` for per-user data isolation'
-  - 'Using `this.get(TASK_STORE)` for dependency injection of providers'
-  - 'Enforcing authentication with `this.fail()` when no session exists'
-  - 'Optional input fields with `.optional()` for filtering'
+  - Using `this.auth?.user.sub` (FrontMcpAuthContext) for per-user data isolation
+  - Using `this.get(TaskStoreProvider)` for dependency injection of providers (class-as-token)
+  - Enforcing authentication with `this.fail()` when no authenticated user is present in `this.auth`
+  - Optional input fields with `.optional()` for filtering
   - '`outputSchema` with nested `z.array(z.object(...))` for structured responses'
 ---
 
 # Task Manager: Authenticated CRUD Tools
 
-Shows how to create CRUD tools with authentication, using `this.context.session` for user isolation and `this.get()` for dependency injection.
+Shows how to create CRUD tools with authentication, using `this.auth?.user.sub` (the FrontMcpAuthContext exposed on every execution context) for user isolation and `this.get()` for dependency injection.
 
 ## Code
 
@@ -22,7 +28,7 @@ Shows how to create CRUD tools with authentication, using `this.context.session`
 // src/tools/create-task.tool.ts
 import { Tool, ToolContext, z } from '@frontmcp/sdk';
 
-import { TASK_STORE } from '../providers/task-store.provider';
+import { TaskStoreProvider } from '../providers/task-store.provider';
 
 @Tool({
   name: 'create_task',
@@ -42,10 +48,11 @@ import { TASK_STORE } from '../providers/task-store.provider';
 export class CreateTaskTool extends ToolContext {
   async execute(input: { title: string; priority: 'low' | 'medium' | 'high' }) {
     // Inject the task store via DI
-    const store = this.get(TASK_STORE);
+    // Inject the task store via DI (the class itself is the token)
+    const store = this.get(TaskStoreProvider);
 
-    // Get the authenticated user's ID from the session
-    const userId = this.context.session?.userId;
+    // Get the authenticated user's id from FrontMcpAuthContext (`this.auth.user.sub`)
+    const userId = this.auth?.user.sub;
     if (!userId) {
       this.fail(new Error('Authentication required'));
     }
@@ -72,7 +79,7 @@ export class CreateTaskTool extends ToolContext {
 // src/tools/list-tasks.tool.ts
 import { Tool, ToolContext, z } from '@frontmcp/sdk';
 
-import { TASK_STORE } from '../providers/task-store.provider';
+import { TaskStoreProvider } from '../providers/task-store.provider';
 
 @Tool({
   name: 'list_tasks',
@@ -95,8 +102,8 @@ import { TASK_STORE } from '../providers/task-store.provider';
 })
 export class ListTasksTool extends ToolContext {
   async execute(input: { status?: 'pending' | 'in_progress' | 'done' }) {
-    const store = this.get(TASK_STORE);
-    const userId = this.context.session?.userId;
+    const store = this.get(TaskStoreProvider);
+    const userId = this.auth?.user.sub;
 
     if (!userId) {
       this.fail(new Error('Authentication required'));
@@ -124,9 +131,9 @@ export class ListTasksTool extends ToolContext {
 
 ## What This Demonstrates
 
-- Using `this.context.session?.userId` for per-user data isolation
-- Using `this.get(TASK_STORE)` for dependency injection of providers
-- Enforcing authentication with `this.fail()` when no session exists
+- Using `this.auth?.user.sub` (FrontMcpAuthContext) for per-user data isolation
+- Using `this.get(TaskStoreProvider)` for dependency injection of providers (class-as-token)
+- Enforcing authentication with `this.fail()` when no authenticated user is present in `this.auth`
 - Optional input fields with `.optional()` for filtering
 - `outputSchema` with nested `z.array(z.object(...))` for structured responses
 

package/catalog/frontmcp-guides/examples/example-task-manager/authenticated-e2e-tests.md

@@ -7,9 +7,9 @@ tags: [guides, auth, session, e2e, unit-test, task-manager]
 features:
   - 'Using `TestTokenFactory` to create JWT tokens for authenticated E2E tests'
   - 'Chaining `.withToken(token).buildAndConnect()` for authenticated clients'
-  - 'Unit testing with mocked DI tokens via `this.get()` mock'
-  - 'Mocking session context (`context: { session: { userId } }`) for auth-dependent tools'
-  - 'Testing the unauthenticated error path (no session)'
+  - 'Unit testing tools by mocking `this.get(TaskStoreProvider)` and the `auth` getter'
+  - 'Mocking `this.auth = { user: { sub } }` (FrontMcpAuthContext) for auth-dependent tools'
+  - 'Testing the unauthenticated error path (no `auth` / anonymous user)'
 ---
 
 # Task Manager: Authenticated E2E Tests
@@ -43,7 +43,7 @@ describe('Task Manager E2E', () => {
   });
 
   it('should list all CRUD tools', async () => {
-    const { tools } = await client.listTools();
+    const tools = await client.tools.list();
     const names = tools.map((t) => t.name);
 
     expect(names).toContain('create_task');
@@ -53,16 +53,16 @@ describe('Task Manager E2E', () => {
   });
 
   it('should create and list a task', async () => {
-    const createResult = await client.callTool('create_task', {
+    const createResult = await client.tools.call('create_task', {
       title: 'E2E test task',
       priority: 'high',
     });
-    expect(createResult).toBeSuccessful();
+    expect(createResult.isError).toBeFalsy();
 
-    const listResult = await client.callTool('list_tasks', {});
-    expect(listResult).toBeSuccessful();
+    const listResult = await client.tools.call('list_tasks', {});
+    expect(listResult.isError).toBeFalsy();
 
-    const parsed = JSON.parse(listResult.content[0].text);
+    const parsed = listResult.json<{ tasks: Array<{ title: string }> }>();
     expect(parsed.tasks.length).toBeGreaterThan(0);
     expect(parsed.tasks.some((t: { title: string }) => t.title === 'E2E test task')).toBe(true);
   });
@@ -70,15 +70,16 @@ describe('Task Manager E2E', () => {
 ```
 
 ```typescript
-// test/create-task.tool.spec.ts — Unit test with mocked session
+// test/create-task.tool.spec.ts — Unit test with mocked auth context
 import { ToolContext } from '@frontmcp/sdk';
+
+import { TaskStoreProvider } from '../src/providers/task-store.provider';
 import { CreateTaskTool } from '../src/tools/create-task.tool';
-import { TASK_STORE, type TaskStore } from '../src/providers/task-store.provider';
 import type { Task } from '../src/types/task';
 
 describe('CreateTaskTool', () => {
   let tool: CreateTaskTool;
-  let mockStore: jest.Mocked<TaskStore>;
+  let mockStore: jest.Mocked<TaskStoreProvider>;
 
   beforeEach(() => {
     tool = new CreateTaskTool();
@@ -87,13 +88,13 @@ describe('CreateTaskTool', () => {
       list: jest.fn(),
       update: jest.fn(),
       delete: jest.fn(),
-    };
+    } as unknown as jest.Mocked<TaskStoreProvider>;
   });
 
   function applyContext(userId: string | undefined): void {
     const ctx = {
-      get: jest.fn((token: symbol) => {
-        if (token === TASK_STORE) return mockStore;
+      get: jest.fn((token: unknown) => {
+        if (token === TaskStoreProvider) return mockStore;
         throw new Error(`Unknown token: ${String(token)}`);
       }),
       tryGet: jest.fn(),
@@ -101,9 +102,10 @@ describe('CreateTaskTool', () => {
         throw err;
       }),
       mark: jest.fn(),
-      notify: jest.fn(),
-      respondProgress: jest.fn(),
-      context: { session: userId ? { userId } : undefined },
+      notify: jest.fn().mockResolvedValue(true),
+      progress: jest.fn().mockResolvedValue(true),
+      // Stub the FrontMcpAuthContext exposed via the `auth` getter on the real SDK.
+      auth: userId ? { user: { sub: userId }, isAnonymous: false } : undefined,
     } as unknown as ToolContext;
     Object.assign(tool, ctx);
   }
@@ -139,9 +141,9 @@ describe('CreateTaskTool', () => {
 
 - Using `TestTokenFactory` to create JWT tokens for authenticated E2E tests
 - Chaining `.withToken(token).buildAndConnect()` for authenticated clients
-- Unit testing with mocked DI tokens via `this.get()` mock
-- Mocking session context (`context: { session: { userId } }`) for auth-dependent tools
-- Testing the unauthenticated error path (no session)
+- Unit testing tools by mocking `this.get(TaskStoreProvider)` and the `auth` getter
+- Mocking `this.auth = { user: { sub } }` (FrontMcpAuthContext) for auth-dependent tools
+- Testing the unauthenticated error path (no `auth` / anonymous user)
 
 ## Related
 

package/catalog/frontmcp-guides/examples/example-task-manager/redis-provider-with-di.md

@@ -2,20 +2,25 @@
 name: redis-provider-with-di
 reference: example-task-manager
 level: intermediate
-description: 'Shows how to create a Redis-backed provider with a DI token, lifecycle hooks (`onInit`/`onDestroy`), and how tools inject it.'
-tags: [guides, redis, node, task-manager, task, manager]
+description: Shows how to create a Redis-backed provider using the class-as-token DI pattern (`@Provider({ name, scope })`) plus an `AsyncProvider` factory that runs the async Redis setup before any tool is invoked.
+tags:
+  - guides
+  - redis
+  - node
+  - task-manager
+  - task
+  - manager
 features:
-  - "Defining an interface and DI token (`Symbol('TaskStore')`) for the provider"
-  - 'Using `@Provider({ token: TASK_STORE })` to register the provider for DI'
-  - 'Lifecycle hooks: `onInit()` for connection setup, `onDestroy()` for cleanup'
-  - 'Lazy-loading `ioredis` via dynamic `import()` in `onInit()`'
-  - 'Using `@frontmcp/utils` for `randomUUID()` instead of `node:crypto`'
-  - 'Per-user data isolation using Redis hash keys (`tasks:${userId}`)'
+  - 'Class-as-token DI: `@Provider({ name, scope })` and inject via `this.get(TaskStoreProvider)`'
+  - Building the singleton with `AsyncProvider({ provide, name, scope, useFactory })` for async setup
+  - 'Cleanup: explicit `disconnect()` method (called from the host before `server.dispose()`) — `@Provider` has no `onDestroy` hook'
+  - Using `@frontmcp/utils` for `randomUUID()` instead of `node:crypto`
+  - Per-user data isolation using Redis hash keys (`tasks:${userId}`)
 ---
 
 # Task Manager: Redis Provider with Dependency Injection
 
-Shows how to create a Redis-backed provider with a DI token, lifecycle hooks (`onInit`/`onDestroy`), and how tools inject it.
+Shows how to create a Redis-backed provider using the class-as-token DI pattern (`@Provider({ name, scope })`) plus an `AsyncProvider` factory that runs the async Redis setup before any tool is invoked.
 
 ## Code
 
@@ -33,32 +38,18 @@ export interface Task {
 
 ```typescript
 // src/providers/task-store.provider.ts
-import { Provider } from '@frontmcp/sdk';
-import type { Token } from '@frontmcp/di';
-import type { Task } from '../types/task';
-
-export interface TaskStore {
-  create(task: Omit<Task, 'id' | 'createdAt'>): Promise<Task>;
-  list(userId: string): Promise<Task[]>;
-  update(id: string, userId: string, data: Partial<Pick<Task, 'title' | 'priority' | 'status'>>): Promise<Task>;
-  delete(id: string, userId: string): Promise<void>;
-}
+import Redis, { Redis as RedisClient } from 'ioredis';
 
-// DI token — tools use this.get(TASK_STORE) to access the provider
-export const TASK_STORE: Token<TaskStore> = Symbol('TaskStore');
+import { AsyncProvider, Provider, ProviderScope } from '@frontmcp/sdk';
+import { randomUUID } from '@frontmcp/utils';
 
-@Provider({ token: TASK_STORE })
-export class RedisTaskStoreProvider implements TaskStore {
-  private redis!: import('ioredis').default;
+import type { Task } from '../types/task';
 
-  // Lifecycle: initialize Redis connection
-  async onInit(): Promise<void> {
-    const Redis = (await import('ioredis')).default;
-    this.redis = new Redis(process.env.REDIS_URL ?? 'redis://localhost:6379');
-  }
+@Provider({ name: 'task-store', scope: ProviderScope.GLOBAL })
+export class TaskStoreProvider {
+  constructor(private readonly redis: RedisClient) {}
 
   async create(input: Omit<Task, 'id' | 'createdAt'>): Promise<Task> {
-    const { randomUUID } = await import('@frontmcp/utils');
     const task: Task = {
       ...input,
       id: randomUUID(),
@@ -90,26 +81,44 @@ export class RedisTaskStoreProvider implements TaskStore {
     }
   }
 
-  // Lifecycle: close Redis connection on shutdown
-  async onDestroy(): Promise<void> {
+  // `@Provider` has no `onDestroy` hook — expose explicit cleanup that the
+  // host calls before `server.dispose()` (e.g., from the SIGTERM/process
+  // shutdown side-effect handler).
+  async disconnect(): Promise<void> {
     await this.redis.quit();
   }
 }
+
+// AsyncProvider factory: builds the TaskStoreProvider singleton with a connected Redis client.
+// Tools still inject the class itself: `this.get(TaskStoreProvider)`.
+export const createTaskStoreProvider = AsyncProvider({
+  provide: TaskStoreProvider,
+  name: 'task-store-factory',
+  scope: ProviderScope.GLOBAL,
+  inject: () => [] as const,
+  useFactory: async () => {
+    const redis = new Redis(process.env.REDIS_URL ?? 'redis://localhost:6379');
+    return new TaskStoreProvider(redis);
+  },
+});
 ```
 
 ```typescript
 // src/tasks.app.ts
 import { App } from '@frontmcp/sdk';
-import { RedisTaskStoreProvider } from './providers/task-store.provider';
+
+import { createTaskStoreProvider } from './providers/task-store.provider';
 import { CreateTaskTool } from './tools/create-task.tool';
+import { DeleteTaskTool } from './tools/delete-task.tool';
 import { ListTasksTool } from './tools/list-tasks.tool';
 import { UpdateTaskTool } from './tools/update-task.tool';
-import { DeleteTaskTool } from './tools/delete-task.tool';
 
 @App({
   name: 'Tasks',
   description: 'Task management with CRUD operations',
-  providers: [RedisTaskStoreProvider],
+  // The AsyncProvider factory binds the `TaskStoreProvider` class as the DI token.
+  // Tools inject the same class via `this.get(TaskStoreProvider)`.
+  providers: [createTaskStoreProvider],
   tools: [CreateTaskTool, ListTasksTool, UpdateTaskTool, DeleteTaskTool],
 })
 export class TasksApp {}
@@ -117,10 +126,9 @@ export class TasksApp {}
 
 ## What This Demonstrates
 
-- Defining an interface and DI token (`Symbol('TaskStore')`) for the provider
-- Using `@Provider({ token: TASK_STORE })` to register the provider for DI
-- Lifecycle hooks: `onInit()` for connection setup, `onDestroy()` for cleanup
-- Lazy-loading `ioredis` via dynamic `import()` in `onInit()`
+- Class-as-token DI: `@Provider({ name, scope })` and inject via `this.get(TaskStoreProvider)`
+- Building the singleton with `AsyncProvider({ provide, name, scope, useFactory })` for async setup
+- Cleanup: explicit `disconnect()` method (called from the host before `server.dispose()`) — `@Provider` has no `onDestroy` hook
 - Using `@frontmcp/utils` for `randomUUID()` instead of `node:crypto`
 - Per-user data isolation using Redis hash keys (`tasks:${userId}`)
 

package/catalog/frontmcp-guides/examples/example-weather-api/server-and-app-setup.md

@@ -7,7 +7,7 @@ tags: [guides, weather, api, app, setup]
 features:
   - 'Server entry point with `@FrontMcp` decorator and `info` configuration'
   - 'App registration with `@App` grouping tools and resources together'
-  - 'Static resource that returns JSON data via `read()`'
+  - 'Static resource that returns JSON data via `execute(uri)` and `ReadResourceResult`'
   - 'Clean separation between server, app, tools, and resources'
 ---
 
@@ -20,6 +20,7 @@ Shows the server entry point, app registration, and static resource for a beginn
 ```typescript
 // src/main.ts
 import { FrontMcp } from '@frontmcp/sdk';
+
 import { WeatherApp } from './weather.app';
 
 @FrontMcp({
@@ -32,8 +33,9 @@ export default class WeatherServer {}
 ```typescript
 // src/weather.app.ts
 import { App } from '@frontmcp/sdk';
-import { GetWeatherTool } from './tools/get-weather.tool';
+
 import { CitiesResource } from './resources/cities.resource';
+import { GetWeatherTool } from './tools/get-weather.tool';
 
 @App({
   name: 'Weather',
@@ -46,7 +48,7 @@ export class WeatherApp {}
 
 ```typescript
 // src/resources/cities.resource.ts
-import { Resource, ResourceContext } from '@frontmcp/sdk';
+import { ReadResourceResult, Resource, ResourceContext } from '@frontmcp/sdk';
 
 const SUPPORTED_CITIES = ['London', 'Tokyo', 'New York', 'Paris', 'Sydney', 'Berlin', 'Toronto', 'Mumbai'];
 
@@ -57,8 +59,16 @@ const SUPPORTED_CITIES = ['London', 'Tokyo', 'New York', 'Paris', 'Sydney', 'Ber
   mimeType: 'application/json',
 })
 export class CitiesResource extends ResourceContext {
-  async read() {
-    return JSON.stringify(SUPPORTED_CITIES);
+  async execute(uri: string): Promise<ReadResourceResult> {
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: 'application/json',
+          text: JSON.stringify(SUPPORTED_CITIES),
+        },
+      ],
+    };
   }
 }
 ```
@@ -67,7 +77,7 @@ export class CitiesResource extends ResourceContext {
 
 - Server entry point with `@FrontMcp` decorator and `info` configuration
 - App registration with `@App` grouping tools and resources together
-- Static resource that returns JSON data via `read()`
+- Static resource that returns JSON data via `execute(uri)` and `ReadResourceResult`
 - Clean separation between server, app, tools, and resources
 
 ## Related

package/catalog/frontmcp-guides/examples/example-weather-api/unit-and-e2e-tests.md

@@ -8,7 +8,7 @@ features:
   - 'Unit testing tools by mocking `this.fetch()`, `this.fail()`, and other context methods'
   - 'Using `Object.assign(tool, ctx)` to inject mock context into the tool instance'
   - 'E2E testing with `TestServer.start()` and `McpTestClient.create()`'
-  - 'Using `toContainTool()` custom matcher for asserting tool presence'
+  - 'Asserting tool presence via `expect(tools.map((t) => t.name)).toContain(...)` and parsing resource JSON via `result.json<T>()`'
   - 'Proper cleanup with `client.disconnect()` and `server.stop()` in `afterAll`'
 ---
 
@@ -21,6 +21,7 @@ Shows how to write unit tests for tools by mocking context methods, and E2E test
 ```typescript
 // test/get-weather.tool.spec.ts
 import { ToolContext } from '@frontmcp/sdk';
+
 import { GetWeatherTool } from '../src/tools/get-weather.tool';
 
 describe('GetWeatherTool', () => {
@@ -49,7 +50,7 @@ describe('GetWeatherTool', () => {
       get: jest.fn(),
       tryGet: jest.fn(),
       notify: jest.fn(),
-      respondProgress: jest.fn(),
+      progress: jest.fn(),
     } as unknown as ToolContext;
     Object.assign(tool, ctx);
 
@@ -81,7 +82,7 @@ describe('GetWeatherTool', () => {
       get: jest.fn(),
       tryGet: jest.fn(),
       notify: jest.fn(),
-      respondProgress: jest.fn(),
+      progress: jest.fn(),
     } as unknown as ToolContext;
     Object.assign(tool, ctx);
 
@@ -112,15 +113,15 @@ describe('Weather Server E2E', () => {
   });
 
   it('should list tools including get_weather', async () => {
-    const { tools } = await client.listTools();
+    const tools = await client.tools.list();
 
     expect(tools.length).toBeGreaterThan(0);
-    expect(tools).toContainTool('get_weather');
+    expect(tools.map((t) => t.name)).toContain('get_weather');
   });
 
   it('should read the cities resource', async () => {
-    const result = await client.readResource('weather://cities');
-    const cities = JSON.parse(result.contents[0].text);
+    const result = await client.resources.read('weather://cities');
+    const cities = result.json<string[]>();
 
     expect(Array.isArray(cities)).toBe(true);
     expect(cities).toContain('London');
@@ -134,7 +135,7 @@ describe('Weather Server E2E', () => {
 - Unit testing tools by mocking `this.fetch()`, `this.fail()`, and other context methods
 - Using `Object.assign(tool, ctx)` to inject mock context into the tool instance
 - E2E testing with `TestServer.start()` and `McpTestClient.create()`
-- Using `toContainTool()` custom matcher for asserting tool presence
+- Asserting tool presence via `expect(tools.map((t) => t.name)).toContain(...)` and parsing resource JSON via `result.json<T>()`
 - Proper cleanup with `client.disconnect()` and `server.stop()` in `afterAll`
 
 ## Related