@cyanheads/mcp-ts-core 0.11.2 → 0.11.4

package/templates/tests/smoke/definitions.smoke.test.ts

@@ -13,23 +13,27 @@ import { echoTool } from '@/mcp-server/tools/definitions/echo.tool.js';
 
 describe('scaffold definition smoke test', () => {
   it('executes the shipped tool, resource, and prompt definitions', async () => {
-    const ctx = createMockContext();
+    // `echoTool` declares an error contract, so its handler wants a context
+    // typed against it — passing `errors` narrows what `createMockContext` returns.
+    const ctx = createMockContext({ errors: echoTool.errors });
     const toolResult = await echoTool.handler(
       echoTool.input.parse({ message: 'smoke' }),
       ctx,
     );
     const resourceResult = await echoResource.handler(
-      echoResource.params.parse({ message: 'smoke' }),
+      echoResource.params!.parse({ message: 'smoke' }),
       ctx,
     );
-    const promptMessages = echoPrompt.generate(echoPrompt.args.parse({ message: 'smoke' }));
+    const promptMessages = await echoPrompt.generate(
+      echoPrompt.args!.parse({ message: 'smoke' }),
+    );
     const appResult = await echoAppTool.handler(
       echoAppTool.input.parse({ message: 'smoke app' }),
       ctx,
     );
     const appContent = echoAppTool.format?.(appResult);
     const appHtml = await echoAppUiResource.handler(
-      echoAppUiResource.params.parse({}),
+      echoAppUiResource.params!.parse({}),
       createMockContext({ uri: new URL('ui://template-echo-app/app.html') }),
     );
 

package/templates/tests/tools/echo.tool.test.ts

@@ -3,22 +3,41 @@
  * @module tests/tools/echo.tool.test
  */
 
+import type { HandlerContext, ReasonOf } from '@cyanheads/mcp-ts-core';
 import { describe, expect, it } from 'vitest';
 import { createMockContext } from '@cyanheads/mcp-ts-core/testing';
 import { mcpTest } from '@cyanheads/mcp-ts-core/testing/vitest';
 import { echoTool } from '@/mcp-server/tools/definitions/echo.tool.js';
 
+/**
+ * A tool that declares `errors[]` types its handler's `ctx` against that
+ * contract, so tests hand it a context built the same way — `createMockContext`
+ * narrows its return type from the `errors` it is given. Drop this if your tool
+ * declares no error contract; a bare `createMockContext()` is enough then.
+ */
+type EchoContext = HandlerContext<ReasonOf<typeof echoTool.errors>>;
+
+const echoContext = () => createMockContext({ errors: echoTool.errors });
+
 // ---------------------------------------------------------------------------
 // Fixture-based tests (mcpTest) — fresh ctx per test, no manual construction
 // ---------------------------------------------------------------------------
 
-mcpTest('echoTool: echoes the message back (fixture)', async ({ ctx }) => {
+/** Function form, not a bare value — every test gets its own context. */
+const echoTest = mcpTest.extend<{ ctx: EchoContext }>({
+  // biome-ignore lint/correctness/noEmptyPattern: vitest's fixture API requires a destructuring pattern as the first parameter
+  ctx: async ({}, use) => {
+    await use(echoContext());
+  },
+});
+
+echoTest('echoTool: echoes the message back (fixture)', async ({ ctx }) => {
   const input = echoTool.input.parse({ message: 'hello world' });
   const result = await echoTool.handler(input, ctx);
   expect(result).toEqual({ message: 'hello world' });
 });
 
-mcpTest('echoTool: output conforms to declared schema (fixture)', async ({ ctx }) => {
+echoTest('echoTool: output conforms to declared schema (fixture)', async ({ ctx }) => {
   const input = echoTool.input.parse({ message: 'hello world' });
   const result = await echoTool.handler(input, ctx);
   expect(result).toEqual(expect.schemaMatching(echoTool.output));
@@ -30,14 +49,14 @@ mcpTest('echoTool: output conforms to declared schema (fixture)', async ({ ctx }
 
 describe('echoTool', () => {
   it('echoes the message back', async () => {
-    const ctx = createMockContext();
+    const ctx = echoContext();
     const input = echoTool.input.parse({ message: 'hello world' });
     const result = await echoTool.handler(input, ctx);
     expect(result).toEqual({ message: 'hello world' });
   });
 
   it('output conforms to the declared output schema', async () => {
-    const ctx = createMockContext();
+    const ctx = echoContext();
     const input = echoTool.input.parse({ message: 'hello world' });
     const result = await echoTool.handler(input, ctx);
     expect(result).toEqual(expect.schemaMatching(echoTool.output));