handmux 0.23.0 → 0.25.0

package/dist/src/agent-runtime/bridgeStore.js

@@ -0,0 +1,25 @@
+import { PrivateStateStore } from '../privateStateStore.js';
+function copyState(value) {
+    return structuredClone(value);
+}
+export class MemoryBridgeStateStore {
+    #state = null;
+    load() {
+        return this.#state ? copyState(this.#state) : null;
+    }
+    save(state) {
+        this.#state = copyState(state);
+    }
+}
+export class FileBridgeStateStore {
+    #store;
+    constructor(file) {
+        this.#store = new PrivateStateStore(file);
+    }
+    load() {
+        return this.#store.readStrict();
+    }
+    save(state) {
+        this.#store.write(state);
+    }
+}

package/dist/src/agent-runtime/bridgeTransport.js

@@ -0,0 +1,619 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { DEFAULT_BRIDGE_LIMITS } from './bridgeTypes.js';
+const PROTOCOL_VERSION = 1;
+const NAME_RE = /^[a-z][a-z0-9._-]{0,63}$/;
+const MAX_HANDSHAKE_BYTES = 64 * 1024;
+const DEFAULT_HANDSHAKE_TIMEOUT_MS = 5_000;
+const WIRE_OVERHEAD_BYTES = 16 * 1024;
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value : null;
+}
+function bounded(value, max) {
+    return typeof value === 'string' && value.length > 0 && value.length <= max;
+}
+function validChannelName(value) {
+    return typeof value === 'string' && NAME_RE.test(value) && !value.startsWith('handmux.');
+}
+function errorMessage(error) {
+    return (error instanceof Error ? error.message : String(error)).slice(0, 4096);
+}
+function nonceProof(authToken, nonce) {
+    return crypto.createHmac('sha256', authToken).update(nonce).digest('base64url');
+}
+function equalProof(actual, expected) {
+    if (typeof actual !== 'string')
+        return false;
+    const first = Buffer.from(actual);
+    const second = Buffer.from(expected);
+    return first.length === second.length && crypto.timingSafeEqual(first, second);
+}
+function wirePeer(socket, maxBytes, onMessage) {
+    const peer = {
+        socket,
+        maxBytes,
+        buffer: Buffer.alloc(0),
+        closed: false,
+        send(value) {
+            if (peer.closed || socket.destroyed)
+                throw new Error('Bridge transport is closed');
+            const encoded = Buffer.from(`${JSON.stringify(value)}\n`);
+            if (encoded.length > peer.maxBytes)
+                throw new Error('Bridge transport frame exceeds limit');
+            socket.write(encoded);
+        },
+        close() {
+            if (peer.closed)
+                return;
+            peer.closed = true;
+            socket.destroy();
+        },
+    };
+    socket.on('data', (chunk) => {
+        if (peer.closed)
+            return;
+        peer.buffer = Buffer.concat([peer.buffer, chunk]);
+        if (peer.buffer.length > peer.maxBytes && !peer.buffer.includes(0x0a)) {
+            peer.close();
+            return;
+        }
+        while (true) {
+            const newline = peer.buffer.indexOf(0x0a);
+            if (newline < 0)
+                break;
+            const frame = peer.buffer.subarray(0, newline);
+            peer.buffer = peer.buffer.subarray(newline + 1);
+            if (!frame.length)
+                continue;
+            if (frame.length > peer.maxBytes) {
+                peer.close();
+                return;
+            }
+            try {
+                onMessage(JSON.parse(frame.toString('utf8')));
+            }
+            catch {
+                peer.close();
+                return;
+            }
+        }
+    });
+    return peer;
+}
+function validCandidate(value) {
+    const candidate = record(value);
+    const process = record(candidate?.process);
+    if (!candidate || !bounded(candidate.paneId, 256) || !bounded(candidate.attachmentId, 512)
+        || (candidate.sessionId !== undefined && !bounded(candidate.sessionId, 1024))
+        || (candidate.implementationVersion !== undefined
+            && (!Number.isSafeInteger(candidate.implementationVersion)
+                || Number(candidate.implementationVersion) <= 0))
+        || !process || !Number.isSafeInteger(process.pid) || Number(process.pid) <= 0)
+        return false;
+    return (process.startedAt === undefined
+        || (typeof process.startedAt === 'number' && Number.isFinite(process.startedAt)))
+        && (process.tty === undefined || bounded(process.tty, 1024));
+}
+function validRun(value, adapterId, paneId) {
+    const run = record(value);
+    return run !== null && run.agentId === adapterId && run.paneId === paneId
+        && bounded(run.runId, 256)
+        && (run.implementationVersion === undefined
+            || (Number.isSafeInteger(run.implementationVersion)
+                && Number(run.implementationVersion) > 0))
+        && (run.sessionId === undefined || bounded(run.sessionId, 1024));
+}
+function validLimits(value) {
+    const limits = record(value);
+    if (!limits)
+        return false;
+    return Object.entries(DEFAULT_BRIDGE_LIMITS).every(([name, maximum]) => {
+        const actual = limits[name];
+        return typeof actual === 'number' && Number.isFinite(actual) && actual > 0 && actual <= maximum;
+    }) && Number(limits.defaultRequestTimeoutMs) <= Number(limits.maxRequestTimeoutMs);
+}
+function result(peer, id, value) {
+    if (bounded(id, 256))
+        peer.send({ type: 'result', id, ok: true, value });
+}
+function failure(peer, id, error) {
+    if (bounded(id, 256))
+        peer.send({ type: 'result', id, ok: false, error: errorMessage(error) });
+}
+async function liveSocket(socketPath) {
+    if (!fs.existsSync(socketPath))
+        return false;
+    return new Promise((resolve, reject) => {
+        const socket = net.createConnection(socketPath);
+        let settled = false;
+        const finish = (value, error) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        };
+        socket.once('connect', () => finish(true));
+        socket.once('error', (error) => {
+            if (error.code === 'ECONNREFUSED' || error.code === 'ENOENT')
+                finish(false);
+            else
+                finish(false, error);
+        });
+        socket.setTimeout(500, () => finish(false, new Error('Timed out probing existing Bridge socket')));
+    });
+}
+function ensurePrivateDirectory(directory) {
+    try {
+        const stat = fs.lstatSync(directory);
+        if (!stat.isDirectory() || (stat.mode & 0o077) !== 0) {
+            throw new Error('Bridge transport directory must be a private directory');
+        }
+        if (typeof process.getuid === 'function' && stat.uid !== process.getuid()) {
+            throw new Error('Bridge transport directory must be owned by the current user');
+        }
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !('code' in error) || error.code !== 'ENOENT')
+            throw error;
+        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+        const stat = fs.lstatSync(directory);
+        if (!stat.isDirectory() || (stat.mode & 0o077) !== 0) {
+            throw new Error('Bridge transport directory could not be created privately');
+        }
+    }
+}
+export class LocalAgentBridgeTransportServer {
+    socketPath;
+    #bridge;
+    #authToken;
+    #authorize;
+    #connected;
+    #newNonce;
+    #handshakeTimeoutMs;
+    #sessions = new Set();
+    #server;
+    constructor({ socketPath, authToken, bridge, authorize, connected, newNonce = () => crypto.randomBytes(32).toString('base64url'), handshakeTimeoutMs = DEFAULT_HANDSHAKE_TIMEOUT_MS, }) {
+        if (!path.isAbsolute(socketPath) || !bounded(authToken, 1024) || authToken.length < 32
+            || !bridge || typeof authorize !== 'function' || !Number.isSafeInteger(handshakeTimeoutMs)
+            || handshakeTimeoutMs <= 0 || (connected !== undefined && typeof connected !== 'function')) {
+            throw new TypeError('Bridge transport requires an absolute socket path, Bridge, and authorizer');
+        }
+        this.socketPath = socketPath;
+        this.#authToken = authToken;
+        this.#bridge = bridge;
+        this.#authorize = authorize;
+        this.#connected = connected;
+        this.#newNonce = newNonce;
+        this.#handshakeTimeoutMs = handshakeTimeoutMs;
+    }
+    async start() {
+        if (this.#server)
+            return;
+        ensurePrivateDirectory(path.dirname(this.socketPath));
+        if (await liveSocket(this.socketPath)) {
+            throw new Error('Bridge transport socket is already owned by a live server');
+        }
+        try {
+            fs.unlinkSync(this.socketPath);
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !('code' in error) || error.code !== 'ENOENT')
+                throw error;
+        }
+        const server = net.createServer((socket) => this.#accept(socket));
+        this.#server = server;
+        try {
+            await new Promise((resolve, reject) => {
+                server.once('error', reject);
+                server.listen(this.socketPath, () => {
+                    server.removeListener('error', reject);
+                    resolve();
+                });
+            });
+        }
+        catch (error) {
+            if (this.#server === server)
+                this.#server = undefined;
+            throw error;
+        }
+        try {
+            fs.chmodSync(this.socketPath, 0o600);
+        }
+        catch (error) {
+            await this.close();
+            throw error;
+        }
+    }
+    async close() {
+        const server = this.#server;
+        if (!server)
+            return;
+        this.#server = undefined;
+        for (const session of [...this.#sessions])
+            this.#closeSession(session);
+        await new Promise((resolve) => server.close(() => resolve()));
+        try {
+            fs.unlinkSync(this.socketPath);
+        }
+        catch { /* already removed */ }
+    }
+    #accept(socket) {
+        socket.setNoDelay(true);
+        const nonce = this.#newNonce();
+        const session = {};
+        const peer = wirePeer(socket, MAX_HANDSHAKE_BYTES, (value) => {
+            const operation = session.tail.then(() => this.#message(session, nonce, value));
+            session.tail = operation.catch((error) => {
+                try {
+                    failure(peer, record(value)?.id, error);
+                }
+                catch { /* closing */ }
+                if (!session.connection)
+                    this.#closeSession(session);
+            });
+        });
+        const handshakeTimer = setTimeout(() => this.#closeSession(session), this.#handshakeTimeoutMs);
+        handshakeTimer.unref?.();
+        Object.assign(session, {
+            peer, unregister: new Map(), pending: new Map(), handshakeTimer, tail: Promise.resolve(),
+        });
+        this.#sessions.add(session);
+        socket.once('close', () => this.#closeSession(session));
+        socket.once('error', () => this.#closeSession(session));
+        peer.send({ type: 'challenge', protocolVersion: PROTOCOL_VERSION, nonce });
+    }
+    async #message(session, nonce, raw) {
+        const value = record(raw);
+        if (!value || typeof value.type !== 'string')
+            throw new Error('Invalid Bridge transport frame');
+        if (!session.connection) {
+            if (value.type !== 'hello' || value.protocolVersion !== PROTOCOL_VERSION
+                || !equalProof(value.proof, nonceProof(this.#authToken, nonce))
+                || !bounded(value.adapterId, 64) || !NAME_RE.test(value.adapterId)
+                || !validCandidate(value.candidate))
+                throw new Error('Invalid Bridge transport handshake');
+            const replacing = value.newGeneration === true;
+            if ((value.newGeneration !== undefined && typeof value.newGeneration !== 'boolean')
+                || (replacing && !bounded(value.generationId, 256))
+                || (!replacing && value.generationId !== undefined)) {
+                throw new Error('Invalid Bridge transport generation');
+            }
+            const lease = await this.#authorize(value.adapterId, structuredClone(value.candidate), replacing ? { id: value.generationId, replace: true } : undefined);
+            if (lease.ref.agentId !== value.adapterId)
+                throw new Error('Bridge transport authorization mismatch');
+            if (!this.#sessions.has(session) || session.peer.closed) {
+                throw new Error('Bridge transport closed during authorization');
+            }
+            session.lease = lease;
+            session.connection = this.#bridge.connect(lease);
+            session.connection.signal.addEventListener('abort', () => this.#closeSession(session), { once: true });
+            await this.#connected?.(lease, session.connection);
+            if (!this.#sessions.has(session) || session.peer.closed || session.connection.signal.aborted) {
+                throw new Error('Bridge transport closed while activating connection');
+            }
+            if (session.handshakeTimer)
+                clearTimeout(session.handshakeTimer);
+            session.handshakeTimer = undefined;
+            session.peer.maxBytes = Math.max(session.connection.limits.maxFrameBytes, session.connection.limits.maxSnapshotBytes) + WIRE_OVERHEAD_BYTES;
+            session.peer.send({
+                type: 'ready', protocolVersion: PROTOCOL_VERSION,
+                connectionId: session.connection.connectionId,
+                run: lease.ref,
+                limits: session.connection.limits,
+            });
+            return;
+        }
+        const connection = session.connection;
+        const id = value.id;
+        if (value.type === 'response') {
+            if (!bounded(value.requestId, 256))
+                throw new Error('Invalid Bridge response id');
+            const pending = session.pending.get(value.requestId);
+            if (!pending)
+                return;
+            session.pending.delete(value.requestId);
+            pending.detachAbort();
+            if (value.ok === true)
+                pending.resolve(value.value);
+            else
+                pending.reject(new Error(typeof value.error === 'string' ? value.error : 'Bridge handler failed'));
+            return;
+        }
+        if (value.type === 'snapshot') {
+            if (!bounded(id, 256) || !validChannelName(value.channel))
+                throw new Error('Invalid snapshot frame');
+            result(session.peer, id, await connection.channel(value.channel).setSnapshot(value.value));
+            return;
+        }
+        if (value.type === 'publish') {
+            if (!bounded(id, 256) || !validChannelName(value.channel) || !record(value.event)
+                || (value.delivery !== undefined && value.delivery !== 'ephemeral' && value.delivery !== 'durable')) {
+                throw new Error('Invalid publish frame');
+            }
+            result(session.peer, id, await connection.channel(value.channel).publish(value.event, value.delivery === undefined ? undefined : { delivery: value.delivery }));
+            return;
+        }
+        if (value.type === 'handle') {
+            if (!bounded(id, 256) || !validChannelName(value.channel) || !validChannelName(value.method)) {
+                throw new Error('Invalid handler frame');
+            }
+            const key = `${value.channel}\0${value.method}`;
+            if (session.unregister.has(key))
+                throw new Error('Bridge handler is already registered');
+            const unregister = connection.channel(value.channel).handle(value.method, (payload, context) => (this.#requestClient(session, value.channel, value.method, payload, context)));
+            session.unregister.set(key, unregister);
+            result(session.peer, id, { registered: true });
+            return;
+        }
+        if (value.type === 'unhandle') {
+            if (!bounded(id, 256) || !validChannelName(value.channel) || !validChannelName(value.method)) {
+                throw new Error('Invalid unhandle frame');
+            }
+            const key = `${value.channel}\0${value.method}`;
+            session.unregister.get(key)?.();
+            session.unregister.delete(key);
+            result(session.peer, id, { registered: false });
+            return;
+        }
+        throw new Error('Unsupported Bridge transport frame');
+    }
+    #requestClient(session, channel, method, payload, context) {
+        return new Promise((resolve, reject) => {
+            const cancel = () => {
+                if (!session.pending.delete(context.requestId))
+                    return;
+                try {
+                    session.peer.send({ type: 'cancel', requestId: context.requestId });
+                }
+                catch { /* closed */ }
+                reject(context.signal.reason instanceof Error ? context.signal.reason : new Error('Bridge request cancelled'));
+            };
+            context.signal.addEventListener('abort', cancel, { once: true });
+            session.pending.set(context.requestId, {
+                resolve, reject,
+                detachAbort: () => context.signal.removeEventListener('abort', cancel),
+            });
+            try {
+                session.peer.send({
+                    type: 'request', requestId: context.requestId, channel, method, payload,
+                    deadlineAt: context.deadlineAt,
+                });
+            }
+            catch (error) {
+                session.pending.delete(context.requestId);
+                context.signal.removeEventListener('abort', cancel);
+                reject(error);
+            }
+        });
+    }
+    #closeSession(session) {
+        if (!this.#sessions.delete(session))
+            return;
+        if (session.handshakeTimer)
+            clearTimeout(session.handshakeTimer);
+        session.handshakeTimer = undefined;
+        for (const unregister of session.unregister.values())
+            unregister();
+        session.unregister.clear();
+        for (const pending of session.pending.values()) {
+            pending.detachAbort();
+            pending.reject(new Error('Bridge transport closed'));
+        }
+        session.pending.clear();
+        session.connection?.close();
+        session.peer.close();
+    }
+}
+export async function connectBridgeTransport({ socketPath, authToken, adapterId, candidate, generation, connect = net.createConnection, newRequestId = crypto.randomUUID, handshakeTimeoutMs = DEFAULT_HANDSHAKE_TIMEOUT_MS, }) {
+    if (!path.isAbsolute(socketPath) || !bounded(authToken, 1024) || authToken.length < 32
+        || !NAME_RE.test(adapterId) || !validCandidate(candidate)
+        || (generation !== undefined && (!bounded(generation.id, 256) || generation.replace !== true))
+        || !Number.isSafeInteger(handshakeTimeoutMs) || handshakeTimeoutMs <= 0) {
+        throw new TypeError('Invalid Bridge transport client options');
+    }
+    const socket = connect(socketPath);
+    const abort = new AbortController();
+    const pending = new Map();
+    const handlers = new Map();
+    const handlerAborts = new Map();
+    let peer;
+    const nextId = () => {
+        for (let attempt = 0; attempt < 8; attempt += 1) {
+            const id = newRequestId();
+            if (bounded(id, 256) && !pending.has(id))
+                return id;
+        }
+        throw new Error('Unable to allocate Bridge wire request id');
+    };
+    const request = (value) => new Promise((resolve, reject) => {
+        const id = nextId();
+        pending.set(id, { resolve, reject });
+        try {
+            peer.send({ ...value, id });
+        }
+        catch (error) {
+            pending.delete(id);
+            reject(error);
+        }
+    });
+    let handshakeTimer;
+    let onHandshakeError;
+    let onHandshakeClose;
+    const opened = new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            if (handshakeTimer)
+                clearTimeout(handshakeTimer);
+            handshakeTimer = undefined;
+            if ('error' in outcome)
+                reject(outcome.error);
+            else
+                resolve(outcome.value);
+        };
+        onHandshakeError = (error) => finish({ error });
+        onHandshakeClose = () => finish({ error: new Error('Bridge transport closed during handshake') });
+        socket.once('error', onHandshakeError);
+        socket.once('close', onHandshakeClose);
+        peer = wirePeer(socket, MAX_HANDSHAKE_BYTES, (raw) => {
+            const value = record(raw);
+            if (!value || typeof value.type !== 'string') {
+                peer.close();
+                return;
+            }
+            if (value.type === 'challenge' && value.protocolVersion === PROTOCOL_VERSION
+                && bounded(value.nonce, 256)) {
+                peer.send({
+                    type: 'hello', protocolVersion: PROTOCOL_VERSION,
+                    proof: nonceProof(authToken, value.nonce),
+                    adapterId, candidate,
+                    ...(generation === undefined ? {} : {
+                        newGeneration: true,
+                        generationId: generation.id,
+                    }),
+                });
+                return;
+            }
+            if (value.type === 'ready') {
+                finish({ value });
+                return;
+            }
+            if (value.type === 'result' && bounded(value.id, 256)) {
+                const waiter = pending.get(value.id);
+                if (!waiter)
+                    return;
+                pending.delete(value.id);
+                if (value.ok === true)
+                    waiter.resolve(value.value);
+                else
+                    waiter.reject(new Error(typeof value.error === 'string' ? value.error : 'Bridge operation failed'));
+                return;
+            }
+            if (value.type === 'cancel' && bounded(value.requestId, 256)) {
+                handlerAborts.get(value.requestId)?.abort('server_cancelled');
+                handlerAborts.delete(value.requestId);
+                return;
+            }
+            if (value.type === 'request' && bounded(value.requestId, 256)
+                && validChannelName(value.channel) && validChannelName(value.method)
+                && typeof value.deadlineAt === 'number') {
+                const handler = handlers.get(`${value.channel}\0${value.method}`);
+                if (!handler) {
+                    peer.send({ type: 'response', requestId: value.requestId, ok: false, error: 'handler unavailable' });
+                    return;
+                }
+                const controller = new AbortController();
+                handlerAborts.set(value.requestId, controller);
+                Promise.resolve(handler(value.payload, {
+                    requestId: value.requestId,
+                    deadlineAt: value.deadlineAt,
+                    signal: controller.signal,
+                })).then((response) => {
+                    try {
+                        peer.send({ type: 'response', requestId: value.requestId, ok: true, value: response });
+                    }
+                    catch { /* request was cancelled or transport closed */ }
+                }, (error) => {
+                    try {
+                        peer.send({
+                            type: 'response', requestId: value.requestId, ok: false, error: errorMessage(error),
+                        });
+                    }
+                    catch { /* request was cancelled or transport closed */ }
+                }).finally(() => handlerAborts.delete(value.requestId)).catch(() => { });
+            }
+        });
+        handshakeTimer = setTimeout(() => {
+            finish({ error: new Error('Bridge transport handshake timed out') });
+            peer.close();
+        }, handshakeTimeoutMs);
+        handshakeTimer.unref?.();
+    });
+    const close = () => {
+        if (abort.signal.aborted)
+            return;
+        abort.abort('transport_closed');
+        peer.close();
+        for (const waiter of pending.values())
+            waiter.reject(new Error('Bridge transport closed'));
+        pending.clear();
+        for (const controller of handlerAborts.values())
+            controller.abort('transport_closed');
+        handlerAborts.clear();
+    };
+    socket.once('close', close);
+    let handshake;
+    try {
+        handshake = await opened;
+    }
+    catch (error) {
+        close();
+        throw error;
+    }
+    socket.removeListener('error', onHandshakeError);
+    socket.removeListener('close', onHandshakeClose);
+    socket.on('error', close);
+    if (handshake.protocolVersion !== PROTOCOL_VERSION
+        || !validRun(handshake.run, adapterId, candidate.paneId)
+        || !bounded(handshake.connectionId, 256) || !validLimits(handshake.limits)) {
+        close();
+        throw new Error('Invalid Bridge transport ready frame');
+    }
+    const limits = handshake.limits;
+    peer.maxBytes = Math.max(limits.maxFrameBytes, limits.maxSnapshotBytes) + WIRE_OVERHEAD_BYTES;
+    const channels = new Map();
+    return Object.freeze({
+        run: structuredClone(handshake.run),
+        connectionId: handshake.connectionId,
+        limits: structuredClone(limits),
+        signal: abort.signal,
+        channel(name) {
+            if (!validChannelName(name) || abort.signal.aborted)
+                throw new Error('Invalid or closed Bridge channel');
+            const existing = channels.get(name);
+            if (existing)
+                return existing;
+            const channel = Object.freeze({
+                setSnapshot: (value) => request({ type: 'snapshot', channel: name, value }),
+                publish: (event, options) => request({
+                    type: 'publish', channel: name, event,
+                    ...(options?.delivery === undefined ? {} : { delivery: options.delivery }),
+                }),
+                async handle(method, handler) {
+                    if (!validChannelName(method) || typeof handler !== 'function') {
+                        throw new Error('Invalid Bridge handler');
+                    }
+                    const key = `${name}\0${method}`;
+                    if (handlers.has(key))
+                        throw new Error('Bridge handler is already registered');
+                    handlers.set(key, handler);
+                    try {
+                        await request({ type: 'handle', channel: name, method });
+                    }
+                    catch (error) {
+                        handlers.delete(key);
+                        throw error;
+                    }
+                    return async () => {
+                        if (handlers.get(key) !== handler)
+                            return;
+                        handlers.delete(key);
+                        await request({ type: 'unhandle', channel: name, method });
+                    };
+                },
+            });
+            channels.set(name, channel);
+            return channel;
+        },
+        close,
+    });
+}

package/dist/src/agent-runtime/bridgeTypes.js

@@ -0,0 +1,13 @@
+export const DEFAULT_BRIDGE_LIMITS = Object.freeze({
+    maxFrameBytes: 256 * 1024,
+    maxSnapshotBytes: 1024 * 1024,
+    maxQueuedEventsPerChannel: 256,
+    maxQueuedBytesPerChannel: 4 * 1024 * 1024,
+    maxDurableSpoolBytesPerAdapter: 16 * 1024 * 1024,
+    maxRequestsPerRun: 32,
+    maxRequestsPerAdapter: 128,
+    defaultRequestTimeoutMs: 30_000,
+    maxRequestTimeoutMs: 5 * 60_000,
+    sustainedEventsPerSecond: 200,
+    burstEvents: 500,
+});