@harapter/adapter-openclaw 0.1.1

package/dist/adapter.js

@@ -0,0 +1,1205 @@
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ExtensionRegistry, HarnessError, assertSessionCompatibility, assertSessionOwnership, providerSessionId, runId, } from '@harapter/core';
+import { AcpClient, AcpClientError, } from '@harapter/transport-acp';
+import { JsonRpcRemoteError, JsonRpcTransportError, } from '@harapter/transport-jsonrpc-stdio';
+import { OPENCLAW_OBSERVATION_EXTENSION, OPENCLAW_PROVIDER_ID, OPENCLAW_SESSION_COMPATIBILITY_REF, mapOpenClawSessionUpdate, openClawCompatibilityIdentity, parseOpenClawRuntime, prepareOpenClawPrompt, redactOpenClawObservation, } from './protocol.js';
+const descriptor = {
+    providerId: OPENCLAW_PROVIDER_ID,
+    displayName: 'OpenClaw ACP Gateway',
+    connectionKinds: ['process'],
+    documentationUrl: 'https://docs.openclaw.ai/cli/acp',
+};
+const defaultOperationTimeoutMs = 30_000;
+const defaultCancelSettlementTimeoutMs = 10_000;
+const defaultMaxRunEvents = 128;
+const maximumRunEvents = 4_096;
+const maximumTimerMilliseconds = 2_147_483_647;
+const childTerminationTimeoutMs = 2_000;
+const forbiddenRoutingArguments = [
+    '--require-existing',
+    '--reset-session',
+    '--session',
+    '--session-label',
+];
+/** Create a fresh OpenClaw ACP Provider Adapter factory. */
+export function createOpenClawProviderFactory() {
+    return {
+        descriptor: () => ({
+            ...descriptor,
+            connectionKinds: [...descriptor.connectionKinds],
+        }),
+        connect: async (profile) => connectOpenClaw(profile),
+    };
+}
+async function connectOpenClaw(profile) {
+    validateProfile(profile);
+    const options = connectionOptions(profile.providerOptions, profile);
+    let connected;
+    let acp;
+    try {
+        acp = await spawnAcp(profile, options.acp, (request) => connected?.requestPermission(request) ?? { outcome: 'cancelled' });
+    }
+    catch (error) {
+        throw mapError(error, profile, 'spawn', true);
+    }
+    try {
+        const initialized = await acp.initialize({
+            clientInfo: {
+                name: 'harapter',
+                title: 'Harapter',
+                version: '0.0.0',
+            },
+        }, { timeoutMs: options.operationTimeoutMs });
+        const runtime = parseOpenClawRuntime(initialized);
+        connected = new OpenClawClient(snapshotProfile(profile), acp, runtime, options);
+        connected.startPump();
+        return connected;
+    }
+    catch (error) {
+        await acp.close().catch(() => undefined);
+        throw mapError(error, profile, 'initialize', true);
+    }
+}
+class OpenClawClient {
+    profile;
+    acp;
+    runtime;
+    options;
+    extensionRegistry = new ExtensionRegistry(OPENCLAW_PROVIDER_ID);
+    nativeClient;
+    observationListeners = new Set();
+    unknownListeners = new Set();
+    sessions = new Map();
+    sessionReservations = new Set();
+    pendingApprovals = new Map();
+    activeRun;
+    approvalObserved = false;
+    closed = false;
+    closePromise;
+    interactionSerial = 0;
+    runSerial = 0;
+    constructor(profile, acp, runtime, options) {
+        this.profile = profile;
+        this.acp = acp;
+        this.runtime = runtime;
+        this.options = options;
+        const observer = Object.freeze({
+            onObservation: (listener) => {
+                this.observationListeners.add(listener);
+                return () => this.observationListeners.delete(listener);
+            },
+        });
+        this.extensionRegistry.register({
+            name: OPENCLAW_OBSERVATION_EXTENSION,
+            providerId: OPENCLAW_PROVIDER_ID,
+            displayName: 'OpenClaw ACP observation channel',
+            description: 'Bounded, redacted unknown ACP observations.',
+            documentationUrl: 'https://docs.openclaw.ai/cli/acp',
+            stability: 'experimental',
+        }, observer);
+        this.nativeClient = Object.freeze({
+            runtimeIdentity: this.runtimeIdentity(),
+            requestExtension: (method, params, requestOptions) => this.acp.requestExtension(method, params, requestOptions),
+            notifyExtension: (method, params) => this.acp.notifyExtension(method, params),
+            onUnknownEvent: (listener) => {
+                this.unknownListeners.add(listener);
+                return () => this.unknownListeners.delete(listener);
+            },
+        });
+    }
+    descriptor() {
+        return Promise.resolve({
+            providerId: OPENCLAW_PROVIDER_ID,
+            profileId: this.profile.profileId,
+            displayName: this.profile.displayName,
+            connectionKind: 'process',
+            runtime: {
+                name: this.runtime.name,
+                version: this.runtime.version,
+                protocol: 'ACP over stdio JSON-RPC 2.0',
+                protocolVersion: '1',
+            },
+            compatibility: 'supported',
+        });
+    }
+    capabilities() {
+        return Promise.resolve(this.capabilityManifest());
+    }
+    async createSession(input = {}) {
+        this.assertOpen();
+        const cwd = prepareSessionInput(input, this.profile);
+        const sessionKey = `acp-bridge:harapter-${randomUUID()}`;
+        try {
+            const created = await this.acp.newSession({
+                cwd,
+                mcpServers: [],
+                _meta: { sessionKey },
+            }, { timeoutMs: this.options.operationTimeoutMs });
+            const sessionId = providerSessionId(created.sessionId);
+            this.assertSessionReusable(sessionId);
+            const session = new OpenClawSession(this, sessionId, {
+                strategy: 'isolated',
+                sessionKey,
+                cwd,
+            });
+            this.sessions.set(sessionId, session);
+            return session;
+        }
+        catch (error) {
+            throw this.operationError(error, 'create Session', 'session_create_uncertain');
+        }
+    }
+    async resumeSession(ref) {
+        this.assertOpen();
+        assertSessionOwnership(ref, OPENCLAW_PROVIDER_ID, this.profile.profileId);
+        assertSessionCompatibility(ref, OPENCLAW_SESSION_COMPATIBILITY_REF);
+        const state = sessionStateFromRef(ref);
+        this.reserveSession(ref.providerSessionId);
+        try {
+            await this.acp.resumeSession({
+                sessionId: ref.providerSessionId,
+                cwd: state.cwd,
+                _meta: {
+                    sessionKey: state.sessionKey,
+                    requireExisting: true,
+                },
+            }, { timeoutMs: this.options.operationTimeoutMs });
+            const session = new OpenClawSession(this, ref.providerSessionId, state);
+            this.sessions.set(ref.providerSessionId, session);
+            this.sessionReservations.delete(ref.providerSessionId);
+            return session;
+        }
+        catch (error) {
+            this.sessionReservations.delete(ref.providerSessionId);
+            throw this.operationError(error, 'resume Session', 'session_resume_uncertain');
+        }
+    }
+    extensions() {
+        return this.extensionRegistry;
+    }
+    native(guard) {
+        const value = this.nativeClient;
+        return guard !== undefined && !guard(value) ? undefined : value;
+    }
+    close() {
+        this.closePromise ??= this.closeOnce('client_closed');
+        return this.closePromise;
+    }
+    startPump() {
+        void this.pump();
+    }
+    sessionRef(sessionId, state) {
+        return {
+            providerId: OPENCLAW_PROVIDER_ID,
+            profileId: this.profile.profileId,
+            providerSessionId: sessionId,
+            compatibilityRef: OPENCLAW_SESSION_COMPATIBILITY_REF,
+            providerState: { ...state },
+        };
+    }
+    capabilityManifest() {
+        return openClawCapabilities(this.profile, this.runtime.capabilities, this.runtimeIdentity(), this.approvalObserved);
+    }
+    hasActiveRun(sessionId) {
+        return (this.activeRun !== undefined &&
+            (sessionId === undefined || this.activeRun.ref().sessionId === sessionId));
+    }
+    startRun(sessionId, input, options = {}) {
+        this.assertOpen();
+        if (this.activeRun !== undefined) {
+            throw new HarnessError('run_conflict', 'OpenClaw ACP allows one active Harapter Run per connection.', {
+                retryable: false,
+                providerId: OPENCLAW_PROVIDER_ID,
+                profileId: this.profile.profileId,
+            });
+        }
+        validateRunOptions(options);
+        const prompt = prepareOpenClawPrompt(input, {
+            image: this.runtime.capabilities.prompt.image,
+        });
+        const run = new OpenClawRun({
+            providerId: OPENCLAW_PROVIDER_ID,
+            profileId: this.profile.profileId,
+            sessionId,
+            runId: runId(`openclaw-run-${String(++this.runSerial)}`),
+        }, this.options.maxRunEvents, options.timeoutMs, this.options.cancelSettlementTimeoutMs, () => this.acp.cancelSession(sessionId), (reason) => {
+            this.abortConnection(reason);
+        }, (terminal) => {
+            this.settleApprovals(terminal);
+            if (this.activeRun === terminal)
+                this.activeRun = undefined;
+        });
+        this.activeRun = run;
+        void this.acp
+            .prompt({ sessionId, prompt })
+            .then((result) => {
+            run.finishPrompt(result.stopReason);
+        })
+            .catch((error) => {
+            this.failPrompt(run, error);
+        });
+        return Promise.resolve(run);
+    }
+    respond(sessionId, requestId, response) {
+        this.assertOpen();
+        const pending = this.pendingApprovals.get(requestId);
+        if (pending?.run.ref().sessionId !== sessionId ||
+            response.kind !== 'approval') {
+            throw new HarnessError('invalid_request', 'OpenClaw interaction response does not match an active approval.', {
+                retryable: false,
+                providerId: OPENCLAW_PROVIDER_ID,
+                profileId: this.profile.profileId,
+            });
+        }
+        const option = selectPermissionOption(pending.request.options, response);
+        this.pendingApprovals.delete(requestId);
+        pending.run.resolveInteraction(requestId, response.decision);
+        pending.settle({ outcome: 'selected', optionId: option.optionId });
+        return Promise.resolve();
+    }
+    async closeSession(session) {
+        const sessionId = session.ref().providerSessionId;
+        if (!this.sessions.has(sessionId))
+            return;
+        if (this.hasActiveRun(sessionId)) {
+            throw new HarnessError('run_conflict', 'Cannot close an OpenClaw Session with an active Run.', {
+                retryable: false,
+                providerId: OPENCLAW_PROVIDER_ID,
+                profileId: this.profile.profileId,
+            });
+        }
+        this.assertOpen();
+        this.sessionReservations.add(sessionId);
+        try {
+            await this.acp.closeSession(sessionId, {
+                timeoutMs: this.options.operationTimeoutMs,
+            });
+            this.sessions.delete(sessionId);
+        }
+        catch (error) {
+            throw this.operationError(error, 'close Session', 'session_close_uncertain');
+        }
+        finally {
+            this.sessionReservations.delete(sessionId);
+        }
+    }
+    requestPermission(request) {
+        const run = this.activeRun;
+        if (this.closed ||
+            run?.ref().sessionId !== request.sessionId ||
+            request.options.length === 0) {
+            return { outcome: 'cancelled' };
+        }
+        this.approvalObserved = true;
+        const localId = `openclaw-approval-${String(++this.interactionSerial)}`;
+        return new Promise((settle) => {
+            this.pendingApprovals.set(localId, {
+                localId,
+                request,
+                run,
+                settle,
+            });
+            run.requestInteraction(localId, request);
+        });
+    }
+    async pump() {
+        try {
+            for await (const event of this.acp.events())
+                this.handleEvent(event);
+            if (!this.closed)
+                this.abortConnection('transport_ended');
+        }
+        catch (error) {
+            if (this.closed)
+                return;
+            if (isProtocolFailure(error)) {
+                this.activeRun?.failProtocol('provider_api_incompatible');
+                this.abortConnection('protocol_incompatible');
+                return;
+            }
+            this.abortConnection('transport_ended');
+        }
+    }
+    handleEvent(event) {
+        if (event.kind === 'unknown') {
+            const observation = redactOpenClawObservation(event.observation);
+            emitToListeners(this.observationListeners, observation);
+            emitToListeners(this.unknownListeners, observation);
+            this.activeRun?.receiveUnknown(event.observation, observation);
+            return;
+        }
+        const run = this.activeRun;
+        if (run?.ref().sessionId !== event.sessionId)
+            return;
+        for (const mapped of mapOpenClawSessionUpdate(event.update)) {
+            run.receive(mapped);
+        }
+    }
+    failPrompt(run, error) {
+        if (run.isTerminal())
+            return;
+        if (isProtocolFailure(error)) {
+            run.failProtocol('provider_api_incompatible');
+            this.abortConnection('protocol_incompatible');
+            return;
+        }
+        const mapped = mapError(error, this.profile, 'prompt');
+        if (mapped.code === 'connection_aborted' || mapped.code === 'timeout') {
+            this.abortConnection(mapped.code === 'timeout' ? 'prompt_wait_uncertain' : 'transport_ended');
+            return;
+        }
+        run.failProtocol(mapped.code);
+    }
+    settleApprovals(run) {
+        for (const pending of [...this.pendingApprovals.values()]) {
+            if (pending.run !== run)
+                continue;
+            this.pendingApprovals.delete(pending.localId);
+            pending.run.resolveInteraction(pending.localId, 'cancelled');
+            pending.settle({ outcome: 'cancelled' });
+        }
+    }
+    abortConnection(reason) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        const active = this.activeRun;
+        if (active !== undefined) {
+            this.settleApprovals(active);
+            active.abortConnection(reason);
+            this.activeRun = undefined;
+        }
+        void this.acp.close().catch(() => undefined);
+    }
+    async closeOnce(reason) {
+        if (!this.closed) {
+            this.closed = true;
+            const active = this.activeRun;
+            if (active !== undefined) {
+                this.settleApprovals(active);
+                active.abortConnection(reason);
+                this.activeRun = undefined;
+            }
+        }
+        try {
+            await this.acp.close();
+        }
+        catch (error) {
+            throw mapError(error, this.profile, 'close');
+        }
+    }
+    assertSessionReusable(sessionId) {
+        if (this.sessions.has(sessionId) ||
+            this.sessionReservations.has(sessionId)) {
+            throw new HarnessError('session_provider_mismatch', 'OpenClaw returned a Session identifier already active on this connection.', {
+                retryable: false,
+                providerId: OPENCLAW_PROVIDER_ID,
+                profileId: this.profile.profileId,
+            });
+        }
+    }
+    reserveSession(sessionId) {
+        this.assertSessionReusable(sessionId);
+        this.sessionReservations.add(sessionId);
+    }
+    operationError(error, phase, uncertaintyReason) {
+        const mapped = mapError(error, this.profile, phase);
+        if (mapped.code !== 'timeout' && mapped.code !== 'connection_aborted') {
+            return mapped;
+        }
+        this.abortConnection(uncertaintyReason);
+        return new HarnessError('connection_aborted', `OpenClaw ${phase} did not establish an authoritative outcome.`, {
+            retryable: false,
+            providerId: OPENCLAW_PROVIDER_ID,
+            profileId: this.profile.profileId,
+            ...(mapped.providerCode === undefined
+                ? {}
+                : { providerCode: mapped.providerCode }),
+        });
+    }
+    runtimeIdentity() {
+        return openClawCompatibilityIdentity(this.runtime.version);
+    }
+    assertOpen() {
+        if (this.closed || !this.acp.isOpen()) {
+            throw new HarnessError('connection_aborted', 'The OpenClaw ACP connection is closed.', {
+                retryable: false,
+                providerId: OPENCLAW_PROVIDER_ID,
+                profileId: this.profile.profileId,
+            });
+        }
+    }
+}
+class OpenClawSession {
+    client;
+    sessionId;
+    state;
+    lifecycleState = 'open';
+    closePromise;
+    constructor(client, sessionId, state) {
+        this.client = client;
+        this.sessionId = sessionId;
+        this.state = state;
+    }
+    ref() {
+        return this.client.sessionRef(this.sessionId, this.state);
+    }
+    capabilities() {
+        return Promise.resolve(this.client.capabilityManifest());
+    }
+    async start(input, options) {
+        this.assertOpen();
+        return this.client.startRun(this.sessionId, input, options);
+    }
+    async respond(requestId, response) {
+        this.assertOpen();
+        return this.client.respond(this.sessionId, requestId, response);
+    }
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.lifecycleState = 'closing';
+        const attempt = this.closeOnce();
+        this.closePromise = attempt;
+        void attempt.catch((error) => {
+            if (this.closePromise === attempt) {
+                if (error instanceof HarnessError &&
+                    error.code === 'connection_aborted') {
+                    return;
+                }
+                this.closePromise = undefined;
+                this.lifecycleState = 'open';
+            }
+        });
+        return attempt;
+    }
+    async closeOnce() {
+        await this.client.closeSession(this);
+        this.lifecycleState = 'closed';
+    }
+    assertOpen() {
+        if (this.lifecycleState !== 'open') {
+            throw new HarnessError('session_not_found', 'The OpenClaw Session is closed.', {
+                retryable: false,
+                providerId: OPENCLAW_PROVIDER_ID,
+                profileId: this.ref().profileId,
+            });
+        }
+    }
+}
+class OpenClawRun {
+    reference;
+    cancelSettlementTimeoutMs;
+    sendCancel;
+    abortOwnerConnection;
+    onTerminal;
+    eventQueue;
+    settlement;
+    timeout;
+    cancelPromise;
+    cancelReason;
+    finalMessage = '';
+    finalResult;
+    reasoning = '';
+    resolveSettlement;
+    sequence = 0;
+    usage;
+    constructor(reference, maxRunEvents, timeoutMs, cancelSettlementTimeoutMs, sendCancel, abortOwnerConnection, onTerminal) {
+        this.reference = reference;
+        this.cancelSettlementTimeoutMs = cancelSettlementTimeoutMs;
+        this.sendCancel = sendCancel;
+        this.abortOwnerConnection = abortOwnerConnection;
+        this.onTerminal = onTerminal;
+        validateRunTimeout(timeoutMs);
+        this.eventQueue = new EventQueue(maxRunEvents);
+        this.settlement = new Promise((resolveSettlement) => {
+            this.resolveSettlement = resolveSettlement;
+        });
+        this.timeout =
+            timeoutMs === undefined
+                ? undefined
+                : setTimeout(() => {
+                    this.cancelReason = 'timeout';
+                    void this.cancel().catch(() => {
+                        this.abortOwnerConnection('timeout_cancellation_failed');
+                    });
+                }, timeoutMs);
+        this.timeout?.unref();
+        this.emit({ type: 'run.started', data: {} });
+    }
+    ref() {
+        return { ...this.reference };
+    }
+    events() {
+        return this.eventQueue.iterable();
+    }
+    cancel() {
+        if (this.isTerminal())
+            return Promise.resolve({ mode: 'already_terminal' });
+        this.cancelPromise ??= this.cancelOnce();
+        return this.cancelPromise;
+    }
+    result() {
+        return this.settlement;
+    }
+    receive(mapped) {
+        if (this.isTerminal())
+            return;
+        if (mapped.messageDelta !== undefined) {
+            this.finalMessage += mapped.messageDelta;
+        }
+        if (mapped.reasoningDelta !== undefined)
+            this.reasoning += mapped.reasoningDelta;
+        if (mapped.usage !== undefined)
+            this.usage = mapped.usage;
+        this.emit(mapped);
+    }
+    receiveUnknown(observation, redacted) {
+        if (this.isTerminal())
+            return;
+        this.emit({
+            type: 'provider',
+            data: { method: observation.method },
+            providerEventType: observation.method,
+            raw: redacted,
+        });
+    }
+    requestInteraction(requestId, request) {
+        if (this.isTerminal())
+            return;
+        this.emit({
+            type: 'interaction.requested',
+            data: {
+                requestId,
+                kind: 'approval',
+                ...(request.toolCall.title === undefined ||
+                    request.toolCall.title === null
+                    ? {}
+                    : { title: request.toolCall.title.slice(0, 128) }),
+                schema: {
+                    options: request.options.map(({ kind, name, optionId }) => ({
+                        kind,
+                        name: name.slice(0, 128),
+                        optionId,
+                    })),
+                },
+            },
+        });
+    }
+    resolveInteraction(requestId, decision) {
+        if (this.isTerminal())
+            return;
+        this.emit({
+            type: 'interaction.resolved',
+            data: { requestId, kind: 'approval', decision },
+        });
+    }
+    finishPrompt(stopReason) {
+        if (this.isTerminal())
+            return;
+        if (stopReason === 'end_turn') {
+            this.finish({
+                status: 'completed',
+                ...(this.finalMessage.length === 0
+                    ? {}
+                    : { finalMessage: this.finalMessage }),
+                ...(this.usage === undefined ? {} : { usage: this.usage }),
+                providerResult: { stopReason },
+            }, 'run.completed');
+            return;
+        }
+        if (stopReason === 'cancelled') {
+            this.finish({
+                status: 'cancelled',
+                ...(this.usage === undefined ? {} : { usage: this.usage }),
+                providerResult: {
+                    stopReason,
+                    ...(this.cancelReason === undefined
+                        ? {}
+                        : { reason: this.cancelReason }),
+                },
+            }, 'run.cancelled');
+            return;
+        }
+        if (stopReason === 'refusal' ||
+            stopReason === 'max_tokens' ||
+            stopReason === 'max_turn_requests') {
+            this.finish({ status: 'failed', providerResult: { stopReason } }, 'run.failed');
+            return;
+        }
+        this.failProtocol('provider_api_incompatible');
+    }
+    failProtocol(reason) {
+        if (this.isTerminal())
+            return;
+        this.finish({ status: 'failed', providerResult: { reason } }, 'run.failed');
+    }
+    abortConnection(reason) {
+        if (this.isTerminal())
+            return;
+        this.finish({ status: 'connection_aborted', providerResult: { reason } }, 'connection.aborted');
+    }
+    isTerminal() {
+        return this.finalResult !== undefined;
+    }
+    async cancelOnce() {
+        try {
+            await this.sendCancel();
+        }
+        catch {
+            this.abortOwnerConnection('cancel_notification_failed');
+            return { mode: 'connection_aborted' };
+        }
+        const result = await withTimeout(this.settlement, this.cancelSettlementTimeoutMs);
+        if (result === undefined) {
+            this.abortOwnerConnection('cancel_terminal_timeout');
+            return { mode: 'connection_aborted' };
+        }
+        if (result.status === 'cancelled')
+            return { mode: 'native' };
+        if (result.status === 'connection_aborted') {
+            return { mode: 'connection_aborted' };
+        }
+        return { mode: 'already_terminal' };
+    }
+    finish(result, type) {
+        if (this.isTerminal())
+            return;
+        if (this.timeout !== undefined)
+            clearTimeout(this.timeout);
+        let terminalResult = result;
+        let terminalType = type;
+        let overflowed = false;
+        if (this.finalMessage.length > 0) {
+            overflowed = !this.eventQueue.push(this.portableEvent({
+                type: 'message.completed',
+                data: { text: this.finalMessage },
+            }));
+        }
+        if (!overflowed && this.reasoning.length > 0) {
+            overflowed = !this.eventQueue.push(this.portableEvent({
+                type: 'reasoning.completed',
+                data: { text: this.reasoning },
+            }));
+        }
+        if (overflowed) {
+            terminalResult = {
+                status: 'connection_aborted',
+                providerResult: { reason: 'event_buffer_overflow' },
+            };
+            terminalType = 'connection.aborted';
+        }
+        this.finalResult = terminalResult;
+        this.onTerminal(this);
+        this.eventQueue.pushTerminal(this.portableEvent({ type: terminalType, data: terminalResult }));
+        this.eventQueue.close();
+        this.resolveSettlement(terminalResult);
+        if (overflowed)
+            this.abortOwnerConnection('event_buffer_overflow');
+    }
+    emit(mapped) {
+        if (this.finalResult !== undefined)
+            return;
+        if (!this.eventQueue.push(this.portableEvent(mapped))) {
+            this.abortOwnerConnection('event_buffer_overflow');
+        }
+    }
+    portableEvent(mapped) {
+        const sequence = this.sequence++;
+        return {
+            id: `${this.reference.runId}:event:${String(sequence)}`,
+            type: mapped.type,
+            providerId: this.reference.providerId,
+            profileId: this.reference.profileId,
+            sessionId: this.reference.sessionId,
+            runId: this.reference.runId,
+            sequence,
+            timestamp: new Date().toISOString(),
+            data: mapped.data,
+            ...(mapped.providerEventType === undefined
+                ? {}
+                : { providerEventType: mapped.providerEventType }),
+            ...(mapped.raw === undefined ? {} : { raw: mapped.raw }),
+        };
+    }
+}
+class EventQueue {
+    capacity;
+    values = [];
+    closed = false;
+    consumed = false;
+    waiter;
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    push(event) {
+        if (this.closed)
+            return false;
+        if (this.waiter !== undefined) {
+            const waiter = this.waiter;
+            this.waiter = undefined;
+            waiter({ done: false, value: event });
+            return true;
+        }
+        if (this.values.length >= this.capacity - 1)
+            return false;
+        this.values.push(event);
+        return true;
+    }
+    pushTerminal(event) {
+        if (this.waiter !== undefined) {
+            const waiter = this.waiter;
+            this.waiter = undefined;
+            waiter({ done: false, value: event });
+            return;
+        }
+        this.values.push(event);
+    }
+    close() {
+        this.closed = true;
+    }
+    iterable() {
+        if (this.consumed) {
+            return {
+                [Symbol.asyncIterator]: () => ({
+                    next: () => Promise.reject(new HarnessError('run_conflict', 'OpenClaw Run events already have a consumer.', { retryable: false, providerId: OPENCLAW_PROVIDER_ID })),
+                }),
+            };
+        }
+        this.consumed = true;
+        return {
+            [Symbol.asyncIterator]: () => ({ next: () => this.next() }),
+        };
+    }
+    next() {
+        const event = this.values.shift();
+        if (event !== undefined)
+            return Promise.resolve({ done: false, value: event });
+        if (this.closed)
+            return Promise.resolve({ done: true, value: undefined });
+        if (this.waiter !== undefined) {
+            return Promise.reject(new HarnessError('run_conflict', 'An OpenClaw Run event read is already pending.', { retryable: false, providerId: OPENCLAW_PROVIDER_ID }));
+        }
+        return new Promise((resolveNext) => {
+            this.waiter = resolveNext;
+        });
+    }
+}
+async function spawnAcp(profile, options, requestPermission) {
+    if (profile.connection.kind !== 'process')
+        throw profileInvalid(profile);
+    const child = spawn(profile.connection.command, [...(profile.connection.args ?? [])], {
+        cwd: profile.connection.cwd,
+        shell: false,
+        stdio: ['pipe', 'pipe', 'ignore'],
+    });
+    await processStarted(child);
+    try {
+        return new AcpClient({
+            ...options,
+            readable: child.stdout,
+            writable: child.stdin,
+            requestPermission,
+            cleanup: () => terminateChild(child),
+        });
+    }
+    catch (error) {
+        await terminateChild(child);
+        throw error;
+    }
+}
+function processStarted(child) {
+    return new Promise((resolveStarted, rejectStarted) => {
+        const onSpawn = () => {
+            child.off('error', onError);
+            child.on('error', () => undefined);
+            resolveStarted();
+        };
+        const onError = (error) => {
+            child.off('spawn', onSpawn);
+            rejectStarted(error);
+        };
+        child.once('spawn', onSpawn);
+        child.once('error', onError);
+    });
+}
+async function terminateChild(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    child.kill();
+    if (await waitForChildExit(child, childTerminationTimeoutMs))
+        return;
+    child.kill('SIGKILL');
+    if (await waitForChildExit(child, childTerminationTimeoutMs))
+        return;
+    throw new Error('OpenClaw ACP child process did not exit.');
+}
+function waitForChildExit(child, timeoutMs) {
+    if (child.exitCode !== null || child.signalCode !== null) {
+        return Promise.resolve(true);
+    }
+    return new Promise((resolveExit) => {
+        let settled = false;
+        const onExit = () => {
+            finish(true);
+        };
+        const timer = setTimeout(() => {
+            finish(false);
+        }, timeoutMs);
+        function finish(exited) {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.off('exit', onExit);
+            resolveExit(exited);
+        }
+        child.once('exit', onExit);
+        if (child.exitCode !== null || child.signalCode !== null)
+            finish(true);
+    });
+}
+function openClawCapabilities(profile, capabilities, runtimeIdentity, approvalObserved) {
+    const native = { mode: 'native', source: 'handshake' };
+    const unsupported = {
+        mode: 'unsupported',
+        source: 'handshake',
+    };
+    return {
+        providerId: OPENCLAW_PROVIDER_ID,
+        profileId: profile.profileId,
+        capabilities: {
+            'session.create': native,
+            'session.resume': capabilities.session.resume ? native : unsupported,
+            'session.close': capabilities.session.close ? native : unsupported,
+            'session.workspace': {
+                mode: 'unknown',
+                reason: 'ACP accepts cwd, but Gateway tool execution in that workspace lacks live evidence.',
+                source: 'schema',
+            },
+            'session.fork': unsupported,
+            'run.stream': native,
+            'run.cancel': { mode: 'native', source: 'schema' },
+            'run.timeout': {
+                mode: 'emulated',
+                reason: 'A local timer requests native ACP cancellation.',
+                source: 'configuration',
+            },
+            'run.concurrent': {
+                mode: 'unsupported',
+                limits: { maxActiveRunsPerConnection: 1 },
+                source: 'configuration',
+            },
+            'connection.abort': {
+                mode: 'adapter_controlled',
+                source: 'configuration',
+            },
+            'input.text': native,
+            'input.image': capabilities.prompt.image ? native : unsupported,
+            'input.file': unsupported,
+            'interaction.approval': approvalObserved
+                ? { mode: 'native', source: 'schema' }
+                : {
+                    mode: 'unknown',
+                    reason: 'ACP initialization does not advertise permission requests.',
+                    source: 'handshake',
+                },
+            'interaction.user_input': unsupported,
+            'interaction.provider': unsupported,
+            'event.raw': { mode: 'adapter_controlled', source: 'configuration' },
+            'native.client': { mode: 'native', source: 'schema' },
+        },
+        observedAt: new Date().toISOString(),
+        runtimeIdentity,
+    };
+}
+function connectionOptions(value, profile) {
+    const options = value ?? {};
+    const allowed = new Set([
+        'cancelSettlementTimeoutMs',
+        'maxBufferedEvents',
+        'maxBufferedMessages',
+        'maxMessageBytes',
+        'maxPendingInboundRequests',
+        'maxPendingRequests',
+        'maxPendingWrites',
+        'maxRunEvents',
+        'operationTimeoutMs',
+        'requestTimeoutMs',
+    ]);
+    if (Object.keys(options).some((key) => !allowed.has(key))) {
+        throw profileInvalid(profile);
+    }
+    const acp = {
+        requestTimeoutMs: options['requestTimeoutMs'] === undefined
+            ? maximumTimerMilliseconds
+            : positiveProfileTimer(options['requestTimeoutMs'], 'requestTimeoutMs'),
+    };
+    for (const name of [
+        'maxBufferedEvents',
+        'maxBufferedMessages',
+        'maxMessageBytes',
+        'maxPendingInboundRequests',
+        'maxPendingRequests',
+        'maxPendingWrites',
+    ]) {
+        if (options[name] !== undefined) {
+            acp[name] = positiveProfileInteger(options[name], name);
+        }
+    }
+    return {
+        acp,
+        cancelSettlementTimeoutMs: options['cancelSettlementTimeoutMs'] === undefined
+            ? defaultCancelSettlementTimeoutMs
+            : positiveProfileTimer(options['cancelSettlementTimeoutMs'], 'cancelSettlementTimeoutMs'),
+        maxRunEvents: runEventCapacity(options['maxRunEvents']),
+        operationTimeoutMs: options['operationTimeoutMs'] === undefined
+            ? defaultOperationTimeoutMs
+            : positiveProfileTimer(options['operationTimeoutMs'], 'operationTimeoutMs'),
+    };
+}
+function validateProfile(profile) {
+    const connection = profile.connection;
+    if (profile.providerId !== OPENCLAW_PROVIDER_ID ||
+        connection.kind !== 'process' ||
+        connection.ownership !== 'adapter' ||
+        connection.command.trim().length === 0 ||
+        connection.envRefs !== undefined ||
+        (connection.args ?? []).some((argument) => forbiddenRoutingArguments.some((name) => argument === name || argument.startsWith(`${name}=`)))) {
+        throw profileInvalid(profile);
+    }
+}
+function prepareSessionInput(input, profile) {
+    if (input.systemContext !== undefined ||
+        input.model !== undefined ||
+        input.providerOptions !== undefined ||
+        input.metadata !== undefined) {
+        throw new HarnessError('unsupported_capability', 'OpenClaw ACP does not map portable Session model or context controls.', {
+            retryable: false,
+            providerId: OPENCLAW_PROVIDER_ID,
+            profileId: profile.profileId,
+            details: { capability: 'session.options' },
+        });
+    }
+    if (input.workspace === undefined) {
+        return resolve(profile.connection.kind === 'process'
+            ? (profile.connection.cwd ?? process.cwd())
+            : process.cwd());
+    }
+    try {
+        const url = new URL(input.workspace.uri);
+        if (url.protocol !== 'file:')
+            throw new Error('not file');
+        return resolve(fileURLToPath(url));
+    }
+    catch {
+        throw new HarnessError('invalid_request', 'OpenClaw workspace must be an absolute file URI.', {
+            retryable: false,
+            providerId: OPENCLAW_PROVIDER_ID,
+            profileId: profile.profileId,
+        });
+    }
+}
+function sessionStateFromRef(ref) {
+    const state = record(ref.providerState);
+    if (state?.['strategy'] !== 'isolated' ||
+        typeof state['sessionKey'] !== 'string' ||
+        !state['sessionKey'].startsWith('acp-bridge:harapter-') ||
+        typeof state['cwd'] !== 'string' ||
+        !state['cwd'].startsWith('/')) {
+        throw new HarnessError('session_provider_mismatch', 'OpenClaw Session reference does not contain valid isolated route state.', {
+            retryable: false,
+            providerId: OPENCLAW_PROVIDER_ID,
+            profileId: ref.profileId,
+        });
+    }
+    return {
+        strategy: 'isolated',
+        sessionKey: state['sessionKey'],
+        cwd: state['cwd'],
+    };
+}
+function validateRunOptions(options) {
+    validateRunTimeout(options.timeoutMs);
+    if (options.providerOptions !== undefined || options.metadata !== undefined) {
+        throw new HarnessError('invalid_request', 'OpenClaw Run Provider options and metadata are not mapped.', { retryable: false, providerId: OPENCLAW_PROVIDER_ID });
+    }
+}
+function selectPermissionOption(options, response) {
+    const permittedKinds = response.decision === 'approve'
+        ? new Set(['allow_once', 'allow_always'])
+        : new Set(['reject_once', 'reject_always']);
+    if (response.providerOptions !== undefined) {
+        const providerOptions = record(response.providerOptions);
+        const explicit = providerOptions?.['optionId'];
+        if (providerOptions === undefined ||
+            Object.keys(providerOptions).length !== 1 ||
+            typeof explicit !== 'string') {
+            throw invalidPermissionOption();
+        }
+        const selected = options.find(({ optionId }) => optionId === explicit);
+        if (selected === undefined || !permittedKinds.has(selected.kind)) {
+            throw invalidPermissionOption();
+        }
+        return selected;
+    }
+    const defaultKind = response.decision === 'approve' ? 'allow_once' : 'reject_once';
+    const selected = options.find(({ kind }) => kind === defaultKind);
+    if (selected === undefined) {
+        throw invalidPermissionOption();
+    }
+    return selected;
+}
+function invalidPermissionOption() {
+    return new HarnessError('invalid_request', 'OpenClaw approval decision has no compatible Provider option.', { retryable: false, providerId: OPENCLAW_PROVIDER_ID });
+}
+function runEventCapacity(value) {
+    if (value === undefined)
+        return defaultMaxRunEvents;
+    const capacity = positiveProfileInteger(value, 'maxRunEvents');
+    if (capacity < 2 || capacity > maximumRunEvents) {
+        throw new HarnessError('profile_invalid', `OpenClaw maxRunEvents must be between 2 and ${String(maximumRunEvents)}.`, { retryable: false, providerId: OPENCLAW_PROVIDER_ID });
+    }
+    return capacity;
+}
+function validateRunTimeout(timeoutMs) {
+    if (timeoutMs === undefined)
+        return;
+    if (!Number.isSafeInteger(timeoutMs) ||
+        timeoutMs <= 0 ||
+        timeoutMs > maximumTimerMilliseconds) {
+        throw new HarnessError('invalid_request', 'OpenClaw Run timeoutMs must be a positive supported timer value.', { retryable: false, providerId: OPENCLAW_PROVIDER_ID });
+    }
+}
+function positiveProfileInteger(value, label) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) {
+        throw new HarnessError('profile_invalid', `OpenClaw ${label} must be a positive integer.`, { retryable: false, providerId: OPENCLAW_PROVIDER_ID });
+    }
+    return value;
+}
+function positiveProfileTimer(value, label) {
+    const timeout = positiveProfileInteger(value, label);
+    if (timeout > maximumTimerMilliseconds) {
+        throw new HarnessError('profile_invalid', `OpenClaw ${label} exceeds the supported timer range.`, { retryable: false, providerId: OPENCLAW_PROVIDER_ID });
+    }
+    return timeout;
+}
+function profileInvalid(profile) {
+    return new HarnessError('profile_invalid', 'OpenClaw requires an adapter-owned process Profile without unresolved secrets or session-routing arguments.', {
+        retryable: false,
+        providerId: OPENCLAW_PROVIDER_ID,
+        profileId: profile.profileId,
+    });
+}
+function snapshotProfile(profile) {
+    return {
+        ...profile,
+        connection: {
+            ...profile.connection,
+            ...(profile.connection.kind === 'process' && profile.connection.args
+                ? { args: [...profile.connection.args] }
+                : {}),
+        },
+        ...(profile.providerOptions === undefined
+            ? {}
+            : { providerOptions: { ...profile.providerOptions } }),
+    };
+}
+function emitToListeners(listeners, event) {
+    for (const listener of [...listeners]) {
+        try {
+            listener(structuredClone(event));
+        }
+        catch {
+            // Provider observers cannot affect lifecycle processing.
+        }
+    }
+}
+function mapError(error, profile, phase, connecting = false) {
+    if (error instanceof HarnessError)
+        return error;
+    if (error instanceof JsonRpcRemoteError) {
+        const remote = error.getRemoteError();
+        return new HarnessError(remote.code === -32_601 ? 'provider_api_incompatible' : 'provider_error', `OpenClaw rejected ${phase}.`, {
+            retryable: false,
+            providerId: OPENCLAW_PROVIDER_ID,
+            profileId: profile.profileId,
+            providerCode: String(remote.code),
+        });
+    }
+    if (error instanceof AcpClientError) {
+        const code = isProtocolFailure(error)
+            ? 'provider_api_incompatible'
+            : error.code === 'capability_not_advertised'
+                ? 'unsupported_capability'
+                : error.code === 'client_closed'
+                    ? connecting
+                        ? 'connection_failed'
+                        : 'connection_aborted'
+                    : 'provider_error';
+        return new HarnessError(code, `OpenClaw ${phase} did not complete.`, {
+            retryable: false,
+            providerId: OPENCLAW_PROVIDER_ID,
+            profileId: profile.profileId,
+            providerCode: error.code,
+        });
+    }
+    if (error instanceof JsonRpcTransportError) {
+        const code = error.code === 'request_timeout'
+            ? 'timeout'
+            : connecting
+                ? 'connection_failed'
+                : 'connection_aborted';
+        return new HarnessError(code, `OpenClaw ${phase} did not complete.`, {
+            retryable: error.code === 'request_timeout',
+            providerId: OPENCLAW_PROVIDER_ID,
+            profileId: profile.profileId,
+            providerCode: error.code,
+        });
+    }
+    const systemCode = typeof error === 'object' && error !== null && 'code' in error
+        ? error.code
+        : undefined;
+    if (connecting && systemCode === 'ENOENT') {
+        return new HarnessError('runtime_not_found', 'The configured OpenClaw runtime was not found.', {
+            retryable: false,
+            providerId: OPENCLAW_PROVIDER_ID,
+            profileId: profile.profileId,
+        });
+    }
+    return new HarnessError(connecting ? 'connection_failed' : 'provider_error', `OpenClaw ${phase} did not complete.`, {
+        retryable: false,
+        providerId: OPENCLAW_PROVIDER_ID,
+        profileId: profile.profileId,
+    });
+}
+function isProtocolFailure(error) {
+    return (error instanceof AcpClientError &&
+        (error.code === 'invalid_message' ||
+            error.code === 'unsupported_protocol_version'));
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+async function withTimeout(promise, timeoutMs) {
+    let timer;
+    const timeout = new Promise((resolveTimeout) => {
+        timer = setTimeout(() => {
+            resolveTimeout(undefined);
+        }, timeoutMs);
+        timer.unref();
+    });
+    try {
+        return await Promise.race([promise, timeout]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=adapter.js.map