@anureo/conformance 0.2.0 → 0.3.0

package/src/fake.js

@@ -0,0 +1,284 @@
+import { randomUUID } from "node:crypto";
+import { HarnessSdkError, } from "@anureo/sdk";
+import { AHP_PROTOCOL_CONTRACT, assertRequest, negotiateVersion, } from "@anureo/protocol";
+/** Default advertised capabilities. Adapter reads clone the current contents of this mutable template. */
+export const FAKE_CAPABILITIES = {
+    session: { resume: true, fork: ["before", "through"], revert: ["conversation", "files", "both"], history: true },
+    input: { delivery: ['native', 'afterTurn'], steer: { target: 'turn', atomicMatch: true }, interrupt: { targets: ['turn', 'session'], reportsPendingInputs: true } },
+    turn: { outputSchema: true, inputModalities: ["text", "image", "file"], overrides: ["model"] },
+    goal: { actions: ["set", "clear"] }, compact: true, review: true,
+    interactions: ["approval", "userInput", "elicitation", "dynamicTool"],
+    config: { options: [{ id: "model", scope: "session", schema: { type: "string" } }] },
+};
+/** Create a fresh adapter to pass to createClient. Await disposal of the client when the fixture is done. */
+export function createScriptedAdapter(options) {
+    return new ScriptedHarnessAdapter(options);
+}
+/**
+ * Supply runConformance with a fresh in-memory adapter per case, including held turns and
+ * observation faults. A supplied capability set replaces the defaults for applicability checks.
+ * The runner owns each client and its adapter.
+ */
+export function createScriptedConformanceFactory(capabilities) {
+    return (scenario) => {
+        const adapter = createScriptedAdapter({ capabilities, execute: scenarioExecutor(scenario) });
+        const sessionId = "conformance-session";
+        const driver = {
+            adapter,
+            openParams: { requestId: "conformance-open", mode: "new", binding: { sessionId, adapterId: "scripted", runtimeConfigId: "conformance-runtime" }, cwd: "/tmp" },
+        };
+        // executeScenarioTurn calls afterStart after admission, when openSession has recorded the sink.
+        if (scenario === "backpressure") {
+            driver.afterStart = async () => {
+                adapter.sinks.get(sessionId).tryEmit({ type: "notice", payload: { severity: "info", code: "FLOOD", message: "x".repeat(8192) } });
+            };
+            driver.runtimeOptions = { queue: { maxFrameBytes: 4096 } };
+        }
+        if (scenario === "disconnect") {
+            driver.afterStart = async () => {
+                await adapter.sinks.get(sessionId).fail(new HarnessSdkError("CONNECTION_CLOSED", "Conformance disconnection", false, true));
+            };
+        }
+        return driver;
+    };
+}
+/**
+ * Exercise the SDK with an in-memory adapter that records opens and backend dispatches. By default
+ * a submission echoes text and publishes completion before acknowledging it. Hooks can supply
+ * other behavior. Await Client.dispose to release SDK ownership while retaining fixture records
+ * for assertions.
+ */
+export class ScriptedHarnessAdapter {
+    options;
+    /** Retain fixture options by reference for subsequent capability reads, opens and dispatches. */
+    constructor(options = {}) {
+        this.options = options;
+    }
+    /** Backend dispatches in arrival order, including calls intercepted by execute. */
+    calls = [];
+    /** Detached open attempts, including attempts whose hook or fork validation fails. */
+    opened = [];
+    /** Latest supplied event sink per session ID, retained for fixture-controlled publication/failure. */
+    sinks = new Map();
+    /** Latest created backend per session ID, recorded before fork validation and onOpen. */
+    backends = new Map();
+    /** Number of disposal calls received, including any repeated direct calls. */
+    disposeCount = 0;
+    /** Return detached declared capabilities, using FAKE_CAPABILITIES when omitted. */
+    get capabilities() { return structuredClone(this.options.capabilities ?? FAKE_CAPABILITIES); }
+    /**
+     * Return scripted runtime metadata and cloned capabilities after negotiating AHP v1. The SDK
+     * adapter wrapper forwards the result to Client.initialize for validation and storage. Malformed
+     * requests and unsupported versions reject.
+     */
+    async initialize(params) {
+        assertRequest("initialize", params);
+        negotiateVersion(params.protocolVersions);
+        return { protocolVersion: 1, protocolContract: AHP_PROTOCOL_CONTRACT, runtime: { name: "scripted", version: "1.0.0", adapter: "conformance/0.1.0" }, capabilities: this.capabilities };
+    }
+    /**
+     * Supply OutputSession.open with a backend for SDK attachment. Record the backend and sink
+     * before copying fork history so a failed setup is observable. Missing source or boundary
+     * rejects with SESSION_NOT_FOUND or TURN_NOT_FOUND, respectively. Await onOpen before returning
+     * the backend. Hook failures reject and leave the recorded fixture state available.
+     */
+    async openSession(params, sink) {
+        this.opened.push(structuredClone(params));
+        this.sinks.set(params.binding.sessionId, sink);
+        const backend = new ScriptedBackendSession(this, params, sink);
+        this.backends.set(params.binding.sessionId, backend);
+        const fork = params.fork;
+        if (params.mode === "fork" && fork)
+            this.copyForkHistory(fork, backend);
+        await this.options.onOpen?.(params, sink);
+        return backend;
+    }
+    /** Count adapter release. The SDK wrapper calls this after session cleanup attempts. */
+    async dispose() { this.disposeCount++; }
+    /**
+     * Give openSession a detached prefix of the source history before setup hooks run. A missing
+     * source or boundary throws so open rejects with the fork's fixture records still available.
+     */
+    copyForkHistory(fork, backend) {
+        const source = this.backends.get(fork.sourceSessionId);
+        if (!source)
+            throw new HarnessSdkError("SESSION_NOT_FOUND");
+        const retained = historyBoundaryIndex(source.history, fork.boundary);
+        backend.history.push(...structuredClone(source.history.slice(0, retained)));
+    }
+}
+/**
+ * Inspect or customize the in-memory session recorded by ScriptedHarnessAdapter.openSession.
+ * OutputSession dispatches validated SDK requests to this backend. Direct fixture calls to execute
+ * bypass those SDK guards.
+ */
+export class ScriptedBackendSession {
+    adapter;
+    sink;
+    /** Requested identity with a deterministic scripted nativeRef, adopted by the SDK at attachment. */
+    binding;
+    /** Capabilities cloned from the adapter at construction and shared with the fixture state. */
+    capabilities;
+    /** Mutable native history. Default backend history/read returns this array by reference. */
+    history = [];
+    /** Number of disposal calls received, including any repeated direct calls. */
+    disposeCount = 0;
+    /** Initial attachment snapshot. Default configuration dispatch replaces it without publishing a state event. */
+    state;
+    /** Build a ready attachment snapshot and retain the adapter and event sink for dispatch. */
+    constructor(adapter, params, 
+    /** Callbacks supplied at open for event publication, interactions and source faults. */
+    sink) {
+        this.adapter = adapter;
+        this.sink = sink;
+        this.binding = { ...params.binding, nativeRef: { provider: "scripted", value: `native:${params.binding.sessionId}` } };
+        this.capabilities = adapter.capabilities;
+        this.state = {
+            binding: this.binding,
+            capabilities: this.capabilities,
+            status: "ready",
+            activeTurnIds: [],
+            config: params.config ?? {},
+            ...(params.model ? { model: params.model } : {}),
+            capabilityRevision: 1,
+        };
+    }
+    /** Await ordered sink publication. Supply the owning turn ID for item events. Sink failures reject. */
+    async emit(payload, turnId) { await this.sink.emit(payload, { turnId }); }
+    async execute(method, params) {
+        const call = { method, params };
+        this.adapter.calls.push(call);
+        const custom = await this.adapter.options.execute?.(call, this.sink);
+        if (custom !== undefined)
+            return custom;
+        switch (method) {
+            case "input/submit":
+                return await this.submitInput(params);
+            case "turn/steer": {
+                const request = params;
+                await this.emit({ type: "turn/completed", payload: { turnId: request.expectedTurnId, status: "completed" } });
+                return { submissionId: request.submissionId, turnId: request.expectedTurnId, accepted: true };
+            }
+            case "turn/interrupt": {
+                const { turnId } = params;
+                await this.emit({ type: "turn/completed", payload: { turnId, status: "interrupted" } });
+                return { accepted: true, turnId };
+            }
+            case "session/config/set": {
+                this.state = {
+                    ...this.state,
+                    config: { ...this.state.config, ...params.patch },
+                    capabilityRevision: this.state.capabilityRevision + 1,
+                };
+                return this.state;
+            }
+            case "session/revert": {
+                const request = params;
+                if (request.scope !== "files") {
+                    this.history.splice(historyBoundaryIndex(this.history, request.boundary));
+                }
+                return { appliedScope: request.scope, boundary: request.boundary };
+            }
+            case "history/read":
+                return { items: this.history, snapshotToken: "fake-snapshot", source: this.binding.nativeRef };
+            case "goal/set":
+                return { goal: params.goal, status: "active" };
+            case "goal/clear":
+                return { goal: null, status: "cleared" };
+            case "compact/start":
+                return { maintenanceId: "fake-maintenance", status: "completed" };
+            case "review/start": {
+                const turnId = randomUUID();
+                await this.emit({ type: "turn/started", payload: { turnId } });
+                await this.emit({ type: "turn/completed", payload: { turnId, status: "completed" } });
+                return startedReceipt(params.submissionId, turnId);
+            }
+            case "session/interrupt":
+                return { accepted: true, stillQueued: [] };
+            case "session/close":
+                return { closed: true, observationClosed: true, executionStopped: "unconfirmed" };
+            case "interaction/respond":
+            case "interaction/cancel":
+                throw new Error("Interactions must be handled by the SDK registry");
+        }
+    }
+    /** Count backend release calls from the SDK or direct fixture callers and retain state for assertions. */
+    async dispose() { this.disposeCount++; }
+    /**
+     * Produce the default submission receipt after publishing start, preview, final item and terminal.
+     * Reuse an item ID across turns to exercise SDK scoping. Store the completed item before terminal
+     * publication, where a sink failure can still reject the dispatch.
+     */
+    async submitInput(request) {
+        const turnId = randomUUID();
+        await this.emit({ type: "turn/started", payload: { turnId } });
+        const text = request.input.filter(part => part.type === "text").map(part => part.text).join("\n");
+        const item = { id: "native-reused", type: "agentMessage", text, phase: "final" };
+        await this.emit({ type: "item/started", payload: { item: { ...item, text: "" } } }, turnId);
+        await this.emit({ type: "item/delta", payload: { itemId: item.id, kind: "text", text: "preview " } }, turnId);
+        await this.emit({ type: "item/completed", payload: { item } }, turnId);
+        this.history.push({ turnId, item });
+        await this.emit({ type: "turn/completed", payload: { turnId, status: "completed" } });
+        return { submissionId: request.submissionId, turnId, accepted: true, disposition: "started" };
+    }
+}
+/** Associate an accepted submission with its started turn. Terminal publication is independent. */
+function startedReceipt(submissionId, turnId) {
+    return { submissionId, accepted: true, disposition: "started", turnId };
+}
+/**
+ * Find the end of the retained prefix shared by fork and revert. Use the first matching history
+ * entry as the boundary. Throw TURN_NOT_FOUND before either caller changes history if it is absent.
+ */
+function historyBoundaryIndex(history, boundary) {
+    const index = history.findIndex(entry => entry.turnId === boundary.turnId);
+    if (index < 0)
+        throw new HarnessSdkError("TURN_NOT_FOUND");
+    return boundary.relation === "before" ? index : index + 1;
+}
+/**
+ * Create the hook that ScriptedBackendSession.execute awaits. Only special submissions supply a
+ * receipt here. Held cases stop after start so the suite can drive control or observation loss.
+ * Interaction cases await SDK settlement before completion. Sink failures reject dispatch.
+ */
+function scenarioExecutor(scenario) {
+    return async (call, sink) => {
+        if (call.method !== "input/submit")
+            return undefined;
+        const { submissionId } = call.params;
+        const turnId = randomUUID();
+        const hold = ["interrupt", "steer", "disconnect", "backpressure"].includes(scenario);
+        const interaction = hold ? undefined : scenarioInteraction(scenario, turnId);
+        if (!hold && !interaction && scenario !== "unknown-item")
+            return undefined;
+        await sink.emit({ type: "turn/started", payload: { turnId } });
+        if (hold)
+            return startedReceipt(submissionId, turnId);
+        if (interaction) {
+            // The SDK registry calls this responder when it settles the request. The fixture has no
+            // native peer to notify, but it still waits for the registry before completing the turn.
+            await sink.requestInteraction(interaction, async () => { });
+        }
+        else {
+            await sink.emit({
+                type: "item/completed",
+                payload: { item: { id: "unknown", type: "toolCall", kind: "other", title: "Unknown", nativeType: "futureNativeType", raw: { safe: "value" } } },
+            }, { turnId });
+        }
+        await sink.emit({ type: "turn/completed", payload: { turnId, status: "completed" } });
+        return startedReceipt(submissionId, turnId);
+    };
+}
+/** Supply the SDK's automatic conformance handler with the native request for an interaction case. */
+function scenarioInteraction(scenario, turnId) {
+    switch (scenario) {
+        case "approval":
+            return { interactionId: "conformance-approval", kind: "approval", turnId, options: [{ id: "deny", label: "Deny", semantic: "deny" }] };
+        case "userInput":
+            return { interactionId: "conformance-input", kind: "userInput", turnId, questions: [{ id: "q", prompt: "Value" }] };
+        case "elicitation":
+            return { interactionId: "conformance-elicitation", kind: "elicitation", turnId, mode: "form" };
+        case "dynamicTool":
+            return { interactionId: "conformance-tool", kind: "dynamicTool", turnId, toolName: "conformance", arguments: {} };
+    }
+}

package/src/fixtures.d.ts

@@ -0,0 +1,38 @@
+import type { AhpEventPayload, AhpMethod, AhpRequestMap, AhpResultMap } from "@anureo/protocol";
+/** Native peer protocol used to select a fixture. The JSONL runners accept Codex, ACP and AHP. */
+export type WireFlavor = "codex" | "claude" | "acp" | "ahp";
+/** One step in the JSONL peer script. The peer considers only the next step for each parsed message. */
+export interface NativeFixtureFrame {
+    /** Match this method exactly. Omit to match any parsed message, including a response without a method. */
+    waitForMethod?: string;
+    /**
+     * Messages written in order after a match. The peer substitutes "$requestId" and
+     * "$params.<key>" string values recursively, using a single top-level parameter key.
+     * ACP and AHP default jsonrpc to "2.0". Codex leaves that field as authored.
+     */
+    emit: ReadonlyArray<Record<string, unknown>>;
+    /**
+     * Require an exact ID and JSON.stringify-equal result after the method filter matches.
+     * A mismatch suppresses emission, stops script processing, writes FIXTURE_RESPONSE_MISMATCH
+     * to stderr and sets exit code 2.
+     */
+    expectedResponse?: {
+        id: string | number;
+        result: unknown;
+    };
+}
+/** Describe a named native exchange and the AHP event payloads the consuming test should assert. */
+export interface ConformanceFixture {
+    name: string;
+    flavor: WireFlavor;
+    /** Ordered peer steps. For JSONL peers, point HARNESS_FIXTURE_SCRIPT at a file containing this array. */
+    script: readonly NativeFixtureFrame[];
+    /** Expected observations for the consuming test to compare with the adapter's emitted payloads. */
+    expectedEvents: readonly AhpEventPayload[];
+}
+/** Pair an AHP request and expected result under their method key for a typed test fixture. */
+export type MethodFixture<M extends AhpMethod> = {
+    method: M;
+    request: AhpRequestMap[M];
+    result: AhpResultMap[M];
+};

package/src/index.d.ts

@@ -0,0 +1,6 @@
+/** Adapter acceptance runners and injectable fixtures for SDK, adapter and application tests. */
+export * from "./fake.js";
+export * from "./suite.js";
+export * from "./fixtures.js";
+export * from "./fake-claude.js";
+export * from "./native.js";

package/src/index.js

@@ -0,0 +1,6 @@
+/** Adapter acceptance runners and injectable fixtures for SDK, adapter and application tests. */
+export * from "./fake.js";
+export * from "./suite.js";
+export * from "./fixtures.js";
+export * from "./fake-claude.js";
+export * from "./native.js";

package/src/native.d.ts

@@ -0,0 +1,44 @@
+import type { Client, Input, Session } from '@anureo/sdk';
+/** Native execution association, active observation closure, and independent observer ownership cases. */
+export type NativeScenario = 'overlap' | 'close-active' | 'observer-cancel';
+/** Supply an already opened, isolated native session and transfer its client to the runner for disposal. */
+export interface NativeFixture {
+    client: Client;
+    /** Open session owned by client. */
+    session: Session;
+    /** Input that starts an execution the fixture keeps active for the selected check. */
+    first: Input;
+    /** Follow-up input for overlap/observer-cancel; unused by close-active. */
+    second: Input;
+    /** Whether the two overlap submissions should resolve to the same execution ID. */
+    relation: 'same' | 'different';
+    /**
+     * The overlap and observer-cancel checks await this hook after initiating both submissions
+     * and before awaiting the second Turn. If the fixture holds execution, wait for evidence
+     * that the native backend received both inputs before allowing completion. Omit the hook
+     * when native behavior provides that ordering. The close-active check never calls it.
+     */
+    release?(): Promise<void>;
+}
+/** Supply a fresh client and open session for each case. Clean up partial setup on rejection and retain ownership of external resources. */
+export type NativeFixtureFactory = (scenario: NativeScenario) => Promise<NativeFixture>;
+/** Native case verdicts in the order requested by the caller. */
+export interface NativeConformanceReport {
+    /** True when every selected case passed, including an empty selection. */
+    passed: boolean;
+    results: Array<{
+        scenario: NativeScenario;
+        passed: boolean;
+        /** Failure code or CONFORMANCE_FAILED. RESOURCE_RELEASE_FAILED is appended after a prior failure. */
+        error?: string;
+    }>;
+}
+/**
+ * Check native lifecycle behavior through the SDK, sequentially in the requested order.
+ * The default order is overlap, close-active, then observer-cancel. Submission association,
+ * result and close waits each use 3000 ms. Factory setup, the optional release hook and client
+ * disposal have no runner deadline. The runner awaits disposal of each returned client before
+ * proceeding and reports setup, check and disposal failures as case verdicts. Fixture providers
+ * still own external servers and controls.
+ */
+export declare function runNativeConformance(factory: NativeFixtureFactory, scenarios?: readonly NativeScenario[]): Promise<NativeConformanceReport>;

package/src/native.js

@@ -0,0 +1,96 @@
+/**
+ * Check native lifecycle behavior through the SDK, sequentially in the requested order.
+ * The default order is overlap, close-active, then observer-cancel. Submission association,
+ * result and close waits each use 3000 ms. Factory setup, the optional release hook and client
+ * disposal have no runner deadline. The runner awaits disposal of each returned client before
+ * proceeding and reports setup, check and disposal failures as case verdicts. Fixture providers
+ * still own external servers and controls.
+ */
+export async function runNativeConformance(factory, scenarios = ['overlap', 'close-active', 'observer-cancel']) {
+    const results = [];
+    for (const scenario of scenarios) {
+        results.push(await runNativeCase(factory, scenario));
+    }
+    return { passed: results.every(value => value.passed), results };
+}
+const nativeWaitMs = 3000;
+/** Give runNativeConformance one verdict after running the selected check and disposing its fixture client. */
+async function runNativeCase(factory, scenario) {
+    let fixture;
+    let failure;
+    try {
+        fixture = await factory(scenario);
+        const first = submitObserved(fixture.session, fixture.first);
+        if (scenario === 'overlap')
+            await checkOverlap(fixture, first);
+        else if (scenario === 'close-active')
+            await checkActiveClose(fixture, first);
+        else
+            await checkObserverCancellation(fixture, first);
+    }
+    catch (cause) {
+        failure = cause && typeof cause === 'object' && 'code' in cause ? String(cause.code) : 'CONFORMANCE_FAILED';
+    }
+    finally {
+        try {
+            await fixture?.client.dispose();
+        }
+        catch {
+            failure = failure ? `${failure}+RESOURCE_RELEASE_FAILED` : 'RESOURCE_RELEASE_FAILED';
+        }
+    }
+    return { scenario, passed: !failure, ...(failure ? { error: failure } : {}) };
+}
+/** Start association immediately. Observe early rejection while the case releases its fixture, and preserve it for later awaits. */
+function submitObserved(session, input) {
+    const submission = session.submit({ input }, { timeoutMs: nativeWaitMs });
+    void submission.catch(() => { });
+    return submission;
+}
+/** Initiate both inputs before release, then verify the expected association and matching results for a shared execution. */
+async function checkOverlap(fixture, first) {
+    const second = submitObserved(fixture.session, fixture.second);
+    await fixture.release?.();
+    const [firstTurn, secondTurn] = await Promise.all([first, second]);
+    if ((firstTurn.id === secondTurn.id) !== (fixture.relation === 'same'))
+        throw new Error('EXECUTION_ASSOCIATION');
+    const [firstResult, secondResult] = await Promise.all([
+        firstTurn.result({ timeoutMs: nativeWaitMs }),
+        secondTurn.result({ timeoutMs: nativeWaitMs }),
+    ]);
+    if (firstResult.status !== 'completed' || secondResult.status !== 'completed')
+        throw new Error('NATIVE_TERMINAL');
+    if (firstTurn.id === secondTurn.id && JSON.stringify(firstResult) !== JSON.stringify(secondResult))
+        throw new Error('SHARED_RESULT');
+}
+/** Closing an active session must end observation without synthesizing a native execution result. */
+async function checkActiveClose(fixture, first) {
+    const turn = await first;
+    const result = await fixture.session.close({ timeoutMs: nativeWaitMs });
+    if (!result.observationClosed)
+        throw new Error('OBSERVATION_NOT_CLOSED');
+    await assertObservationClosed(turn);
+}
+/** Dispose the original observer before the second submission. Its sibling must still receive the native completion after release. */
+async function checkObserverCancellation(fixture, first) {
+    const firstTurn = await first;
+    const siblingObserver = firstTurn.observe();
+    await firstTurn.dispose();
+    const second = submitObserved(fixture.session, fixture.second);
+    await fixture.release?.();
+    await second;
+    if ((await siblingObserver.result({ timeoutMs: nativeWaitMs })).status !== 'completed')
+        throw new Error('SIBLING_OBSERVER_CANCELLED');
+}
+/** Accept only observation closure; a native terminal or any other rejection fails the active-close case. */
+async function assertObservationClosed(turn) {
+    try {
+        await turn.result({ timeoutMs: nativeWaitMs });
+    }
+    catch (cause) {
+        if (cause && typeof cause === 'object' && 'code' in cause && cause.code === 'OBSERVATION_CLOSED')
+            return;
+        throw cause;
+    }
+    throw new Error('FALSE_TERMINAL');
+}

package/src/suite.d.ts

@@ -0,0 +1,60 @@
+import { type HarnessAdapter, type RuntimeOptions, type Session } from '@anureo/sdk';
+import type { InteractionRequested, InteractionResponse, SessionOpenParams } from '@anureo/protocol';
+/** Default shared acceptance cases in execution order. Use runNativeConformance for native lifecycle cases. */
+export declare const CONFORMANCE_SCENARIOS: readonly ["lifecycle", "immediate", "identity", "approval", "userInput", "elicitation", "dynamicTool", "interrupt", "steer", "fork", "revert", "history", "unknown-item", "disconnect", "backpressure"];
+/** Select a shared behavioral case to run or to supply fixture behavior for. */
+export type ConformanceScenario = typeof CONFORMANCE_SCENARIOS[number];
+/** Supply scenario-specific native behavior to the runner that manages the SDK client. */
+export interface ConformanceDriver {
+    /** Fresh adapter passed to createClient for SDK-managed initialization and release. */
+    adapter: HarnessAdapter;
+    /** Native session setup passed to Client.openSession. Its binding also supplies the client identity. */
+    openParams: SessionOpenParams;
+    /** SDK policy overrides, including queue limits for backpressure fixtures. */
+    runtimeOptions?: RuntimeOptions;
+    /**
+     * runConformance awaits this hook after obtaining the initial Turn and completing any control request,
+     * before waiting for its result. Fixtures can use it to induce source loss. A rejection reaches the
+     * case as an execution failure and can satisfy a fault case if it carries one of that case's codes.
+     */
+    afterStart?: (session: Session) => Promise<void>;
+    /** Authoritative text expected by lifecycle and immediate. Defaults to 'conformance'. */
+    expectedText?: string;
+    /**
+     * Answer a native interaction with a response of the matching kind. The SDK calls the runner's
+     * registered handler after publishing the request and delivers the answer to the native responder.
+     * If the callback throws, the SDK cancels the interaction while it is still actionable.
+     * By default the runner selects the first approval option and the first option for each question,
+     * uses 'conformance' for free-text answers and tool output, and declines elicitation.
+     */
+    answer?: (request: InteractionRequested) => InteractionResponse;
+}
+/** Supply an isolated driver each time runConformance starts a selected case, even if it later skips the case. Release external resources and clean up failed factory setup yourself. */
+export type ConformanceFactory = (scenario: ConformanceScenario) => Promise<ConformanceDriver> | ConformanceDriver;
+/** Verdict for one selected case. */
+export interface ConformanceCaseResult {
+    scenario: ConformanceScenario;
+    /** An undeclared required capability yields 'not-applicable'. A broken declared capability yields 'failed'. */
+    status: 'passed' | 'failed' | 'not-applicable';
+    /** Diagnostic for a failed case, replaced by RESOURCE_RELEASE_FAILED if disposal of its client rejects. */
+    message?: string;
+}
+/** Shared case verdicts in the order requested by the caller. */
+export interface ConformanceReport {
+    /** True when no selected case failed, including an empty selection or cases that were skipped. */
+    passed: boolean;
+    cases: ConformanceCaseResult[];
+}
+/**
+ * Check an adapter through the public SDK, sequentially in the selected order (all shared cases by default).
+ * The timeoutMs option bounds initial submission, controls, afterStart and result observation.
+ * It defaults to 3000 ms and leaves setup, later session operations and cleanup on their own
+ * SDK or fixture wait policies. The runner awaits reader teardown before client disposal and
+ * starts the next case after cleanup. Setup and check failures become case verdicts. Reader
+ * teardown failure rejects the run before client disposal. Client disposal failure marks the
+ * case failed with RESOURCE_RELEASE_FAILED. Callers still own resources outside the SDK client.
+ */
+export declare function runConformance(factory: ConformanceFactory, options?: {
+    timeoutMs?: number;
+    scenarios?: readonly ConformanceScenario[];
+}): Promise<ConformanceReport>;