@anureo/conformance 0.2.0 → 0.3.0

package/src/suite.js

@@ -0,0 +1,289 @@
+import { createClient } from '@anureo/sdk';
+/** Default shared acceptance cases in execution order. Use runNativeConformance for native lifecycle cases. */
+export const CONFORMANCE_SCENARIOS = [
+    'lifecycle', 'immediate', 'identity', 'approval', 'userInput', 'elicitation', 'dynamicTool',
+    'interrupt', 'steer', 'fork', 'revert', 'history', 'unknown-item', 'disconnect', 'backpressure',
+];
+/**
+ * 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 async function runConformance(factory, options = {}) {
+    const cases = [];
+    for (const scenario of options.scenarios ?? CONFORMANCE_SCENARIOS) {
+        cases.push(await runConformanceCase({ factory, scenario, timeoutMs: options.timeoutMs ?? 3000 }));
+    }
+    return { passed: cases.every(entry => entry.status !== 'failed'), cases };
+}
+/**
+ * Supply runConformance with one verdict after fixture setup, applicable checks and ordered cleanup.
+ * Returning the reader first detaches it from the session and lets its collection task finish.
+ * Reader teardown failure propagates directly. Client disposal failure replaces any earlier verdict.
+ */
+async function runConformanceCase({ factory, scenario, timeoutMs }) {
+    let client;
+    let observation;
+    let result;
+    try {
+        const driver = await factory(scenario);
+        client = await createCaseClient(driver);
+        const session = await client.openSession(driver.openParams);
+        if (!isApplicable(scenario, session.capabilities)) {
+            result = { scenario, status: 'not-applicable' };
+        }
+        else {
+            observation = collectEvents(session);
+            await checkScenario({ client, session, driver, scenario, observation, timeoutMs });
+            result = { scenario, status: 'passed' };
+        }
+    }
+    catch (cause) {
+        result = { scenario, status: 'failed', message: cause instanceof Error ? cause.message : 'Conformance failed' };
+    }
+    finally {
+        await observation?.reader.return?.();
+        await observation?.task;
+        try {
+            await client?.dispose();
+        }
+        catch {
+            result = { scenario, status: 'failed', message: 'RESOURCE_RELEASE_FAILED' };
+        }
+    }
+    return result;
+}
+const interactionKinds = ['approval', 'userInput', 'elicitation', 'dynamicTool'];
+/**
+ * Initialize the driver adapter for runConformanceCase, advertising every interaction kind.
+ * The SDK invokes the registered handler after publishing the request and uses its answer for
+ * native settlement. Return createClient's initialization promise so runConformanceCase can
+ * open a session and later dispose the client, or record an initialization failure.
+ */
+function createCaseClient(driver) {
+    const handlers = Object.fromEntries(interactionKinds.map(kind => [
+        kind,
+        async (request) => (driver.answer ?? defaultAnswer)(request),
+    ]));
+    return createClient({
+        adapter: driver.adapter,
+        identity: driver.openParams.binding,
+        runtime: driver.runtimeOptions,
+        interactions: handlers,
+    });
+}
+/**
+ * Subscribe before submission so the case can inspect events published before association.
+ * The task records read failures and enforces a 10,000-event limit. checkScenario uses its
+ * completion and failure during verification. runConformanceCase owns reader teardown.
+ */
+function collectEvents(session) {
+    const reader = session.events()[Symbol.asyncIterator]();
+    const events = [];
+    let failure;
+    const task = (async () => {
+        try {
+            for (;;) {
+                const event = await reader.next();
+                if (event.done)
+                    return;
+                events.push(event.value);
+                if (events.length > 10_000)
+                    throw new Error('Too many events without completion');
+            }
+        }
+        catch (cause) {
+            failure = cause;
+        }
+    })();
+    return { reader, events, task, get failure() { return failure; } };
+}
+/**
+ * Verify the initial execution before any follow-up operations add events. runConformanceCase
+ * awaits this before recording a pass. Only source fault cases expect observation to fail.
+ */
+async function checkScenario({ client, session, driver, scenario, observation, timeoutMs }) {
+    const { events } = observation;
+    const capabilities = session.capabilities;
+    const execution = executeScenarioTurn({ session, driver, scenario, capabilities });
+    const expectsSourceFailure = scenario === 'disconnect' || scenario === 'backpressure';
+    if (expectsSourceFailure) {
+        await checkSourceFailure({ execution, scenario, events, timeoutMs });
+    }
+    else {
+        const { turn, result } = await deadline(Promise.race([
+            execution,
+            observation.task.then(() => { throw observation.failure ?? new Error('Source ended before result'); }),
+        ]), timeoutMs);
+        checkTurnResult({ scenario, driver, events, result });
+        if (scenario === 'identity' || scenario === 'history' || scenario === 'fork' || scenario === 'revert') {
+            await checkSessionOperation({ client, session, turn, scenario, capabilities });
+        }
+    }
+    requireCondition(!observation.failure || expectsSourceFailure, 'Unexpected source failure');
+    checkEventSequence(session, events);
+}
+/** Dispatch the selected follow-up after initial terminal evidence passes. Its rejection fails the case. */
+async function checkSessionOperation({ client, session, turn, scenario, capabilities }) {
+    switch (scenario) {
+        case 'identity':
+            await checkDistinctExecution(session, turn);
+            break;
+        case 'history':
+            await checkHistoryIdentity(session);
+            break;
+        case 'fork': {
+            const relations = capabilities.session?.fork;
+            requireCondition(relations !== undefined, 'Fork capability missing');
+            await checkForkBoundaries({ client, session, turn, relations, history: capabilities.session?.history });
+            break;
+        }
+        case 'revert': {
+            const scope = capabilities.session?.revert?.[0];
+            requireCondition(scope !== undefined, 'Revert capability missing');
+            await checkRevertBoundary({ session, turn, scope, history: capabilities.session?.history });
+            break;
+        }
+    }
+}
+/**
+ * Start the initial input for checkScenario and return its associated Turn and retained result.
+ * Session-level interruption is issued before awaiting association, which turn controls require.
+ * Await afterStart after controls so its effects or failure precede the result wait.
+ */
+async function executeScenarioTurn({ session, driver, scenario, capabilities }) {
+    const pendingTurn = session.submit({ input: 'conformance' });
+    // Interruption/release may reject submission before we await the original promise.
+    void pendingTurn.catch(() => { });
+    const supportsTurnInterrupt = scenario === 'interrupt' && capabilities.input?.interrupt?.targets.includes('turn') === true;
+    if (scenario === 'interrupt' && !supportsTurnInterrupt) {
+        await Promise.resolve();
+        await session.interrupt();
+    }
+    const turn = await pendingTurn;
+    if (scenario === 'steer')
+        await turn.steer({ input: 'redirect' });
+    if (scenario === 'interrupt' && supportsTurnInterrupt)
+        await turn.interrupt();
+    await driver.afterStart?.(session);
+    return { turn, result: await turn.result() };
+}
+/** Fail the case unless execution rejects with an allowed source-loss code and no terminal event was published. */
+async function checkSourceFailure({ execution, scenario, events, timeoutMs }) {
+    try {
+        await deadline(execution, timeoutMs);
+    }
+    catch (cause) {
+        requireCondition(cause && typeof cause === 'object' && 'code' in cause, 'Source failure must be typed');
+        const expectedCodes = scenario === 'disconnect'
+            ? ['CONNECTION_CLOSED', 'ACP_CONNECTION_CLOSED', 'RPC_CONNECTION_CLOSED']
+            : ['BACKPRESSURE_EXCEEDED', 'FRAME_TOO_LARGE'];
+        requireCondition(expectedCodes.includes(String(cause.code)), `Unexpected observation error: ${String(cause.code)}`);
+        requireCondition(!events.some(event => event.type === 'turn/completed'), 'SDK must not fabricate native terminal');
+        return;
+    }
+    throw new Error('Lost source must fail observation');
+}
+/** Check native terminal evidence before identity/history operations add further executions and events. */
+function checkTurnResult({ scenario, driver, events, result }) {
+    requireCondition(result.status === (scenario === 'interrupt' ? 'interrupted' : 'completed'), 'Unexpected native terminal');
+    requireCondition(events.filter(event => event.type === 'turn/started').length === 1, 'Execution must start once');
+    requireCondition(events.filter(event => event.type === 'turn/completed').length === 1, 'Execution must end once');
+    if (isInteractionScenario(scenario)) {
+        requireCondition(events.some(event => event.type === 'interaction/requested') && events.some(event => event.type === 'interaction/resolved'), 'Interaction not exercised');
+    }
+    if (scenario === 'lifecycle' || scenario === 'immediate') {
+        requireCondition(result.text === (driver.expectedText ?? 'conformance'), 'Authoritative final text missing');
+    }
+    if (scenario === 'unknown-item') {
+        requireCondition(result.items.some(item => item.type === 'toolCall' && item.kind === 'other' && item.nativeType), 'Unknown native item lost');
+    }
+}
+/** After the first terminal result, wait for a second execution and require a fresh identity. */
+async function checkDistinctExecution(session, turn) {
+    const other = await session.submit({ input: 'conformance' });
+    await other.result();
+    requireCondition(other.id !== turn.id, 'Execution identity reused');
+}
+/** Verify the first history page retains both execution and item IDs after completion. */
+async function checkHistoryIdentity(session) {
+    const page = await session.request('history/read', { sessionId: session.id, requestId: 'history' });
+    requireCondition(page.items.length && page.items.every(item => item.turnId && item.item.id), 'History identity missing');
+}
+/**
+ * Verify each advertised fork boundary in order. Check history when supported and close each
+ * verified fork before opening the next. The case client still owns a fork if a check rejects.
+ */
+async function checkForkBoundaries({ client, session, turn, relations, history }) {
+    for (const relation of relations) {
+        const fork = await client.sessions.fork(session.reference, { boundary: { turnId: turn.id, relation } });
+        requireCondition(fork.id !== session.id && fork.binding.adapterId === session.binding.adapterId, 'Fork binding invalid');
+        if (history) {
+            const page = await fork.request('history/read', { sessionId: fork.id, requestId: 'fork-history' });
+            const includesBoundary = page.items.some(item => item.turnId === turn.id);
+            requireCondition(includesBoundary === (relation !== 'before'), 'Fork boundary lost');
+        }
+        await fork.close();
+    }
+}
+/** Verify the receipt for the first advertised scope, and check supported history when the scope includes conversation. */
+async function checkRevertBoundary({ session, turn, scope, history }) {
+    const sessionId = session.id;
+    const result = await session.request('session/revert', { sessionId, requestId: 'revert', scope, boundary: { turnId: turn.id, relation: 'before' } });
+    requireCondition(result.appliedScope === scope && result.boundary.turnId === turn.id, 'Revert scope mismatch');
+    if (scope !== 'files' && history) {
+        const page = await session.request('history/read', { sessionId, requestId: 'reverted-history' });
+        requireCondition(!page.items.some(item => item.turnId === turn.id), 'Revert boundary retained');
+    }
+}
+/** Check the contiguous session stream from the first observed sequence, since subscriptions have no replay. */
+function checkEventSequence(session, events) {
+    const firstEvent = events[0];
+    if (firstEvent === undefined)
+        return;
+    const contiguous = events.every((event, index) => event.seq === firstEvent.seq + index && event.sessionId === session.id && event.streamId === firstEvent.streamId);
+    requireCondition(contiguous, 'Source sequence gap');
+}
+/** Throw assertion messages that runConformanceCase records as failed-case diagnostics. */
+function requireCondition(value, message) { if (!value)
+    throw new Error(message); }
+/** Reject the wait at its deadline. The underlying promise stays observed and the case owner handles cleanup. */
+function deadline(promise, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('Conformance timed out')), timeoutMs);
+        promise.then(value => { clearTimeout(timer); resolve(value); }, cause => { clearTimeout(timer); reject(cause); });
+    });
+}
+/** Let runConformanceCase skip scenarios whose required session capability was omitted. */
+function isApplicable(scenario, capabilities) {
+    if (isInteractionScenario(scenario))
+        return capabilities.interactions?.includes(scenario) ?? false;
+    if (scenario === 'steer')
+        return capabilities.input?.steer?.atomicMatch === true;
+    if (scenario === 'interrupt')
+        return !!capabilities.input?.interrupt?.targets.length;
+    if (scenario === 'fork')
+        return !!capabilities.session?.fork?.length;
+    if (scenario === 'revert')
+        return !!capabilities.session?.revert?.length;
+    if (scenario === 'history')
+        return !!capabilities.session?.history;
+    return true;
+}
+/** Identify cases whose applicability and verdict depend on a native interaction. */
+function isInteractionScenario(scenario) {
+    return interactionKinds.some(kind => kind === scenario);
+}
+/** Answer the SDK handler's request when the driver supplies no override. Approval fixtures must provide an option. */
+function defaultAnswer(request) {
+    switch (request.kind) {
+        case 'approval': return { kind: request.kind, optionId: request.options[0].id };
+        case 'userInput': return { kind: request.kind, answers: Object.fromEntries(request.questions.map(question => [question.id, question.options?.[0]?.id ?? 'conformance'])) };
+        case 'elicitation': return { kind: request.kind, action: 'decline' };
+        case 'dynamicTool': return { kind: request.kind, content: [{ type: 'text', text: 'conformance' }] };
+    }
+}

package/dist/fake-claude.d.ts

@@ -1,40 +0,0 @@
-import type { JsonObject, JsonValue } from "@anureo/protocol";
-export interface ClaudeQueryScript {
-    messages: JsonObject[];
-    onInput?: (input: JsonValue, emit: (message: JsonObject) => Promise<void>) => Promise<void>;
-    models?: Array<{
-        value: string;
-        displayName: string;
-        description: string;
-    }>;
-    canRewind?: boolean;
-}
-/** Minimal injectable query facade. The adapter supplies its SDK-facing structural types. */
-export declare class ScriptedClaudeQuery implements AsyncIterable<JsonObject> {
-    private readonly script;
-    readonly calls: Array<{
-        method: string;
-        value?: JsonValue;
-    }>;
-    private readonly queue;
-    private closed;
-    constructor(script: ClaudeQueryScript);
-    [Symbol.asyncIterator](): AsyncIterator<JsonObject>;
-    streamInput(stream: AsyncIterable<JsonValue>): Promise<void>;
-    interrupt(): Promise<void>;
-    setModel(model?: string): Promise<void>;
-    setPermissionMode(mode: string): Promise<void>;
-    setMaxThinkingTokens(tokens: number | null): Promise<void>;
-    rewindFiles(id: string): Promise<{
-        canRewind: boolean;
-        error?: string;
-    }>;
-    supportedModels(): Promise<{
-        value: string;
-        displayName: string;
-        description: string;
-    }[]>;
-    finish(): void;
-    close(): void;
-}
-export declare function createFakeClaudeQuery(script: ClaudeQueryScript): ScriptedClaudeQuery;

package/dist/fake.d.ts

@@ -1,44 +0,0 @@
-import { type BackendSession, type HarnessAdapter, type SessionEventSink, type SessionMethod } from "@anureo/sdk";
-import { type Capabilities, type AhpRequestMap, type AhpResultMap, type HistoryItem, type InitializeParams, type InitializeResult, type SessionBinding, type SessionOpenParams, type AhpEventPayload } from "@anureo/protocol";
-import type { ConformanceFactory } from "./suite.js";
-export interface FakeCall {
-    method: SessionMethod;
-    params: AhpRequestMap[SessionMethod];
-}
-export interface FakeAdapterOptions {
-    capabilities?: Capabilities;
-    /** Hook can publish events, pause a response, or throw exactly at a chosen dispatch point. */
-    execute?: (call: FakeCall, sink: SessionEventSink) => Promise<AhpResultMap[SessionMethod] | undefined>;
-    onOpen?: (params: SessionOpenParams, sink: SessionEventSink) => Promise<void>;
-}
-export declare const FAKE_CAPABILITIES: Capabilities;
-/** In-memory official-API-shaped fake. It is test-only and never registered in the production Host. */
-export declare class ScriptedHarnessAdapter implements HarnessAdapter {
-    readonly options: FakeAdapterOptions;
-    readonly calls: FakeCall[];
-    readonly opened: SessionOpenParams[];
-    readonly sinks: Map<string, SessionEventSink>;
-    readonly backends: Map<string, ScriptedBackendSession>;
-    disposeCount: number;
-    constructor(options?: FakeAdapterOptions);
-    get capabilities(): Capabilities;
-    initialize(params: InitializeParams): Promise<InitializeResult>;
-    openSession(params: SessionOpenParams, sink: SessionEventSink): Promise<BackendSession>;
-    dispose(): Promise<void>;
-}
-export declare class ScriptedBackendSession implements BackendSession {
-    private readonly adapter;
-    readonly sink: SessionEventSink;
-    readonly binding: SessionBinding;
-    readonly capabilities: Capabilities;
-    readonly history: HistoryItem[];
-    disposeCount: number;
-    private state;
-    constructor(adapter: ScriptedHarnessAdapter, params: SessionOpenParams, sink: SessionEventSink);
-    emit(payload: AhpEventPayload, turnId?: string): Promise<void>;
-    execute<M extends SessionMethod>(method: M, params: AhpRequestMap[M]): Promise<AhpResultMap[M]>;
-    dispose(): Promise<void>;
-}
-export declare function createScriptedAdapter(options?: FakeAdapterOptions): ScriptedHarnessAdapter;
-/** Reusable deterministic fixtures for the public runner, including deliberate source faults. */
-export declare function createScriptedConformanceFactory(capabilities?: Capabilities): ConformanceFactory;

package/dist/fake.js

@@ -1,199 +0,0 @@
-// packages/conformance/src/fake.ts
-import {
-  negotiateVersion
-} from "@anureo/protocol";
-import { HarnessSdkError } from "@anureo/sdk";
-var FAKE_CAPABILITIES = {
-  session: { resume: true, fork: ["before", "through"], revert: ["conversation", "files", "both"], history: true },
-  turn: { steer: true, interrupt: true, 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" } }] }
-};
-
-class ScriptedHarnessAdapter {
-  options;
-  calls = [];
-  opened = [];
-  sinks = new Map;
-  backends = new Map;
-  disposeCount = 0;
-  constructor(options = {}) {
-    this.options = options;
-  }
-  get capabilities() {
-    return structuredClone(this.options.capabilities ?? FAKE_CAPABILITIES);
-  }
-  async initialize(params) {
-    negotiateVersion(params.protocolVersions);
-    return { protocolVersion: 1, runtime: { name: "scripted", version: "1.0.0", adapter: "conformance/0.1.0" }, capabilities: this.capabilities };
-  }
-  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);
-    if (params.mode === "fork" && params.fork) {
-      const source = this.backends.get(params.fork.sourceSessionId);
-      if (!source)
-        throw new HarnessSdkError("SESSION_NOT_FOUND");
-      const boundaryIndex = source.history.findIndex((entry) => entry.turnId === params.fork.boundary.turnId);
-      if (boundaryIndex < 0)
-        throw new HarnessSdkError("TURN_NOT_FOUND");
-      const retained = params.fork.boundary.relation === "before" ? boundaryIndex : boundaryIndex + 1;
-      backend.history.push(...structuredClone(source.history.slice(0, retained)));
-    }
-    await this.options.onOpen?.(params, sink);
-    return backend;
-  }
-  async dispose() {
-    this.disposeCount++;
-  }
-}
-
-class ScriptedBackendSession {
-  adapter;
-  sink;
-  binding;
-  capabilities;
-  history = [];
-  disposeCount = 0;
-  state;
-  constructor(adapter, params, 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", config: params.config ?? {}, capabilityRevision: 1 };
-  }
-  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;
-    let result;
-    switch (method) {
-      case "turn/start": {
-        const start = params;
-        await this.emit({ type: "turn/started", payload: { turnId: start.turnId } });
-        const item = { id: "native-reused", type: "agentMessage", text: start.input.filter((part) => part.type === "text").map((part) => part.text).join(`
-`), phase: "final" };
-        await this.emit({ type: "item/started", payload: { item: { ...item, text: "" } } }, start.turnId);
-        await this.emit({ type: "item/delta", payload: { itemId: item.id, kind: "text", text: "preview " } }, start.turnId);
-        await this.emit({ type: "item/completed", payload: { item } }, start.turnId);
-        this.history.push({ turnId: start.turnId, item });
-        await this.emit({ type: "turn/completed", payload: { turnId: start.turnId, status: "completed" } });
-        result = { turnId: start.turnId, accepted: true };
-        break;
-      }
-      case "turn/steer":
-        result = { turnId: params.expectedTurnId, accepted: true };
-        break;
-      case "turn/interrupt": {
-        const id = params.turnId;
-        await this.emit({ type: "turn/completed", payload: { turnId: id, status: "interrupted" } });
-        result = { accepted: true, turnId: id };
-        break;
-      }
-      case "session/config/set":
-        this.state = { ...this.state, config: { ...this.state.config, ...params.patch }, capabilityRevision: this.state.capabilityRevision + 1 };
-        result = this.state;
-        break;
-      case "session/revert": {
-        const request = params;
-        if (request.scope !== "files") {
-          const index = this.history.findIndex((entry) => entry.turnId === request.boundary.turnId);
-          if (index < 0)
-            throw new HarnessSdkError("TURN_NOT_FOUND");
-          this.history.splice(request.boundary.relation === "before" ? index : index + 1);
-        }
-        result = { appliedScope: request.scope, boundary: request.boundary };
-        break;
-      }
-      case "history/read":
-        result = { items: this.history, snapshotToken: "fake-snapshot", source: this.binding.nativeRef };
-        break;
-      case "goal/set":
-        result = { goal: params.goal, status: "active" };
-        break;
-      case "goal/clear":
-        result = { goal: null, status: "cleared" };
-        break;
-      case "compact/start":
-        result = { maintenanceId: "fake-maintenance", status: "completed" };
-        break;
-      case "review/start": {
-        const id = params.turnId;
-        await this.emit({ type: "turn/started", payload: { turnId: id } });
-        await this.emit({ type: "turn/completed", payload: { turnId: id, status: "completed" } });
-        result = { accepted: true, turnId: id };
-        break;
-      }
-      case "session/close":
-        result = { closed: true };
-        break;
-      case "interaction/respond":
-      case "interaction/cancel":
-        throw new Error("Interactions must be handled by the SDK registry");
-    }
-    return result;
-  }
-  async dispose() {
-    this.disposeCount++;
-  }
-}
-function createScriptedAdapter(options) {
-  return new ScriptedHarnessAdapter(options);
-}
-function createScriptedConformanceFactory(capabilities) {
-  return (scenario) => {
-    const adapter = createScriptedAdapter({ capabilities, execute: async (call, sink) => {
-      if (call.method !== "turn/start")
-        return;
-      const { turnId } = call.params;
-      if (["interrupt", "steer", "disconnect", "backpressure"].includes(scenario)) {
-        await sink.emit({ type: "turn/started", payload: { turnId } });
-        if (scenario === "backpressure")
-          sink.tryEmit({ type: "notice", payload: { severity: "info", code: "FLOOD", message: "Conformance overflow" } });
-        return { accepted: true, turnId };
-      }
-      const interaction = {
-        approval: { interactionId: "conformance-approval", kind: "approval", turnId, options: [{ id: "deny", label: "Deny", semantic: "deny" }] },
-        userInput: { interactionId: "conformance-input", kind: "userInput", turnId, questions: [{ id: "q", prompt: "Value" }] },
-        elicitation: { interactionId: "conformance-elicitation", kind: "elicitation", turnId, mode: "form" },
-        dynamicTool: { interactionId: "conformance-tool", kind: "dynamicTool", turnId, toolName: "conformance", arguments: {} }
-      };
-      if (interaction[scenario] || scenario === "unknown-item") {
-        await sink.emit({ type: "turn/started", payload: { turnId } });
-        if (interaction[scenario])
-          await sink.requestInteraction(interaction[scenario], 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 { accepted: true, turnId };
-      }
-      return;
-    } });
-    return {
-      adapter,
-      openParams: { requestId: "conformance-open", mode: "new", binding: { sessionId: "conformance-session", adapterId: "scripted", runtimeConfigId: "conformance-runtime" }, cwd: "/tmp" },
-      ...scenario === "backpressure" ? { runtimeOptions: { queue: { maxEvents: 2 } } } : {},
-      ...scenario === "disconnect" ? { afterStart: async () => {
-        await adapter.sinks.get("conformance-session").fail(new HarnessSdkError("CONNECTION_CLOSED", "Conformance disconnection", false, true));
-      } } : {}
-    };
-  };
-}
-export {
-  FAKE_CAPABILITIES,
-  ScriptedBackendSession,
-  ScriptedHarnessAdapter,
-  createScriptedAdapter,
-  createScriptedConformanceFactory
-};

package/dist/fixtures.d.ts

@@ -1,21 +0,0 @@
-import type { AhpEventPayload, AhpMethod, AhpRequestMap, AhpResultMap } from "@anureo/protocol";
-export type WireFlavor = "codex" | "claude" | "acp" | "ahp";
-export interface NativeFixtureFrame {
-    waitForMethod?: string;
-    emit: ReadonlyArray<Record<string, unknown>>;
-    expectedResponse?: {
-        id: string | number;
-        result: unknown;
-    };
-}
-export interface ConformanceFixture {
-    name: string;
-    flavor: WireFlavor;
-    script: readonly NativeFixtureFrame[];
-    expectedEvents: readonly AhpEventPayload[];
-}
-export type MethodFixture<M extends AhpMethod> = {
-    method: M;
-    request: AhpRequestMap[M];
-    result: AhpResultMap[M];
-};

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./fake.js";
-export * from "./suite.js";
-export * from "./fixtures.js";
-export * from "./fake-claude.js";