mcproof 0.3.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nathaniel Caron
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,266 @@
+# MCProof 🛡️
+
+MCProof: A framework for testing MCP servers
+
+## Install
+
+```bash
+npm install mcproof
+```
+
+## Quick Start
+
+Create a `.env.mcproof` file in your project root:
+
+```env
+MCPROOF_BASE_URL=http://localhost:36719
+MCPROOF_TIMEOUT_MS=10000
+MCPROOF_HEADERS='{ "Authorization": "Bearer integration-token", "x-api-key":"demo-key" }'
+```
+
+Write granular test files without any local client setup:
+
+`tools.test.ts`
+
+```ts
+import { expectTool, expectToolCallContent, expectToolCallSuccess, getSharedMcpTestClient } from 'mcproof';
+
+describe('get_current_time', () => {
+  const client = getSharedMcpTestClient();
+
+  test('tool is present', async () => {
+    await expectTool(client, 'get_current_time');
+  });
+
+  test('responds successfully', async () => {
+    const result = await client.invokeTool({
+      name: 'get_current_time',
+      input: { timezone: 'America/New_York' },
+    });
+
+    expectToolCallSuccess(result);
+    expectToolCallContent(result, expect.objectContaining({
+      timezone: 'America/New_York',
+    }));
+  });
+
+  test('fails when required input is missing', async () => {
+    await expectToolCallError(
+      client.invokeTool({ name: 'get_current_time', input: {} })
+    );
+  });
+});
+```
+
+`resources.test.ts`
+
+```ts
+import {
+  expectResource,
+  expectResourceReadContent,
+  expectResourceReadSuccess,
+  getSharedMcpTestClient,
+} from 'mcproof';
+
+describe('time_tool_app resource', () => {
+  const client = getSharedMcpTestClient();
+
+  test('is available', async () => {
+    await expectResource(client, 'ui://time-tool/mcp-app.html', {
+      mimeType: 'text/html;profile=mcp-app',
+    });
+  });
+
+  test('returns content', async () => {
+    const result = await client.readResource({ uri: 'ui://time-tool/mcp-app.html' });
+    expectResourceReadSuccess(result);
+    expectResourceReadContent(result, expect.any(Array));
+  });
+});
+```
+
+`prompts.test.ts`
+
+```ts
+import {
+  expectPrompt,
+  expectPromptGetContent,
+  expectPromptGetSuccess,
+  getSharedMcpTestClient,
+} from 'mcproof';
+
+describe('time_expert_prompt', () => {
+  const client = getSharedMcpTestClient();
+
+  test('is available', async () => {
+    await expectPrompt(client, 'time_expert_prompt', {
+      argumentCount: 0,
+    });
+  });
+
+  test('returns messages', async () => {
+    const result = await client.getPrompt({ name: 'time_expert_prompt' });
+    expectPromptGetSuccess(result);
+    expectPromptGetContent(result, expect.any(Array));
+  });
+});
+```
+
+Run the suite with the framework CLI:
+
+```bash
+npx mcproof test
+```
+
+e.g.,
+![MCProof Logging Screenshot](resources/images/MCProof_Logging_Screenshot.png)
+
+Each CLI test run also writes a simple HTML report under `mcproof-reports/` in your current working directory.
+
+e.g.,
+![MCProof Report Screenshot 1](resources/images/MCProof_Report_Screenshot_1.png)
+![MCProof Report Screenshot 2](resources/images/MCProof_Report_Screenshot_2.png)
+
+Show the installed package version:
+
+```bash
+npx mcproof --version
+```
+
+## Testing for Errors
+
+Error assertions support two patterns, but the **promise pattern** is the default and safest option.
+
+**Promise pattern** — pass the promise directly WITHOUT awaiting to catch validation errors:
+
+```ts
+test('fails when required input is missing', async () => {
+  await expectToolCallError(
+    client.invokeTool({ name: 'get_current_time', input: {} })
+  );
+});
+
+test('fails for invalid URI', async () => {
+  await expectResourceReadError(
+    client.readResource({ uri: 'invalid://uri' })
+  );
+});
+
+test('fails for unknown name', async () => {
+  await expectPromptGetError(
+    client.getPrompt({ name: 'unknown_prompt' })
+  );
+});
+```
+
+**Sync result pattern** — only use this when the SDK returns an error result object (does not throw):
+
+```ts
+test('tool call returns error', async () => {
+  const result = await client.invokeTool({ name: 'some_tool', input: { bad: 'input' } });
+  expectToolCallError(result, 'MCP error -32602: validation failed');
+});
+```
+
+**Try/catch pattern** — use this when you intentionally want to assert on a thrown error directly:
+
+```ts
+test('tool throws when required input is missing', async () => {
+  try {
+    await client.invokeTool({ name: 'get_current_time', input: {} });
+    throw new Error('Expected invokeTool to throw');
+  } catch (error) {
+    expect(String(error)).toContain('MCP error -32602');
+  }
+});
+```
+
+## Env Configuration
+
+- `MCPROOF_BASE_URL`: required MCP server base URL
+- `MCPROOF_TIMEOUT_MS`: optional timeout in milliseconds
+- `MCPROOF_HEADERS`: optional JSON object of default headers
+- `MCPROOF_HEADER_*`: optional per-header overrides, e.g. `MCPROOF_HEADER_AUTHORIZATION`
+- `MCPROOF_ENV_FILE`: optional path to a non-default env file
+
+When both `MCPROOF_HEADERS` and `MCPROOF_HEADER_*` are present, the individual header vars win.
+
+## Advanced Usage
+
+```ts
+import {McpTestClient, validateMcpToolCall, expectToolCallSuccess} from 'mcproof';
+
+const client = new McpTestClient({ baseUrl: 'http://localhost:36719', timeoutMs: 10000 });
+client.setAuthHeaders({ Authorization: 'Bearer token', 'x-api-key': 'key' });
+
+const validation = validateMcpToolCall({ name: 'ping', requestId: '1' });
+if (!validation.isValid) {
+  throw new Error(validation.message);
+}
+
+const result = await client.invokeTool({ name: 'ping', requestId: '1' });
+expectToolCallSuccess(result);
+
+const resourceResult = await client.readResource({ uri: 'resource://weather/current', requestId: '2' });
+const promptResult = await client.getPrompt({
+  name: 'summarize.weather',
+  arguments: { city: 'Montreal' },
+  requestId: '3',
+});
+
+console.log('result output', result.output);
+console.log('resource output', resourceResult.output);
+console.log('prompt output', promptResult.output);
+```
+
+## API
+
+- `McpTestClient` - core test client with HTTP MCP integration
+  - `connect()`
+  - `disconnect()`
+  - `getAuthHeaders()`
+  - `setAuthHeaders(headers)`
+  - `clearAuthHeaders()`
+  - `listTools()`
+  - `listResources()`
+  - `listPrompts()`
+  - `invokeTool(toolCall)`
+  - `readResource(resourceRead)`
+  - `getPrompt(promptGet)`
+
+- `installSharedMcpTestClient(config)`
+- `configureSharedMcpTestClient(config)`
+- `initializeSharedMcpTestClient()`
+- `getSharedMcpTestClient()`
+- `disconnectSharedMcpTestClient()`
+- `resetSharedMcpTestClient()`
+
+- `validateMcpToolCall(call)` - returns `McpProtocolValidationResult`
+- `validateMcpToolResult(result)` - returns `McpProtocolValidationResult`
+- `validateMcpResourceRead(read)` - returns `McpProtocolValidationResult`
+- `validateMcpResourceResult(result)` - returns `McpProtocolValidationResult`
+- `validateMcpPromptGet(get)` - returns `McpProtocolValidationResult`
+- `validateMcpPromptResult(result)` - returns `McpProtocolValidationResult`
+- `expectTool(client, toolName)`
+- `expectResource(client, resourceUri, expected?)`
+- `expectPrompt(client, promptName, expected?)`
+- `expectToolCallSuccess(result)`
+- `expectToolCallError(resultOrInvocation[, expectedMessage])`
+- `expectToolCallContent(result, expected)`
+- `expectToolCallMeta(result, expected?)`
+- `expectResourceReadSuccess(result)`
+- `expectResourceReadError(resultOrInvocation[, expectedMessage])`
+- `expectResourceReadContent(result, expected)`
+- `expectResourceReadMeta(result, expected?)`
+- `expectPromptGetSuccess(result)`
+- `expectPromptGetError(resultOrInvocation[, expectedMessage])`
+- `expectPromptGetContent(result, expected)`
+- `expectPromptGetMeta(result, expected?)`
+
+## Notes
+
+- Uses the official MCP TypeScript SDK client and streamable HTTP transport.
+- Designed for stateless HTTP MCP tooling.
+- The default `mcproof test` command enforces sequential Jest execution for the shared-client workflow.
+- `mcproof test` writes a timestamped HTML summary to `mcproof-reports/` with preflight discovery details and Jest results.
+- The manual shared-client APIs are still available for advanced or non-standard integrations.

package/bin/mcproof.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+const { runCli } = require('../dist/cli.js');
+
+runCli(process.argv.slice(2))
+	.then(code => {
+		process.exit(code);
+	})
+	.catch(error => {
+		console.error(error && error.message ? error.message : String(error));
+		process.exit(1);
+	});

package/dist/assertions.d.ts

@@ -0,0 +1,81 @@
+import { McpPromptDescriptor, McpPromptResult, McpResourceDescriptor, McpResourceResult, McpToolResult } from './types';
+type AsymmetricMatcher = {
+    asymmetricMatch?: (value: unknown) => boolean;
+};
+type ToolLookupClient = {
+    listAvailableTools: () => Promise<string[]>;
+};
+type ResourceLookupClient = {
+    listResources: () => Promise<McpResourceDescriptor[]>;
+};
+type PromptLookupClient = {
+    listPrompts: () => Promise<McpPromptDescriptor[]>;
+};
+export declare function expectTool(client: ToolLookupClient, toolName: string): Promise<void>;
+export declare function expectToolCallSuccess(result: McpToolResult): void;
+/**
+ * Assert that a tool call failed.
+ *
+ * Two patterns are supported:
+ *
+ * 1. **Promise pattern** (to catch SDK validation errors):
+ *    Pass the promise directly WITHOUT awaiting to catch errors thrown during input validation.
+ *    Example: `await expectToolCallError(client.invokeTool({ name: 'tool', input: {} }))`
+ *
+ * 2. **Sync result pattern** (only for non-throwing error responses):
+ *    Await the invocation first, then assert the error result object.
+ *    If invocation throws, use the promise pattern above or a try/catch in your test.
+ *    Example: `const result = await client.invokeTool(...); expectToolCallError(result, 'expected error')`
+ *
+ * When `expectedMessage` is provided, it must match the full error message exactly.
+ */
+export declare function expectToolCallError(result: McpToolResult, expectedMessage?: string): void;
+export declare function expectToolCallError(result: Promise<McpToolResult>, expectedMessage?: string): Promise<void>;
+export declare function expectToolCallContent(result: McpToolResult, expected: unknown): void;
+export declare function expectToolCallMeta(result: McpToolResult, expected?: unknown): void;
+export declare function expectResource(client: ResourceLookupClient, resourceUri: string, expected?: Partial<McpResourceDescriptor> | AsymmetricMatcher): Promise<void>;
+export declare function expectResourceReadSuccess(result: McpResourceResult): void;
+/**
+ * Assert that a resource read failed.
+ *
+ * Two patterns are supported:
+ *
+ * 1. **Promise pattern** (to catch SDK validation errors):
+ *    Pass the promise directly WITHOUT awaiting to catch errors thrown during request validation.
+ *    Example: `await expectResourceReadError(client.readResource({ uri: 'resource://missing' }))`
+ *
+ * 2. **Sync result pattern** (only for non-throwing error responses):
+ *    Await the read first, then assert the error result object.
+ *    If invocation throws, use the promise pattern above or a try/catch in your test.
+ *    Example: `const result = await client.readResource(...); expectResourceReadError(result, 'expected error')`
+ *
+ * When `expectedMessage` is provided, it must match the full error message exactly.
+ */
+export declare function expectResourceReadError(result: McpResourceResult, expectedMessage?: string): void;
+export declare function expectResourceReadError(result: Promise<McpResourceResult>, expectedMessage?: string): Promise<void>;
+export declare function expectResourceReadContent(result: McpResourceResult, expected: unknown): void;
+export declare function expectResourceReadMeta(result: McpResourceResult, expected?: unknown): void;
+export declare function expectPrompt(client: PromptLookupClient, promptName: string, expected?: Partial<McpPromptDescriptor> | AsymmetricMatcher): Promise<void>;
+export declare function expectPromptGetSuccess(result: McpPromptResult): void;
+/**
+ * Assert that a prompt get failed.
+ *
+ * Two patterns are supported:
+ *
+ * 1. **Promise pattern** (to catch SDK validation errors):
+ *    Pass the promise directly WITHOUT awaiting to catch errors thrown during request validation.
+ *    Example: `await expectPromptGetError(client.getPrompt({ name: 'unknown' }))`
+ *
+ * 2. **Sync result pattern** (only for non-throwing error responses):
+ *    Await the get first, then assert the error result object.
+ *    If invocation throws, use the promise pattern above or a try/catch in your test.
+ *    Example: `const result = await client.getPrompt(...); expectPromptGetError(result, 'expected error')`
+ *
+ * When `expectedMessage` is provided, it must match the full error message exactly.
+ */
+export declare function expectPromptGetError(result: McpPromptResult, expectedMessage?: string): void;
+export declare function expectPromptGetError(result: Promise<McpPromptResult>, expectedMessage?: string): Promise<void>;
+export declare function expectPromptGetContent(result: McpPromptResult, expected: unknown): void;
+export declare function expectPromptGetMeta(result: McpPromptResult, expected?: unknown): void;
+export {};
+//# sourceMappingURL=assertions.d.ts.map

package/dist/assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../src/assertions.ts"],"names":[],"mappings":"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"}

package/dist/assertions.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectTool = expectTool;
+exports.expectToolCallSuccess = expectToolCallSuccess;
+exports.expectToolCallError = expectToolCallError;
+exports.expectToolCallContent = expectToolCallContent;
+exports.expectToolCallMeta = expectToolCallMeta;
+exports.expectResource = expectResource;
+exports.expectResourceReadSuccess = expectResourceReadSuccess;
+exports.expectResourceReadError = expectResourceReadError;
+exports.expectResourceReadContent = expectResourceReadContent;
+exports.expectResourceReadMeta = expectResourceReadMeta;
+exports.expectPrompt = expectPrompt;
+exports.expectPromptGetSuccess = expectPromptGetSuccess;
+exports.expectPromptGetError = expectPromptGetError;
+exports.expectPromptGetContent = expectPromptGetContent;
+exports.expectPromptGetMeta = expectPromptGetMeta;
+// Tool assertions
+async function expectTool(client, toolName) {
+    const availableTools = await client.listAvailableTools();
+    if (availableTools.includes(toolName)) {
+        return;
+    }
+    const discovered = availableTools.length > 0 ? availableTools.join(', ') : '(none)';
+    throw new Error(`Expected MCP server to expose tool '${toolName}', but discovered: ${discovered}`);
+}
+function expectToolCallSuccess(result) {
+    assertSuccess(result.status, result.error, 'tool call');
+}
+function expectToolCallError(result, expectedMessage) {
+    if (isPromiseLikeToolResult(result)) {
+        return Promise.resolve(result).then(toolResult => {
+            assertErrored(toolResult.status, toolResult.error, 'tool call', expectedMessage);
+        }, (error) => {
+            if (!expectedMessage) {
+                return;
+            }
+            const message = formatUnknownErrorMessage(error);
+            assertThrownMessageEquals(message, expectedMessage);
+        });
+    }
+    assertErrored(result.status, result.error, 'tool call', expectedMessage);
+}
+function expectToolCallContent(result, expected) {
+    var _a;
+    const normalizedOutput = normalizeToolOutput(result.output);
+    if (isAsymmetricMatcher(expected)) {
+        if (!((_a = expected.asymmetricMatch) === null || _a === void 0 ? void 0 : _a.call(expected, normalizedOutput))) {
+            expect(normalizedOutput).toEqual(expected);
+        }
+        return;
+    }
+    expect(normalizedOutput).toEqual(expected);
+}
+function expectToolCallMeta(result, expected) {
+    const meta = extractToolMeta(result.output);
+    if (expected === undefined) {
+        if (meta === undefined) {
+            throw new Error('Expected tool call result output to contain a _meta field');
+        }
+        return;
+    }
+    expect(meta).toEqual(expected);
+}
+// Resource assertions
+async function expectResource(client, resourceUri, expected) {
+    const resources = await client.listResources();
+    const resource = resources.find(entry => entry.uri === resourceUri);
+    if (!resource) {
+        const discovered = resources.length > 0 ? resources.map(entry => entry.uri).join(', ') : '(none)';
+        throw new Error(`Expected MCP server to expose resource '${resourceUri}', but discovered: ${discovered}`);
+    }
+    if (expected !== undefined) {
+        expect(resource).toEqual(normalizeExpectedDescriptor(expected));
+    }
+}
+function expectResourceReadSuccess(result) {
+    assertSuccess(result.status, result.error, 'resource read');
+}
+function expectResourceReadError(result, expectedMessage) {
+    if (isPromiseLikeResourceResult(result)) {
+        return Promise.resolve(result).then(resourceResult => {
+            assertErrored(resourceResult.status, resourceResult.error, 'resource read', expectedMessage);
+        }, (error) => {
+            if (!expectedMessage) {
+                return;
+            }
+            const message = formatUnknownErrorMessage(error);
+            assertThrownMessageEquals(message, expectedMessage);
+        });
+    }
+    assertErrored(result.status, result.error, 'resource read', expectedMessage);
+}
+function expectResourceReadContent(result, expected) {
+    var _a;
+    const normalizedOutput = normalizeResourceOutput(result.output);
+    if (isAsymmetricMatcher(expected)) {
+        if (!((_a = expected.asymmetricMatch) === null || _a === void 0 ? void 0 : _a.call(expected, normalizedOutput))) {
+            expect(normalizedOutput).toEqual(expected);
+        }
+        return;
+    }
+    expect(normalizedOutput).toEqual(expected);
+}
+function expectResourceReadMeta(result, expected) {
+    const meta = extractToolMeta(result.output);
+    if (expected === undefined) {
+        if (meta === undefined) {
+            throw new Error('Expected resource read output to contain a _meta field');
+        }
+        return;
+    }
+    expect(meta).toEqual(expected);
+}
+// Prompt assertions
+async function expectPrompt(client, promptName, expected) {
+    const prompts = await client.listPrompts();
+    const prompt = prompts.find(entry => entry.name === promptName);
+    if (!prompt) {
+        const discovered = prompts.length > 0 ? prompts.map(entry => entry.name).join(', ') : '(none)';
+        throw new Error(`Expected MCP server to expose prompt '${promptName}', but discovered: ${discovered}`);
+    }
+    if (expected !== undefined) {
+        expect(prompt).toEqual(normalizeExpectedDescriptor(expected));
+    }
+}
+function expectPromptGetSuccess(result) {
+    assertSuccess(result.status, result.error, 'prompt get');
+}
+function expectPromptGetError(result, expectedMessage) {
+    if (isPromiseLikePromptResult(result)) {
+        return Promise.resolve(result).then(promptResult => {
+            assertErrored(promptResult.status, promptResult.error, 'prompt get', expectedMessage);
+        }, (error) => {
+            if (!expectedMessage) {
+                return;
+            }
+            const message = formatUnknownErrorMessage(error);
+            assertThrownMessageEquals(message, expectedMessage);
+        });
+    }
+    assertErrored(result.status, result.error, 'prompt get', expectedMessage);
+}
+function expectPromptGetContent(result, expected) {
+    var _a;
+    const normalizedOutput = normalizePromptOutput(result.output);
+    if (isAsymmetricMatcher(expected)) {
+        if (!((_a = expected.asymmetricMatch) === null || _a === void 0 ? void 0 : _a.call(expected, normalizedOutput))) {
+            expect(normalizedOutput).toEqual(expected);
+        }
+        return;
+    }
+    expect(normalizedOutput).toEqual(expected);
+}
+function expectPromptGetMeta(result, expected) {
+    const meta = extractToolMeta(result.output);
+    if (expected === undefined) {
+        if (meta === undefined) {
+            throw new Error('Expected prompt get output to contain a _meta field');
+        }
+        return;
+    }
+    expect(meta).toEqual(expected);
+}
+function safeParseJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractSseDataPayload(raw) {
+    const payloads = raw
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(line => line.startsWith('data:'))
+        .map(line => line.replace(/^data:\s?/, ''))
+        .filter(line => line.length > 0)
+        .map(line => safeParseJson(line))
+        .filter((value) => value !== undefined);
+    if (payloads.length === 0) {
+        return raw;
+    }
+    return payloads[payloads.length - 1];
+}
+function normalizeToolOutput(value) {
+    if (typeof value === 'string') {
+        const ssePayload = extractSseDataPayload(value);
+        if (ssePayload !== value) {
+            return normalizeToolOutput(ssePayload);
+        }
+        const parsedJson = safeParseJson(value);
+        if (parsedJson !== undefined) {
+            return normalizeToolOutput(parsedJson);
+        }
+        return value;
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const candidate = value;
+    if (candidate.result !== undefined) {
+        return normalizeToolOutput(candidate.result);
+    }
+    if (candidate.output !== undefined) {
+        return normalizeToolOutput(candidate.output);
+    }
+    if (candidate.structuredContent !== undefined) {
+        return candidate.structuredContent;
+    }
+    if (Array.isArray(candidate.content)) {
+        const texts = candidate.content
+            .map(item => (typeof (item === null || item === void 0 ? void 0 : item.text) === 'string' ? item.text : undefined))
+            .filter((text) => text !== undefined);
+        if (texts.length === 1) {
+            const parsed = safeParseJson(texts[0]);
+            return parsed !== undefined ? parsed : texts[0];
+        }
+        if (texts.length > 1) {
+            return texts.join('\n');
+        }
+        return candidate.content;
+    }
+    return value;
+}
+function normalizeResourceOutput(value) {
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const candidate = value;
+    if (candidate.contents !== undefined) {
+        return candidate.contents;
+    }
+    return value;
+}
+function normalizePromptOutput(value) {
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const candidate = value;
+    if (candidate.messages !== undefined) {
+        return candidate.messages;
+    }
+    return value;
+}
+function isAsymmetricMatcher(value) {
+    return Boolean(value && typeof value === 'object' && typeof value.asymmetricMatch === 'function');
+}
+function extractToolMeta(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const candidate = value;
+    if (candidate._meta !== undefined) {
+        return candidate._meta;
+    }
+    if (candidate.result !== undefined) {
+        return extractToolMeta(candidate.result);
+    }
+    if (candidate.output !== undefined) {
+        return extractToolMeta(candidate.output);
+    }
+    return undefined;
+}
+function isPromiseLikeToolResult(value) {
+    return Boolean(value && typeof value === 'object' && typeof value.then === 'function');
+}
+function isPromiseLikeResourceResult(value) {
+    return Boolean(value && typeof value === 'object' && typeof value.then === 'function');
+}
+function isPromiseLikePromptResult(value) {
+    return Boolean(value && typeof value === 'object' && typeof value.then === 'function');
+}
+function formatUnknownErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function assertThrownMessageEquals(actualMessage, expectedMessage) {
+    expect(actualMessage).toBe(expectedMessage);
+}
+function assertErrored(status, error, label, expectedMessage) {
+    if (status !== 'error') {
+        throw new Error(`Expected ${label} to fail with error status`);
+    }
+    if (expectedMessage !== undefined) {
+        expect(error).toBe(expectedMessage);
+    }
+}
+function assertSuccess(status, error, label) {
+    if (status !== 'success') {
+        throw new Error(`Expected ${label} success status but got ${status}: ${error !== null && error !== void 0 ? error : 'no error info'}`);
+    }
+}
+function normalizeExpectedDescriptor(expected) {
+    if (isAsymmetricMatcher(expected)) {
+        return expected;
+    }
+    return expect.objectContaining((expected !== null && expected !== void 0 ? expected : {}));
+}
+//# sourceMappingURL=assertions.js.map