});

private readonly replayByRunId = new Map<string, OpenClawEvent[]>();

private connected = false;

private closed = false;

private eventPumpPromise: Promise<void> | null = null;

private eventPumpReady: Promise<void> | null = null;

private closePromise: Promise<void> | null = null;

constructor(options: OpenClawOptions = {}) {

this.transport =

}

async connect(): Promise<void> {

this.assertOpen();

if (this.connected) {

await this.startEventPump();

this.assertOpen();

return;

}

if (isConnectableTransport(this.transport)) {

await this.transport.connect();

}

this.assertOpen();

this.connected = true;

await this.startEventPump();

this.assertOpen();

}

async close(): Promise<void> {

await this.transport.close?.();

await this.eventPumpPromise?.catch(() => {});

this.normalizedEvents.close();

this.eventPumpPromise = null;

this.eventPumpReady = null;

this.connected = false;

if (this.closePromise) {

return await this.closePromise;

}

if (this.closed) {

return;

}

this.closed = true;

this.closePromise = (async () => {

try {

await this.transport.close?.();

await this.eventPumpPromise?.catch(() => {});

} finally {

this.normalizedEvents.close();

this.eventPumpPromise = null;

this.eventPumpReady = null;

this.connected = false;

}

})();

try {

await this.closePromise;

} finally {

this.closePromise = null;

}

}

async request<T = unknown>(

options?: GatewayRequestOptions,

): Promise<T> {

await this.connect();

this.assertOpen();

return await this.transport.request<T>(method, params, options);

}

}

rawEvents(filter?: (event: GatewayEvent) => boolean): AsyncIterable<GatewayEvent> {

this.assertOpen();

return this.transport.events(filter);

}

private assertOpen(): void {

if (this.closed) {

throw new Error("OpenClaw SDK client is closed");

}

}

private async *iterateEvents(

filter?: (event: OpenClawEvent) => boolean,

): AsyncIterable<OpenClawEvent> {

await this.connect();

this.assertOpen();

for await (const event of this.normalizedEvents.stream(filter)) {

yield event;

}

filter?: (event: OpenClawEvent) => boolean,

): AsyncIterable<OpenClawEvent> {

await this.connect();

this.assertOpen();

const replayEvents = this.replaySnapshot(runId);

let hasCanonicalAssistantRunEvent = replayEvents.some(isAssistantRunEvent);

let hasTerminalRunEvent = replayEvents.some(isTerminalRunEvent);