@purista/harness 1.0.0

package/dist/skills/index.d.ts

@@ -0,0 +1,8 @@
+import type { JsonValue } from '../models/json.js';
+import type { ResolvedSkill, SkillDefinition } from '../harness/defineHarness.js';
+import type { SandboxSession } from '../sandbox/index.js';
+export declare function loadSkillsSync(skills: Record<string, SkillDefinition>): Record<string, ResolvedSkill>;
+export declare function loadSkills(skills: Record<string, SkillDefinition>): Promise<Record<string, ResolvedSkill>>;
+export declare function mountSkillsOnce(session: SandboxSession, mounted: Set<string>, skills: Record<string, ResolvedSkill>, skillIds: readonly string[]): Promise<void>;
+export declare function buildSkillIndex(skills: Record<string, ResolvedSkill>, ids: readonly string[]): string;
+export declare function assertSerializable(value: unknown): asserts value is JsonValue;

package/dist/skills/index.js

@@ -0,0 +1,88 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { SkillManifestError, SkillNotFoundError } from '../errors/index.js';
+function parseFrontmatter(content) {
+    if (!content.startsWith('---\n'))
+        throw new SkillManifestError('Invalid SKILL.md frontmatter', { reason: 'invalid_frontmatter', directory: '' });
+    const end = content.indexOf('\n---\n', 4);
+    if (end < 0)
+        throw new SkillManifestError('Invalid SKILL.md frontmatter', { reason: 'invalid_frontmatter', directory: '' });
+    const raw = content.slice(4, end);
+    const body = content.slice(end + 5);
+    const frontmatter = {};
+    for (const line of raw.split('\n')) {
+        const idx = line.indexOf(':');
+        if (idx < 0)
+            continue;
+        frontmatter[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+    }
+    return { frontmatter, body };
+}
+function validateName(name) { return /^[a-z][a-z0-9-]*$/.test(name) && !/anthropic|claude|purista/i.test(name); }
+export function loadSkillsSync(skills) {
+    const resolved = {};
+    for (const [key, def] of Object.entries(skills)) {
+        const stat = fs.existsSync(def.directory) ? fs.statSync(def.directory) : null;
+        if (!stat?.isDirectory())
+            throw new SkillManifestError('Skill directory missing', { reason: 'directory_missing', directory: def.directory, skill_id: key });
+        const skillPath = path.join(def.directory, 'SKILL.md');
+        const content = fs.existsSync(skillPath) ? fs.readFileSync(skillPath, 'utf8') : null;
+        if (!content)
+            throw new SkillManifestError('missing SKILL.md', { reason: 'missing_skill_md', directory: def.directory, skill_id: key });
+        const { frontmatter } = parseFrontmatter(content);
+        const name = frontmatter['name'] ?? '';
+        const description = frontmatter['description'] ?? '';
+        if (!validateName(name) || description.length < 1 || description.length > 1024) {
+            throw new SkillManifestError('invalid frontmatter', { reason: 'invalid_frontmatter', directory: def.directory, skill_id: key });
+        }
+        if (name !== key)
+            throw new SkillManifestError('name mismatch', { reason: 'name_mismatch', directory: def.directory, skill_id: key });
+        resolved[key] = { name, description, directory: def.directory, ...(frontmatter['version'] ? { version: frontmatter['version'] } : {}) };
+    }
+    return resolved;
+}
+export async function loadSkills(skills) {
+    return loadSkillsSync(skills);
+}
+async function readDirRecursive(root) {
+    const files = new Map();
+    const walk = async (dir) => {
+        const entries = await fsp.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const abs = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                await walk(abs);
+            else if (entry.isFile())
+                files.set(path.posix.normalize(path.relative(root, abs).split(path.sep).join('/')), await fsp.readFile(abs));
+        }
+    };
+    await walk(root);
+    return files;
+}
+export async function mountSkillsOnce(session, mounted, skills, skillIds) {
+    for (const skillId of skillIds) {
+        if (mounted.has(skillId))
+            continue;
+        const skill = skills[skillId];
+        if (!skill)
+            throw new SkillNotFoundError('Skill not found.', { skill_id: skillId });
+        const files = await readDirRecursive(skill.directory);
+        await session.mount(files, `/skills/${skillId}`);
+        mounted.add(skillId);
+    }
+}
+export function buildSkillIndex(skills, ids) {
+    if (ids.length === 0)
+        return '';
+    const lines = ids.map((id) => `- ${skills[id]?.name ?? id}: ${skills[id]?.description ?? ''}`);
+    return `\n\nAvailable skills (read /skills/<name>/SKILL.md for full instructions):\n${lines.join('\n')}`;
+}
+export function assertSerializable(value) {
+    try {
+        JSON.stringify(value);
+    }
+    catch {
+        throw new SkillManifestError('Non-serializable value', { reason: 'invalid_frontmatter', directory: '' });
+    }
+}

package/dist/state/in-memory.d.ts

@@ -0,0 +1,35 @@
+import type { Message, PersistedRunEvent, RunRecord, SessionRecord } from '../models/state.js';
+import type { FinishRunPatch, StateStore } from '../ports/state.js';
+/**
+ * In-process state store for local development and tests.
+ */
+export declare class InMemoryStateStore implements StateStore {
+    private readonly sessions;
+    private readonly messages;
+    private readonly runs;
+    private readonly events;
+    private readonly messageLocks;
+    getSession(id: string): Promise<SessionRecord | undefined>;
+    upsertSession(record: SessionRecord): Promise<void>;
+    closeSession(id: string): Promise<void>;
+    appendMessages(sessionId: string, messages: Message[]): Promise<void>;
+    listMessages(sessionId: string, opts?: {
+        limit?: number;
+        before?: string;
+    }): Promise<Message[]>;
+    clearMessages(sessionId: string): Promise<void>;
+    createRun(record: RunRecord): Promise<void>;
+    finishRun(runId: string, patch: FinishRunPatch): Promise<void>;
+    getRun(runId: string): Promise<RunRecord | undefined>;
+    listRuns(sessionId: string, opts?: {
+        limit?: number;
+        before?: string;
+    }): Promise<RunRecord[]>;
+    appendEvents(runId: string, events: PersistedRunEvent[]): Promise<void>;
+    listEvents(runId: string, opts?: {
+        limit?: number;
+        after?: string;
+    }): Promise<PersistedRunEvent[]>;
+    close(): Promise<void>;
+    private withMessageLock;
+}

package/dist/state/in-memory.js

@@ -0,0 +1,140 @@
+import { StateError } from '../errors/index.js';
+class Mutex {
+    current = Promise.resolve();
+    async lock(fn) {
+        const prev = this.current;
+        let release;
+        this.current = new Promise((resolve) => { release = resolve; });
+        await prev;
+        try {
+            return await fn();
+        }
+        finally {
+            release?.();
+        }
+    }
+}
+/**
+ * In-process state store for local development and tests.
+ */
+export class InMemoryStateStore {
+    sessions = new Map();
+    messages = new Map();
+    runs = new Map();
+    events = new Map();
+    messageLocks = new Map();
+    async getSession(id) {
+        return this.sessions.get(id);
+    }
+    async upsertSession(record) {
+        this.sessions.set(record.id, record);
+    }
+    async closeSession(id) {
+        this.sessions.delete(id);
+        this.messages.delete(id);
+        for (const [runId, run] of this.runs) {
+            if (run.sessionId === id) {
+                this.runs.delete(runId);
+                this.events.delete(runId);
+            }
+        }
+    }
+    async appendMessages(sessionId, messages) {
+        return this.withMessageLock(sessionId, async () => {
+            const current = this.messages.get(sessionId) ?? [];
+            const ids = new Set(current.map((msg) => msg.id));
+            for (const message of messages) {
+                if (ids.has(message.id)) {
+                    throw new StateError('Duplicate message id.', { op: 'appendMessages', reason: 'duplicate_message_id' });
+                }
+                ids.add(message.id);
+            }
+            this.messages.set(sessionId, [...current, ...messages]);
+        });
+    }
+    async listMessages(sessionId, opts = {}) {
+        let rows = [...(this.messages.get(sessionId) ?? [])]
+            .sort((a, b) => a.timestamp === b.timestamp ? a.id.localeCompare(b.id) : a.timestamp.localeCompare(b.timestamp));
+        if (opts.before) {
+            const beforeIndex = rows.findIndex((row) => row.id === opts.before);
+            if (beforeIndex >= 0) {
+                rows = rows.slice(0, beforeIndex);
+            }
+        }
+        if (opts.limit !== undefined) {
+            rows = rows.slice(Math.max(0, rows.length - opts.limit));
+        }
+        return rows;
+    }
+    async clearMessages(sessionId) {
+        return this.withMessageLock(sessionId, async () => {
+            this.messages.delete(sessionId);
+        });
+    }
+    async createRun(record) {
+        this.runs.set(record.id, record);
+    }
+    async finishRun(runId, patch) {
+        const run = this.runs.get(runId);
+        if (!run)
+            return;
+        this.runs.set(runId, { ...run, ...patch });
+    }
+    async getRun(runId) {
+        return this.runs.get(runId);
+    }
+    async listRuns(sessionId, opts = {}) {
+        let rows = [...this.runs.values()]
+            .filter((run) => run.sessionId === sessionId)
+            .sort((a, b) => a.startedAt === b.startedAt ? b.id.localeCompare(a.id) : b.startedAt.localeCompare(a.startedAt));
+        if (opts.before) {
+            const beforeIndex = rows.findIndex((row) => row.id === opts.before);
+            if (beforeIndex >= 0) {
+                rows = rows.slice(beforeIndex + 1);
+            }
+        }
+        if (opts.limit !== undefined) {
+            rows = rows.slice(0, opts.limit);
+        }
+        return rows;
+    }
+    async appendEvents(runId, events) {
+        const current = this.events.get(runId) ?? [];
+        this.events.set(runId, [...current, ...events]);
+    }
+    async listEvents(runId, opts = {}) {
+        let rows = [...(this.events.get(runId) ?? [])];
+        if (opts.after) {
+            const afterIndex = rows.findIndex((row) => row.id === opts.after);
+            if (afterIndex >= 0) {
+                rows = rows.slice(afterIndex + 1);
+            }
+        }
+        if (opts.limit !== undefined) {
+            rows = rows.slice(0, opts.limit);
+        }
+        return rows;
+    }
+    async close() {
+        this.sessions.clear();
+        this.messages.clear();
+        this.runs.clear();
+        this.events.clear();
+        this.messageLocks.clear();
+    }
+    async withMessageLock(sessionId, fn) {
+        let lock = this.messageLocks.get(sessionId);
+        if (!lock) {
+            lock = new Mutex();
+            this.messageLocks.set(sessionId, lock);
+        }
+        try {
+            return await lock.lock(fn);
+        }
+        catch (error) {
+            if (error instanceof StateError)
+                throw error;
+            throw new StateError('State store operation failed.', { op: 'appendMessages' }, error);
+        }
+    }
+}

package/dist/telemetry/index.d.ts

@@ -0,0 +1 @@
+export * from './shim.js';

package/dist/telemetry/index.js

@@ -0,0 +1 @@
+export * from './shim.js';

package/dist/telemetry/shim.d.ts

@@ -0,0 +1,26 @@
+/** Attributes accepted by telemetry span/metric helpers. */
+export type SpanAttrs = Record<string, string | number | boolean | string[] | undefined>;
+/** Minimal telemetry abstraction used by harness internals and integrations. */
+export interface TelemetryShim {
+    /** Creates a span, executes `fn`, and closes the span with success/error status. */
+    span<T>(name: string, attrs: SpanAttrs, fn: (span: import('@opentelemetry/api').Span) => Promise<T>): Promise<T>;
+    /** Records a histogram value with attributes. */
+    recordHistogram(name: string, value: number, attrs: SpanAttrs): void;
+    /** Records a counter increment/add value with attributes. */
+    recordCounter(name: string, value: number, attrs: SpanAttrs): void;
+    /** Injects the current active trace context into a W3C traceparent carrier. */
+    currentTraceparent(): string | undefined;
+}
+/** OpenTelemetry-backed implementation of {@link TelemetryShim}. */
+export declare class OtelTelemetryShim implements TelemetryShim {
+    private readonly tracer;
+    private readonly meter;
+    private readonly histograms;
+    private readonly counters;
+    span<T>(name: string, attrs: SpanAttrs, fn: (span: import('@opentelemetry/api').Span) => Promise<T>): Promise<T>;
+    recordHistogram(name: string, value: number, attrs: SpanAttrs): void;
+    recordCounter(name: string, value: number, attrs: SpanAttrs): void;
+    currentTraceparent(): string | undefined;
+}
+/** Creates the default telemetry shim instance. */
+export declare function createTelemetryShim(): TelemetryShim;

package/dist/telemetry/shim.js

@@ -0,0 +1,120 @@
+import { SpanStatusCode, context, metrics, propagation, trace } from '@opentelemetry/api';
+import { ATTR_ERROR_TYPE } from '@opentelemetry/semantic-conventions';
+import { HarnessError } from '../errors/index.js';
+import { sanitizeForLog } from '../errors/redaction.js';
+function sanitizeAttrs(attrs) {
+    const out = {};
+    for (const [key, value] of Object.entries(attrs)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            out[key] = [...value];
+        }
+        else {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+function errorAttributes(error) {
+    if (error instanceof HarnessError) {
+        const meta = asRecord(error.meta);
+        const providerBody = meta ? jsonAttr(sanitizeForLog(meta['providerBody'])) : undefined;
+        return {
+            [ATTR_ERROR_TYPE]: error.code,
+            'harness.error.code': error.code,
+            'harness.error.category': error.category,
+            'harness.error.retriable': error.retriable,
+            'harness.error.provider': stringAttr(meta?.['provider']),
+            'harness.error.model': stringAttr(meta?.['model']),
+            'harness.error.model_provider_status': numberAttr(meta?.['status']),
+            'harness.error.model_provider_code': stringAttr(meta?.['providerCode']),
+            'harness.error.model_provider_type': stringAttr(meta?.['providerType']),
+            'harness.error.model_provider_param': stringAttr(meta?.['providerParam']),
+            'harness.error.model_provider_request_id': stringAttr(meta?.['providerRequestId']),
+            'harness.error.model_provider_message': stringAttr(meta?.['providerMessage']),
+            'harness.error.model_provider_body': providerBody
+        };
+    }
+    const name = error instanceof Error ? error.name : 'Error';
+    return {
+        [ATTR_ERROR_TYPE]: name,
+        'harness.error.code': name,
+        'harness.error.category': 'internal',
+        'harness.error.retriable': false
+    };
+}
+function asRecord(value) {
+    return value !== null && typeof value === 'object' ? value : undefined;
+}
+function stringAttr(value) {
+    return typeof value === 'string' && value.length > 0 ? value.slice(0, 4000) : undefined;
+}
+function numberAttr(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function jsonAttr(value) {
+    if (value === undefined)
+        return undefined;
+    try {
+        return JSON.stringify(value).slice(0, 8000);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** OpenTelemetry-backed implementation of {@link TelemetryShim}. */
+export class OtelTelemetryShim {
+    tracer = trace.getTracer('@purista/harness');
+    meter = metrics.getMeter('@purista/harness');
+    histograms = new Map();
+    counters = new Map();
+    async span(name, attrs, fn) {
+        return this.tracer.startActiveSpan(name, { attributes: sanitizeAttrs(attrs) }, async (span) => {
+            try {
+                const result = await fn(span);
+                span.setStatus({ code: SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setAttributes(sanitizeAttrs(errorAttributes(error)));
+                const recordedError = error instanceof HarnessError
+                    ? new Error(error.message)
+                    : error instanceof Error
+                        ? new Error(error.message)
+                        : new Error(String(error));
+                span.recordException(recordedError);
+                span.setStatus({ code: SpanStatusCode.ERROR, message: recordedError.message });
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    recordHistogram(name, value, attrs) {
+        let histogram = this.histograms.get(name);
+        if (!histogram) {
+            histogram = this.meter.createHistogram(name);
+            this.histograms.set(name, histogram);
+        }
+        histogram.record(value, sanitizeAttrs(attrs));
+    }
+    recordCounter(name, value, attrs) {
+        let counter = this.counters.get(name);
+        if (!counter) {
+            counter = this.meter.createCounter(name);
+            this.counters.set(name, counter);
+        }
+        counter.add(value, sanitizeAttrs(attrs));
+    }
+    currentTraceparent() {
+        const carrier = {};
+        propagation.inject(context.active(), carrier);
+        return carrier['traceparent'];
+    }
+}
+/** Creates the default telemetry shim instance. */
+export function createTelemetryShim() {
+    return new OtelTelemetryShim();
+}

package/dist/testing/capabilities.d.ts

@@ -0,0 +1,11 @@
+import { type AdapterCapabilities, type AdapterCapability } from '../ports/capabilities.js';
+/** Test adapter descriptor with a stable diagnostic id. */
+export interface FakeCapabilityAdapter extends AdapterCapabilities {
+    readonly id: string;
+}
+/** Creates a fake adapter capability descriptor for tests. */
+export declare function fakeCapabilityAdapter(capabilities: readonly AdapterCapability[], opts?: {
+    id?: string;
+}): FakeCapabilityAdapter;
+/** Shared contract for adapters that expose harness capabilities. */
+export declare function adapterCapabilitiesContract(make: () => AdapterCapabilities | Promise<AdapterCapabilities>): void;

package/dist/testing/capabilities.js

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { collectAdapterCapabilities, validateAdapterCapabilities } from '../ports/capabilities.js';
+/** Creates a fake adapter capability descriptor for tests. */
+export function fakeCapabilityAdapter(capabilities, opts = {}) {
+    return {
+        id: opts.id ?? 'fake',
+        capabilities
+    };
+}
+/** Shared contract for adapters that expose harness capabilities. */
+export function adapterCapabilitiesContract(make) {
+    describe('adapterCapabilitiesContract', () => {
+        it('declares a stable capability list', async () => {
+            const adapter = await make();
+            const capabilities = collectAdapterCapabilities([adapter]);
+            expect(capabilities).toEqual(adapter.capabilities);
+            expect(validateAdapterCapabilities(adapter.capabilities, capabilities).ok).toBe(true);
+        });
+    });
+}

package/dist/testing/fakeModelProvider.d.ts

@@ -0,0 +1,25 @@
+import type { EmbeddingRequest, EmbeddingResponse, ModelProvider, ObjectRequest, ObjectResponse, ObjectStreamChunk, RerankRequest, RerankResponse, TextRequest, TextResponse, TextStreamChunk } from '../ports/model-provider.js';
+import type { JsonValue } from '../models/json.js';
+/** Deterministic model provider for harness tests and examples. */
+export declare class FakeModelProvider implements ModelProvider {
+    private queue;
+    private textStreamQueue;
+    private objectStreamQueue;
+    readonly requests: Array<TextRequest | ObjectRequest | EmbeddingRequest | RerankRequest>;
+    readonly id = "fake";
+    readonly genAiSystem = "fake";
+    enqueueObject(response: ObjectResponse): void;
+    enqueueText(response: TextResponse): void;
+    enqueueEmbedding(response: EmbeddingResponse): void;
+    enqueueRerank(response: RerankResponse): void;
+    enqueueTextStream(chunks: TextStreamChunk[]): void;
+    enqueueObjectStream(chunks: ObjectStreamChunk[]): void;
+    /** Backward-compatible helper for older tests during the object migration. */
+    enqueue(response: ObjectResponse): void;
+    text(req: TextRequest): Promise<TextResponse>;
+    textStream(req: TextRequest): AsyncIterable<TextStreamChunk>;
+    object<T extends JsonValue = JsonValue>(req: ObjectRequest<T>): Promise<ObjectResponse<T>>;
+    objectStream<T extends JsonValue = JsonValue>(req: ObjectRequest<T>): AsyncIterable<ObjectStreamChunk<T>>;
+    embed(req: EmbeddingRequest): Promise<EmbeddingResponse>;
+    rerank(req: RerankRequest): Promise<RerankResponse>;
+}

package/dist/testing/fakeModelProvider.js

@@ -0,0 +1,79 @@
+/** Deterministic model provider for harness tests and examples. */
+export class FakeModelProvider {
+    queue = [];
+    textStreamQueue = [];
+    objectStreamQueue = [];
+    requests = [];
+    id = 'fake';
+    genAiSystem = 'fake';
+    enqueueObject(response) { this.queue.push({ method: 'object', response }); }
+    enqueueText(response) { this.queue.push({ method: 'text', response }); }
+    enqueueEmbedding(response) { this.queue.push({ method: 'embed', response }); }
+    enqueueRerank(response) { this.queue.push({ method: 'rerank', response }); }
+    enqueueTextStream(chunks) { this.textStreamQueue.push(chunks); }
+    enqueueObjectStream(chunks) { this.objectStreamQueue.push(chunks); }
+    /** Backward-compatible helper for older tests during the object migration. */
+    enqueue(response) { this.enqueueObject(response); }
+    async text(req) {
+        this.requests.push(req);
+        const next = this.queue.shift();
+        if (next?.method === 'text')
+            return next.response;
+        if (next)
+            this.queue.unshift(next);
+        return { content: '', usage: emptyUsage(), toolCalls: [], finishReason: 'stop' };
+    }
+    async *textStream(req) {
+        this.requests.push(req);
+        for (const chunk of this.textStreamQueue.shift() ?? [{ kind: 'finish', usage: emptyUsage(), finishReason: 'stop' }]) {
+            yield chunk;
+        }
+    }
+    async object(req) {
+        this.requests.push(req);
+        const next = this.queue.shift();
+        if (next?.method === 'object')
+            return next.response;
+        if (next)
+            this.queue.unshift(next);
+        return { object: '', usage: emptyUsage(), toolCalls: [], finishReason: 'stop' };
+    }
+    async *objectStream(req) {
+        this.requests.push(req);
+        for (const chunk of this.objectStreamQueue.shift() ?? [{ kind: 'finish', object: '', usage: emptyUsage(), finishReason: 'stop' }]) {
+            yield chunk;
+        }
+    }
+    async embed(req) {
+        this.requests.push(req);
+        const next = this.queue.shift();
+        if (next?.method === 'embed')
+            return next.response;
+        if (next)
+            this.queue.unshift(next);
+        const inputCount = Array.isArray(req.input) ? req.input.length : 1;
+        return {
+            embeddings: Array.from({ length: inputCount }, (_, index) => ({ index, vector: [0] })),
+            usage: emptyUsage()
+        };
+    }
+    async rerank(req) {
+        this.requests.push(req);
+        const next = this.queue.shift();
+        if (next?.method === 'rerank')
+            return next.response;
+        if (next)
+            this.queue.unshift(next);
+        return {
+            results: req.documents.map((document, index) => ({
+                id: document.id,
+                index,
+                score: req.documents.length - index,
+                ...(document.metadata ? { metadata: document.metadata } : {})
+            })).slice(0, req.topN ?? req.documents.length)
+        };
+    }
+}
+function emptyUsage() {
+    return { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+}

package/dist/testing/feedback.d.ts

@@ -0,0 +1,10 @@
+import type { FeedbackRecord, FeedbackTarget } from '../ports/feedback.js';
+/** Minimal in-memory feedback recorder for tests and examples. */
+export declare function createInMemoryFeedbackRecorder(): {
+    record(input: Omit<FeedbackRecord, "id" | "createdAt"> & {
+        id?: string;
+        createdAt?: string;
+    }): FeedbackRecord;
+    list(target?: FeedbackTarget): readonly FeedbackRecord[];
+    clear(): void;
+};

package/dist/testing/feedback.js

@@ -0,0 +1,24 @@
+/** Minimal in-memory feedback recorder for tests and examples. */
+export function createInMemoryFeedbackRecorder() {
+    const records = [];
+    return {
+        record(input) {
+            const record = {
+                ...input,
+                id: input.id ?? `feedback_${records.length + 1}`,
+                createdAt: input.createdAt ?? new Date().toISOString()
+            };
+            records.push(record);
+            return record;
+        },
+        list(target) {
+            if (!target) {
+                return [...records];
+            }
+            return records.filter((record) => JSON.stringify(record.target) === JSON.stringify(target));
+        },
+        clear() {
+            records.splice(0, records.length);
+        }
+    };
+}

package/dist/testing/fixtures/mcp/fake-http-server.d.ts

@@ -0,0 +1,8 @@
+export interface FakeHttpMcpServer {
+    url: string;
+    close(): Promise<void>;
+}
+export interface FakeHttpMcpServerOptions {
+    requiredHeaders?: Record<string, string>;
+}
+export declare function startFakeHttpMcpServer(options?: FakeHttpMcpServerOptions): Promise<FakeHttpMcpServer>;