@anureo/adapter-hermes 0.0.0-stage → 0.3.0

package/src/events.js

@@ -0,0 +1,274 @@
+import { HarnessSdkError } from '@anureo/sdk';
+import { identity, integer, json, object, protocolError, stableId, text } from "./native.js";
+/**
+ * Publish cumulative session usage for HermesSession.apply and terminal turn projection.
+ * Omit nonfinite or negative counters and await sink publication.
+ */
+export async function sessionUsage(sink, payload) {
+    const usage = { provider: 'hermes', source: 'native', scope: 'session' };
+    const fields = { input: 'input', output: 'output', total: 'total', context_max: 'contextWindow', context_used: 'contextUsed' };
+    for (const [native, target] of Object.entries(fields)) {
+        const value = payload[native];
+        if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
+            usage[target] = value;
+    }
+    await sink.emit({ type: 'usage/updated', payload: usage });
+}
+/**
+ * Internal execution projection created by HermesSession.turn. Publish ordered SDK items through
+ * its sink, retaining bounded provisional state until native terminal evidence arrives. Native
+ * snapshots complete items; deltas only describe provisional progress. Sink failures reject to the
+ * session's receipt or event path; the session owns recovery and channel disposal.
+ */
+export class HermesTurn {
+    /** SDK identity shared by submission bindings, events and interrupt targeting. */
+    id;
+    /** Durable native admission used to reconcile this execution after reconnect. */
+    admissionId;
+    /** Native authority paired with generation; HermesSession checks both when reusing this execution. */
+    epoch;
+    /** Native execution generation within this authority, used to fence interrupt requests. */
+    generation;
+    /** Set before publishing turn/started to suppress duplicate starts during association and event delivery. */
+    started = false;
+    /** Set before turn/completed publication. HermesSession uses it to stop treating this turn as active. */
+    terminal = false;
+    /** Set with terminal evidence before turn/completed publication, and retained after item content is released. */
+    status;
+    /** Accept validated native execution identity and derive a local turn id stable across replay. */
+    constructor({ admissionId, epoch, generation, sessionId, sink, options }) {
+        this.admissionId = admissionId;
+        this.epoch = epoch;
+        this.generation = generation;
+        this.sink = sink;
+        this.options = options;
+        this.id = `hermes-${stableId(sessionId, admissionId)}`;
+    }
+    /** Publish turn/started at most once, before any binding or item publication. */
+    async start() {
+        if (this.started)
+            return;
+        this.started = true;
+        await this.sink.emit({ type: 'turn/started', payload: { turnId: this.id, nativeTurnId: this.admissionId } });
+    }
+    /** HermesSession.associate binds native-claimed input once; late binding of a terminal turn adds no user item. */
+    async bind(submissionId, input) {
+        await this.start();
+        if (this.submissions.has(submissionId))
+            return;
+        this.submissions.add(submissionId);
+        await this.sink.bindSubmission(submissionId, this.id);
+        if (this.terminal)
+            return;
+        // Native admission/claim is the evidence that this input belongs to this execution.
+        await this.complete({ id: `${this.id}:user:${stableId(submissionId)}`, type: 'userMessage', content: [{ type: 'text', text: input }], status: 'completed' });
+    }
+    /** Report incomplete progress once and stop appending to the current partial segment; native snapshots can still replace its text. */
+    async gap() {
+        if (this.terminal || this.gapReported)
+            return;
+        this.gapReported = true;
+        await this.start();
+        if (this.current)
+            this.current.incomplete = true;
+        await this.complete({ id: `${this.id}:gap`, type: 'notice', severity: 'warning', code: 'HERMES_PROGRESS_GAP',
+            text: 'Some intermediate Hermes progress was unavailable; the final answer requires native terminal evidence.', status: 'completed' });
+    }
+    /** Project the event supplied by HermesSession.applyTurnEvent. Ignore terminal replays and reject malformed payloads or sink failures. */
+    async apply(event) {
+        if (this.terminal)
+            return;
+        await this.start();
+        switch (event.type) {
+            case 'message.delta':
+                await this.messageDelta(event.payload);
+                return;
+            case 'message.interim':
+                await this.messageInterim(event.payload);
+                return;
+            case 'reasoning.delta':
+                await this.reasoningDelta(event.payload);
+                return;
+            case 'tool.start':
+            case 'tool.complete':
+                await this.toolEvent(event.type, event.payload);
+                return;
+            case 'message.complete': await this.messageComplete(event.payload);
+        }
+    }
+    /**
+     * HermesSession.associate supplies receipt-only terminal evidence after reconnect or submit.
+     * Mark unavailable intermediate progress, then publish the final response; unsupported outcomes or
+     * non-string final_response reject as protocol errors. Missing final_response means empty text.
+     */
+    async fromReceipt(result, outcome) {
+        if (this.terminal)
+            return;
+        const status = outcome === 'completed' ? 'completed' : outcome === 'interrupted' || outcome === 'cancelled' ? 'interrupted' : outcome === 'failed' ? 'failed' : undefined;
+        if (!status || result.final_response !== undefined && typeof result.final_response !== 'string')
+            throw protocolError();
+        await this.gap();
+        await this.finish(status, typeof result.final_response === 'string' ? result.final_response : '', result);
+    }
+    items = new Map();
+    completed = new Set();
+    submissions = new Set();
+    segment = 0;
+    current;
+    lastText = '';
+    reasoning = '';
+    bytes = 0;
+    gapReported = false;
+    /** Replace streamed commentary with the native snapshot and seal the segment unless it is stale. */
+    async messageInterim(payload) {
+        const body = text(payload.text);
+        if (payload.segment !== undefined && integer(payload.segment) < this.segment)
+            return;
+        if (!this.current)
+            this.current = { item: { id: `${this.id}:message:${this.segment}`, type: 'agentMessage', text: body, phase: 'commentary' }, incomplete: false };
+        else
+            this.current.item = { ...this.current.item, text: body };
+        await this.commentary();
+    }
+    /** Retain the accumulated reasoning summary while publishing only the new chunk as a delta. */
+    async reasoningDelta(payload) {
+        const chunk = text(payload.text);
+        this.reasoning += chunk;
+        const item = { id: `${this.id}:reasoning`, type: 'reasoning', summary: this.reasoning };
+        if (!this.items.has(item.id))
+            await this.put({ ...item, summary: '' });
+        await this.put(item);
+        await this.sink.emit({ type: 'item/delta', payload: { itemId: item.id, kind: 'reasoningSummary', text: chunk } }, { turnId: this.id });
+    }
+    /**
+     * Project both tool phases under one native identity. Ignore duplicate starts, retain prior input
+     * when completion omits it, and convert native duration seconds to SDK milliseconds.
+     */
+    async toolEvent(type, payload) {
+        const id = `${this.id}:tool:${identity(payload.tool_id)}`;
+        if (type === 'tool.start' && this.items.has(id))
+            return;
+        const name = identity(payload.name);
+        const prior = this.items.get(id);
+        const item = { ...(prior?.type === 'toolCall' ? prior : {}), id, type: 'toolCall', kind: 'other',
+            title: name, toolName: name, nativeType: name,
+            ...(payload.args !== undefined ? { input: json(payload.args) } : {}) };
+        if (type === 'tool.start') {
+            await this.put(item);
+            return;
+        }
+        await this.complete({ ...item, status: 'completed',
+            ...(payload.result !== undefined ? { output: json(payload.result) } : typeof payload.result_text === 'string' ? { output: payload.result_text } : {}),
+            ...(typeof payload.duration_s === 'number' && payload.duration_s >= 0 ? { durationMs: payload.duration_s * 1000 } : {}),
+        });
+    }
+    /** Require a recognized terminal status. Use retained text only when both native text fields are absent or null. */
+    async messageComplete(payload) {
+        const status = payload.status === 'complete' ? 'completed' : payload.status === 'interrupted' ? 'interrupted' : payload.status === 'error' ? 'failed' : undefined;
+        if (!status)
+            throw protocolError();
+        const value = payload.text ?? payload.content;
+        if (value != null && typeof value !== 'string')
+            throw protocolError();
+        await this.finish(status, value == null ? this.current?.item.text ?? this.lastText : value, payload);
+    }
+    /** Retain a detached item within count/byte budgets and publish item/started only on first appearance. */
+    async put(item) {
+        const previous = this.items.get(item.id);
+        const bytes = Buffer.byteLength(JSON.stringify(item));
+        const total = this.bytes - (previous ? Buffer.byteLength(JSON.stringify(previous)) : 0) + bytes;
+        if (total > (this.options.maxBufferedBytes ?? 16 * 1024 * 1024) || !previous && this.items.size >= 2048)
+            throw new HarnessSdkError('BACKPRESSURE_EXCEEDED');
+        this.items.set(item.id, structuredClone(item));
+        this.bytes = total;
+        if (!previous)
+            await this.sink.emit({ type: 'item/started', payload: { item: { ...item, status: 'running' } } }, { turnId: this.id });
+    }
+    /** Publish item completion at most once per id, starting an unseen item first. */
+    async complete(item) {
+        if (this.completed.has(item.id))
+            return;
+        await this.put(item);
+        this.completed.add(item.id);
+        await this.sink.emit({ type: 'item/completed', payload: { item } }, { turnId: this.id });
+    }
+    /** Seal the current commentary segment and retain its text as the fallback when a terminal frame omits text. */
+    async commentary() {
+        if (!this.current)
+            return;
+        this.lastText = this.current.item.text;
+        await this.complete({ ...this.current.item, phase: 'commentary', status: 'completed' });
+        this.current = undefined;
+        this.segment++;
+    }
+    /** Reconcile UTF-16 text offsets within a commentary segment; conflicting overlap rejects and a missing prefix marks a gap. */
+    async messageDelta(payload) {
+        if (payload.text === null) {
+            await this.commentary();
+            return;
+        }
+        let chunk = text(payload.text);
+        if (payload.segment !== undefined) {
+            const next = integer(payload.segment);
+            if (next < this.segment)
+                return;
+            if (next > this.segment) {
+                await this.commentary();
+                this.segment = next;
+            }
+        }
+        if (!this.current) {
+            this.current = { item: { id: `${this.id}:message:${this.segment}`, type: 'agentMessage', text: '', phase: 'commentary' }, incomplete: false };
+            await this.put(this.current.item);
+        }
+        const current = this.current;
+        if (current.incomplete)
+            return;
+        const offset = payload.offset === undefined ? current.item.text.length : integer(payload.offset);
+        if (offset > current.item.text.length) {
+            await this.gap();
+            return;
+        }
+        if (offset < current.item.text.length) {
+            const overlap = Math.min(chunk.length, current.item.text.length - offset);
+            if (current.item.text.slice(offset, offset + overlap) !== chunk.slice(0, overlap))
+                throw protocolError();
+            chunk = chunk.slice(overlap);
+        }
+        if (!chunk)
+            return;
+        current.item = { ...current.item, text: current.item.text + chunk };
+        await this.put(current.item);
+        await this.sink.emit({ type: 'item/delta', payload: { itemId: current.item.id, kind: 'text', text: chunk } }, { turnId: this.id });
+    }
+    /** Complete final/reasoning items before terminal publication, flag unfinished native items and release retained content after success. */
+    async finish(status, body, payload) {
+        await this.start();
+        const id = this.current?.item.id ?? `${this.id}:final`;
+        await this.complete({ id, type: 'agentMessage', text: body, phase: 'final', status: status === 'completed' ? 'completed' : status });
+        if (typeof payload.reasoning === 'string')
+            this.reasoning = payload.reasoning;
+        if (this.reasoning)
+            await this.complete({ id: `${this.id}:reasoning`, type: 'reasoning', summary: this.reasoning, status: 'completed' });
+        for (const item of this.items.values())
+            if (!this.completed.has(item.id)) {
+                await this.gap();
+                await this.complete({ ...item, extensions: { ...item.extensions, nativeResultUnavailable: true } });
+            }
+        if (payload.usage != null)
+            await sessionUsage(this.sink, object(payload.usage));
+        this.terminal = true;
+        this.status = status;
+        await this.sink.emit({ type: 'turn/completed', payload: { turnId: this.id, status,
+                ...(status === 'failed' ? { error: { code: 'HERMES_TURN_FAILED', message: 'Hermes turn failed', retryable: false, outcomeUnknown: false } } : {}) } });
+        // Core retains completed results; the mapper retains only identity and control evidence.
+        this.items.clear();
+        this.completed.clear();
+        this.current = undefined;
+        this.reasoning = '';
+        this.lastText = '';
+        this.bytes = 0;
+    }
+    sink;
+    options;
+}

package/src/index.d.ts

@@ -0,0 +1,81 @@
+import { type HarnessAdapter, type SessionEventSink } from '@anureo/sdk';
+import { type InitializeParams, type InitializeResult, type SessionOpenParams } from '@anureo/protocol';
+import { HermesSession } from "./session.js";
+import { type HermesAdapterOptions } from "./options.js";
+export type { HermesAdapterOptions } from "./options.js";
+/**
+ * Connect SDK clients to a shared Hermes gateway owner. Pass this adapter to createClient, which
+ * initializes and disposes it through the SDK's output wrapper. Direct port consumers must await
+ * initialize before opening sessions and dispose the adapter when finished; disposal ends local
+ * observation without stopping the shared owner or its executions.
+ */
+export declare class HermesAdapter implements HarnessAdapter {
+    /** Configuration for subsequent native work. Argument, toolset and environment containers are copied at construction. */
+    readonly options: HermesAdapterOptions;
+    /** Validate and copy configuration without native I/O; invalid options throw INVALID_PARAMS. */
+    constructor(options?: HermesAdapterOptions);
+    /** Return 'http' to OutputSession.open for a new editor-capable session, or undefined when the bridge is unavailable. */
+    outputBridgeTransport(params: SessionOpenParams): 'http' | undefined;
+    /**
+     * Negotiate the SDK protocol and describe the ticketed Hermes owner without creating a session.
+     * Cache the first native probe promise, including failure, and release its channel after description.
+     * Request validation/version errors throw synchronously; disposed adapters return a rejected promise,
+     * and attachment, description or concurrent disposal failures reject the probe.
+     */
+    initialize(params: InitializeParams): Promise<InitializeResult>;
+    /**
+     * Open a new or resumed native observation after initialization. OutputSession.open supplies the
+     * forwarding sink and owns the returned backend; callbacks can publish before this resolves.
+     * Reject invalid requests, unsupported options, binding mismatches or setup failure, disposing
+     * partial sessions first. Direct port consumers own cleanup of the returned observation.
+     */
+    openSession(params: SessionOpenParams, sink: SessionEventSink): Promise<HermesSession>;
+    /**
+     * Abort attachment and close local channels without stopping native work. The first call awaits
+     * tracked session disposal. To observe completion of an in-flight initialization, await its own
+     * promise, which can remain pending while the attach child is disposed. Later disposal calls return immediately.
+     */
+    dispose(): Promise<void>;
+    private initialized?;
+    private profileId?;
+    private editorMcp;
+    private disposed;
+    private readonly abort;
+    private probe?;
+    private readonly sessions;
+    /**
+     * Own the temporary channel for initialize. Ignore probe events and reject server requests once
+     * the channel is available. Publish the profile and editor support only after a validated
+     * description, then close the probe on either outcome. Description failures have a known outcome
+     * because the probe never submits work.
+     */
+    private probeRuntime;
+    /** Reject unsupported features and foreign resume bindings before openSession acquires resources. */
+    private assertSupportedOpen;
+}
+/**
+ * Create a Hermes adapter for createClient. Configuration is validated synchronously and invalid
+ * options throw INVALID_PARAMS. Native attachment starts on initialization. Dispose the returned
+ * client when finished. createClient releases the adapter if client initialization fails.
+ *
+ * @example
+ * With the Hermes CLI on PATH and a configured default profile:
+ *
+ * ```ts
+ * import { createHermesAdapter } from '@anureo/adapter-hermes'
+ * import { createClient } from '@anureo/sdk'
+ *
+ * const client = await createClient({
+ *   adapter: createHermesAdapter(),
+ *   identity: { adapterId: 'hermes', runtimeConfigId: 'default' },
+ * })
+ * try {
+ *   const session = await client.sessions.create({ cwd: process.cwd() })
+ *   const turn = await session.submit({ input: 'Summarize this workspace.' })
+ *   console.log(await turn.result())
+ * } finally {
+ *   await client.dispose()
+ * }
+ * ```
+ */
+export declare function createHermesAdapter(options?: HermesAdapterOptions): HermesAdapter;

package/src/index.js

@@ -0,0 +1,169 @@
+import { HarnessSdkError } from '@anureo/sdk';
+import { AHP_PROTOCOL_CONTRACT, assertRequest, negotiateVersion } from '@anureo/protocol';
+import { attachGateway } from "./attach.js";
+import { describe } from "./native.js";
+import { HermesRpc } from "./rpc.js";
+import { HermesSession, hermesCapabilities } from "./session.js";
+import { validateOptions } from "./options.js";
+/**
+ * Connect SDK clients to a shared Hermes gateway owner. Pass this adapter to createClient, which
+ * initializes and disposes it through the SDK's output wrapper. Direct port consumers must await
+ * initialize before opening sessions and dispose the adapter when finished; disposal ends local
+ * observation without stopping the shared owner or its executions.
+ */
+export class HermesAdapter {
+    /** Configuration for subsequent native work. Argument, toolset and environment containers are copied at construction. */
+    options;
+    /** Validate and copy configuration without native I/O; invalid options throw INVALID_PARAMS. */
+    constructor(options = {}) {
+        try {
+            validateOptions(options);
+        }
+        catch {
+            throw new HarnessSdkError('INVALID_PARAMS', 'Invalid Hermes adapter options');
+        }
+        this.options = { ...options, ...(options.toolsets ? { toolsets: [...options.toolsets] } : {}), ...(options.args ? { args: [...options.args] } : {}), ...(options.env ? { env: { ...options.env } } : {}) };
+    }
+    /** Return 'http' to OutputSession.open for a new editor-capable session, or undefined when the bridge is unavailable. */
+    outputBridgeTransport(params) {
+        return this.editorMcp && params.mode === 'new' ? 'http' : undefined;
+    }
+    /**
+     * Negotiate the SDK protocol and describe the ticketed Hermes owner without creating a session.
+     * Cache the first native probe promise, including failure, and release its channel after description.
+     * Request validation/version errors throw synchronously; disposed adapters return a rejected promise,
+     * and attachment, description or concurrent disposal failures reject the probe.
+     */
+    initialize(params) {
+        if (this.disposed)
+            return Promise.reject(new HarnessSdkError('RUNTIME_DISPOSED'));
+        assertRequest('initialize', params);
+        negotiateVersion(params.protocolVersions);
+        return this.initialized ??= this.probeRuntime();
+    }
+    /**
+     * Open a new or resumed native observation after initialization. OutputSession.open supplies the
+     * forwarding sink and owns the returned backend; callbacks can publish before this resolves.
+     * Reject invalid requests, unsupported options, binding mismatches or setup failure, disposing
+     * partial sessions first. Direct port consumers own cleanup of the returned observation.
+     */
+    async openSession(params, sink) {
+        if (this.disposed)
+            throw new HarnessSdkError('RUNTIME_DISPOSED');
+        if (!this.profileId)
+            throw new HarnessSdkError('NOT_INITIALIZED');
+        assertRequest('session/open', params);
+        this.assertSupportedOpen(params);
+        const session = new HermesSession({ params, sink, options: this.options, profileId: this.profileId, released: () => this.sessions.delete(session) });
+        this.sessions.add(session);
+        try {
+            await session.open();
+            if (this.disposed)
+                throw new HarnessSdkError('RUNTIME_DISPOSED');
+            return session;
+        }
+        catch (cause) {
+            await session.dispose();
+            throw cause;
+        }
+    }
+    /**
+     * Abort attachment and close local channels without stopping native work. The first call awaits
+     * tracked session disposal. To observe completion of an in-flight initialization, await its own
+     * promise, which can remain pending while the attach child is disposed. Later disposal calls return immediately.
+     */
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.abort.abort();
+        this.probe?.dispose();
+        await Promise.all([...this.sessions].map(value => value.dispose()));
+        this.sessions.clear();
+    }
+    initialized;
+    profileId;
+    editorMcp = false;
+    disposed = false;
+    abort = new AbortController();
+    probe;
+    sessions = new Set();
+    /**
+     * Own the temporary channel for initialize. Ignore probe events and reject server requests once
+     * the channel is available. Publish the profile and editor support only after a validated
+     * description, then close the probe on either outcome. Description failures have a known outcome
+     * because the probe never submits work.
+     */
+    async probeRuntime() {
+        const grant = await attachGateway(this.options, this.options.startup ?? 'start', this.abort.signal);
+        let channel;
+        channel = await HermesRpc.connect(grant, {
+            event: async () => { },
+            request: async (request) => { await channel?.reject(request.id); },
+            failure: () => { },
+        }, this.options, this.abort.signal);
+        if (this.disposed) {
+            channel.dispose();
+            throw new HarnessSdkError('RUNTIME_DISPOSED');
+        }
+        this.probe = channel;
+        try {
+            const description = describe(await channel.request('runtime.describe'), grant);
+            if (this.disposed)
+                throw new HarnessSdkError('RUNTIME_DISPOSED');
+            this.profileId = description.profileId;
+            this.editorMcp = description.editorMcp;
+            return {
+                protocolVersion: 1,
+                protocolContract: AHP_PROTOCOL_CONTRACT,
+                runtime: { name: 'hermes', version: grant.version, adapter: 'hermes-gateway/0.2.0' },
+                capabilities: hermesCapabilities(),
+            };
+        }
+        catch (cause) {
+            if (cause instanceof HarnessSdkError)
+                throw new HarnessSdkError(cause.code, cause.message, cause.retryable, false);
+            throw new HarnessSdkError('PROTOCOL_ERROR', 'Invalid Hermes gateway description');
+        }
+        finally {
+            channel.dispose();
+            if (this.probe === channel)
+                this.probe = undefined;
+        }
+    }
+    /** Reject unsupported features and foreign resume bindings before openSession acquires resources. */
+    assertSupportedOpen(params) {
+        if (params.mode === 'fork' || params.instructions !== undefined || params.permissionMode !== undefined
+            || (params.mcpServers !== undefined && (!this.editorMcp || params.mode !== 'new'))
+            || Object.keys(params.config ?? {}).length)
+            throw new HarnessSdkError('CAPABILITY_UNSUPPORTED');
+        if (params.mode === 'resume' && params.binding.nativeRef?.provider !== 'hermes')
+            throw new HarnessSdkError('SESSION_BINDING_MISMATCH');
+    }
+}
+/**
+ * Create a Hermes adapter for createClient. Configuration is validated synchronously and invalid
+ * options throw INVALID_PARAMS. Native attachment starts on initialization. Dispose the returned
+ * client when finished. createClient releases the adapter if client initialization fails.
+ *
+ * @example
+ * With the Hermes CLI on PATH and a configured default profile:
+ *
+ * ```ts
+ * import { createHermesAdapter } from '@anureo/adapter-hermes'
+ * import { createClient } from '@anureo/sdk'
+ *
+ * const client = await createClient({
+ *   adapter: createHermesAdapter(),
+ *   identity: { adapterId: 'hermes', runtimeConfigId: 'default' },
+ * })
+ * try {
+ *   const session = await client.sessions.create({ cwd: process.cwd() })
+ *   const turn = await session.submit({ input: 'Summarize this workspace.' })
+ *   console.log(await turn.result())
+ * } finally {
+ *   await client.dispose()
+ * }
+ * ```
+ */
+export function createHermesAdapter(options = {}) { return new HermesAdapter(options); }

package/src/interactions.d.ts

@@ -0,0 +1,83 @@
+import { type SessionEventSink } from '@anureo/sdk';
+import { type NativeObject } from "./native.js";
+import type { HermesAdapterOptions } from "./options.js";
+import type { HermesRpc, ServerRequest } from "./rpc.js";
+/**
+ * Internal interaction registry owned by HermesSession. Map replayed prompts and gateway requests
+ * to stable SDK interaction ids without blocking the serial reader on user answers. The two native
+ * mechanisms share this registry but retain their different acknowledgement semantics. The SDK
+ * Session owns handler cancellation and answer privacy. HermesSession owns channel cleanup and recovery.
+ */
+export declare class HermesInteractions {
+    /** Capture callbacks supplied by HermesSession; resolve identity/channel lazily so pending answers use the recovered connection. */
+    constructor({ sessionId, rpc, sink, turnId, epoch, options }: {
+        sessionId: () => string;
+        rpc: () => HermesRpc;
+        sink: SessionEventSink;
+        /** Resolve a generation only in the session's current authority epoch. */
+        turnId: (generation: number) => string | undefined;
+        epoch: () => number;
+        options: HermesAdapterOptions;
+    });
+    /**
+     * Register an approval/clarification from HermesSession.apply or snapshot, ignoring replayed ids.
+     * Invalid prompts and a full registry reject registration. The sink can invoke the responder with
+     * an answer or null, which sends a denial or empty clarification. Delivery checks the current
+     * authority before sending once and requires a native ACK for the same prompt id. The sink
+     * observes delivery failures through the responder.
+     */
+    prompt(value: NativeObject): Promise<void>;
+    /**
+     * Register session-scoped srq requests from HermesSession's live or held traffic, or from snapshot.
+     * Reply with a native error for unsupported requests and reject malformed supported payloads.
+     * The sink owns the wait for answers. The responder resolves after local send, so snapshot checks
+     * whether a finished delivery still appears open remotely.
+     */
+    serverRequest(request: ServerRequest): Promise<void>;
+    /** Let deliveries already in flight settle before HermesSession.applyTurnEvent projects a terminal frame. The sink handles their outcomes. */
+    waitResponders(): Promise<void>;
+    /**
+     * Handle peer settlement from HermesSession.apply or withdrawal from snapshot. Match prompt
+     * generations to fence reused ids and leave in-flight delivery to its own settlement path.
+     * Publish an unknown outcome for a bare native resolved signal because it carries no answer.
+     * Sink publication failures reject to the caller.
+     */
+    settled(target: InteractionTarget, reason: string): Promise<void>;
+    /**
+     * HermesSession.snapshot reconciles open native questions before releasing held traffic. Withdraw
+     * missing questions and register new ones; reject RESULT_UNKNOWN if a locally finished delivery is
+     * still open remotely, preventing silent suppression or replay of a possibly delivered secret.
+     */
+    snapshot(prompts: unknown[], requests: unknown[]): Promise<void>;
+    private readonly pending;
+    /** Parse a nonempty clarify batch with distinct native question ids so one answer can be sent per id. */
+    private batchQuestions;
+    /** Normalize optional native choices; null, omission and an empty array all leave the question open-ended. */
+    private question;
+    /** Encode SDK answers for Hermes text fields; unanswered/null values become empty text and string selections are comma-separated. */
+    private answer;
+    /**
+     * Admit within registry budgets and register the responder with the SDK sink. Session invokes it
+     * for unsupported or closed requests, and InteractionRegistry invokes it for answers and
+     * cancellations. Mark delivery in flight before writing so native settlement can defer to it.
+     * Observe fulfillment and rejection as local completion without blocking the reader on the user.
+     */
+    private register;
+    private readonly sessionId;
+    private readonly rpc;
+    private readonly sink;
+    private readonly turnId;
+    private readonly epoch;
+    private readonly options;
+}
+/** Preserve the native identity needed to match settlement, including the generation for prompts. */
+type InteractionTarget = {
+    wire: 'prompt';
+    nativeId: string;
+    generation: number;
+} | {
+    wire: 'request';
+    nativeId: string;
+    generation?: never;
+};
+export {};