@ziggs-ai/api-client 0.1.4 → 0.1.5

package/dist/ConnectionManager.d.ts

@@ -25,6 +25,7 @@ export declare class ConnectionManager {
     private _entries;
     private _active;
     private _meta;
+    private _waking;
     constructor({ maxActive, idleTimeoutMs, control }?: ConnectionManagerOptions);
     register(id: string, openFn: OpenFn, closeFn: CloseFn, meta?: ConnectionManagerMeta): void;
     start(): void;

package/dist/ConnectionManager.js

@@ -8,6 +8,7 @@ export class ConnectionManager {
     _entries;
     _active;
     _meta;
+    _waking;
     constructor({ maxActive = 50, idleTimeoutMs = 60_000, control } = {}) {
         this.maxActive = maxActive;
         this.idleTimeoutMs = idleTimeoutMs;
@@ -16,6 +17,7 @@ export class ConnectionManager {
         this._entries = new Map();
         this._active = new Map();
         this._meta = new Map();
+        this._waking = new Map();
     }
     register(id, openFn, closeFn, meta) {
         if (!id)
@@ -48,15 +50,27 @@ export class ConnectionManager {
             this._resetTimer(id);
             return existing.handle;
         }
+        const pending = this._waking.get(id);
+        if (pending)
+            return pending;
         const entry = this._entries.get(id);
         if (!entry)
             throw new Error(`[ConnectionManager] unknown id: "${id}"`);
         if (this._active.size >= this.maxActive)
             await this._evictLRU();
-        const handle = await entry.openFn();
-        this._active.set(id, { handle, timer: null, lastActive: Date.now() });
-        this._scheduleIdle(id);
-        return handle;
+        const wakePromise = (async () => {
+            try {
+                const handle = await entry.openFn();
+                this._active.set(id, { handle, timer: null, lastActive: Date.now() });
+                this._scheduleIdle(id);
+                return handle;
+            }
+            finally {
+                this._waking.delete(id);
+            }
+        })();
+        this._waking.set(id, wakePromise);
+        return wakePromise;
     }
     async sleep(id) {
         const entry = this._active.get(id);

package/dist/http/AgreementClient.js

@@ -44,7 +44,9 @@ export async function proposeAgreement(proposalData, creds) {
     const headers = buildHeaders(creds);
     if (idempotencyKey)
         headers['Idempotency-Key'] = idempotencyKey;
-    const res = await fetch(`${getAgreementBaseUrl()}/propose`, {
+    // ZIG-207: canonical REST path. Backend keeps /propose serving the
+    // identical handler with a Deprecation/Sunset header until PR-F removes it.
+    const res = await fetch(`${getAgreementBaseUrl()}/proposals`, {
         method: 'POST',
         headers,
         body: JSON.stringify(bodyData),
@@ -55,7 +57,7 @@ export async function proposeAgreement(proposalData, creds) {
     }
     const data = await res.json().catch(() => null);
     if (!data?.['agreement']) {
-        throw new Error('Invalid response: expected { agreement } from /agreements/propose');
+        throw new Error('Invalid response: expected { agreement } from POST /agreements/proposals');
     }
     return data['agreement'];
 }
@@ -70,15 +72,26 @@ export async function proposeBroadcast(input, creds) {
 export async function delegateAgreement(proposalData, creds) {
     if (!proposalData)
         throw new Error('Proposal data is required for delegation');
+    if (!proposalData.parentAgreementId)
+        throw new Error('parentAgreementId is required for delegation');
     assertCreds(creds, 'proposal creation');
-    const { idempotencyKey, ...bodyData } = proposalData;
+    const { idempotencyKey, parentAgreementId } = proposalData;
     const headers = buildHeaders(creds);
     if (idempotencyKey)
         headers['Idempotency-Key'] = idempotencyKey;
-    const res = await fetch(`${getAgreementBaseUrl()}/delegate`, {
+    // ZIG-207 / ZIG-270: parentAgreementId in path AND body. Backend's
+    // `DelegateTaskDto` validates `parentAgreementId` as a required string;
+    // controller (`POST /agreements/:parentAgreementId/delegations`) merges
+    // path over body, so duplicating the value is harmless. Stripping it
+    // from the body (as ZIG-207 #72 did) trips DTO validation and returns
+    // `400: parentAgreementId must be a string` → infinite retry loop in
+    // `agreement_subcontract`. Send both, let the path win.
+    const bodyWithParent = { ...proposalData };
+    delete bodyWithParent.idempotencyKey;
+    const res = await fetch(`${getAgreementBaseUrl()}/${encodeURIComponent(parentAgreementId)}/delegations`, {
         method: 'POST',
         headers,
-        body: JSON.stringify(bodyData),
+        body: JSON.stringify(bodyWithParent),
     });
     if (!res.ok) {
         const body = await res.text().catch(() => '');
@@ -86,7 +99,7 @@ export async function delegateAgreement(proposalData, creds) {
     }
     const data = await res.json().catch(() => null);
     if (!data?.['agreement']) {
-        throw new Error('Invalid response: expected { agreement } from /agreements/delegate');
+        throw new Error('Invalid response: expected { agreement } from POST /agreements/:parentAgreementId/delegations');
     }
     return data['agreement'];
 }
@@ -154,7 +167,8 @@ export async function getAgreementStatus(agreementId, creds) {
 export async function listAgreements(filters = {}, creds) {
     assertCreds(creds, 'list agreements');
     try {
-        const url = new URL(`${getAgreementBaseUrl()}/list`);
+        // Canonical query path: GET /agreements?scope=&status=&engagementKind=&...
+        const url = new URL(getAgreementBaseUrl());
         if (filters.status)
             url.searchParams.set('status', filters.status);
         if (filters.engagementKind)
@@ -180,7 +194,10 @@ export async function listAgreements(filters = {}, creds) {
 export async function getMyAgreements(filters = {}, creds) {
     assertCreds(creds, 'get my agreements');
     try {
-        const url = new URL(`${getAgreementBaseUrl()}/mine`);
+        // Canonical query path: GET /agreements?scope=mine returns the enriched
+        // shape (tasks + originChatId + isYou flags).
+        const url = new URL(getAgreementBaseUrl());
+        url.searchParams.set('scope', 'mine');
         if (filters.engagementKind)
             url.searchParams.set('engagementKind', filters.engagementKind);
         if (filters.proposalStatus)
@@ -229,7 +246,8 @@ export async function createAgreement(body, creds) {
     if (!body)
         throw new Error('Body is required for agreement creation');
     assertCreds(creds, 'agreement creation');
-    const res = await fetch(`${getAgreementBaseUrl()}/create`, {
+    // Canonical REST create: POST /agreements.
+    const res = await fetch(getAgreementBaseUrl(), {
         method: 'POST',
         headers: buildHeaders(creds),
         body: JSON.stringify(body),
@@ -240,7 +258,7 @@ export async function createAgreement(body, creds) {
     }
     const data = await res.json().catch(() => null);
     if (!data?.['agreement']) {
-        throw new Error('Invalid response: expected { ok, agreement } from /agreements/create');
+        throw new Error('Invalid response: expected { ok, agreement } from POST /agreements');
     }
     return data;
 }
@@ -248,8 +266,10 @@ export async function revokeAgreement(agreementId, creds) {
     if (!agreementId)
         throw new Error('agreementId is required for revocation');
     assertCreds(creds, 'agreement revocation');
-    const res = await fetch(`${getAgreementBaseUrl()}/${agreementId}/revoke`, {
-        method: 'POST',
+    // ZIG-207: canonical REST verb. Legacy POST /agreements/:id/revoke stays
+    // serving the identical handler (with Deprecation headers) until PR-F.
+    const res = await fetch(`${getAgreementBaseUrl()}/${encodeURIComponent(agreementId)}`, {
+        method: 'DELETE',
         headers: buildHeaders(creds),
     });
     if (!res.ok) {
@@ -258,7 +278,7 @@ export async function revokeAgreement(agreementId, creds) {
     }
     const data = await res.json().catch(() => null);
     if (!data?.['agreement']) {
-        throw new Error('Invalid response: expected { ok, agreement } from /agreements/:id/revoke');
+        throw new Error('Invalid response: expected { ok, agreement } from DELETE /agreements/:id');
     }
     return data;
 }

package/dist/http/ChatClient.d.ts

@@ -11,4 +11,24 @@ export interface ChatSummary {
 export declare function openConversation(participantId: string, creds: Creds): Promise<{
     chatId: string;
 }>;
+export interface SendChatMessageInput {
+    chatId: string;
+    receiverId: string;
+    text: string;
+    messageId: string;
+    entryType?: string;
+    contentType?: string;
+    underAgreementId?: string;
+}
+export interface SendChatMessageResult {
+    success: boolean;
+    message: string;
+    messageId: string;
+    chatId: string;
+}
+/**
+ * POST /chats/:chatId/messages as an impersonated delegate agent.
+ * Requires operator token + X-Agent-Id (ZIG-222).
+ */
+export declare function sendChatMessage(input: SendChatMessageInput, creds: Creds): Promise<SendChatMessageResult>;
 export declare function listMyChats(creds: Creds): Promise<ChatSummary[]>;

package/dist/http/ChatClient.js

@@ -32,7 +32,8 @@ export async function openConversation(participantId, creds) {
     if (!participantId)
         throw new Error('participantId is required for openConversation');
     assertCreds(creds, 'open conversation');
-    const res = await fetch(`${getBackendUrl()}/chat/openConversation`, {
+    // Canonical REST: POST /chats with { participantId }, returns { chatId }.
+    const res = await fetch(`${getBackendUrl()}/chats`, {
         method: 'POST',
         headers: buildHeaders(creds),
         body: JSON.stringify({ participantId }),
@@ -43,15 +44,49 @@ export async function openConversation(participantId, creds) {
     }
     const data = await res.json().catch(() => null);
     if (!data?.['chatId'] || typeof data['chatId'] !== 'string') {
-        throw new Error('Invalid response: expected { chatId } from /chat/openConversation');
+        throw new Error('Invalid response: expected { chatId } from POST /chats');
     }
     return { chatId: data['chatId'] };
 }
+/**
+ * POST /chats/:chatId/messages as an impersonated delegate agent.
+ * Requires operator token + X-Agent-Id (ZIG-222).
+ */
+export async function sendChatMessage(input, creds) {
+    assertCreds(creds, 'send chat message');
+    const entryType = input.entryType ?? 'message';
+    const contentType = input.contentType ?? 'text';
+    const res = await fetch(`${getBackendUrl()}/chats/${encodeURIComponent(input.chatId)}/messages`, {
+        method: 'POST',
+        headers: buildHeaders(creds),
+        body: JSON.stringify({
+            chatId: input.chatId,
+            messageId: input.messageId,
+            text: input.text,
+            entryType,
+            contentType,
+            receiver: input.receiverId,
+            underAgreementId: input.underAgreementId,
+        }),
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throwApiError(res, body, `sendChatMessage failed: ${res.status} ${res.statusText}`);
+    }
+    const data = (await res.json().catch(() => null));
+    return {
+        success: Boolean(data?.['success']),
+        message: String(data?.['message'] ?? 'ok'),
+        messageId: String(data?.['messageId'] ?? input.messageId),
+        chatId: String(data?.['chatId'] ?? input.chatId),
+    };
+}
 export async function listMyChats(creds) {
     assertCreds(creds, 'list my chats');
     try {
-        const res = await fetch(`${getBackendUrl()}/chat/listMyChats`, {
-            method: 'POST',
+        // Canonical REST: GET /chats/mine.
+        const res = await fetch(`${getBackendUrl()}/chats/mine`, {
+            method: 'GET',
             headers: buildHeaders(creds),
         });
         if (!res.ok) {

package/dist/http/ContextDiscoveryClient.d.ts

@@ -0,0 +1,23 @@
+import 'dotenv/config';
+export interface ContextReachDescriptor {
+    grantId: string;
+    scope: {
+        kind: 'chat' | 'agreement' | 'org';
+        id: string;
+    };
+    temporal: 'from-now' | 'from-start';
+    watermarkAt: string;
+    expiresAt: string | null;
+    parentGrantId: string | null;
+    createdAt: string;
+}
+/**
+ * ZIG-412 discovery — scope descriptors only, no content.
+ */
+export declare class ContextDiscoveryClient {
+    private readonly operatorKey;
+    private readonly agentId;
+    private readonly baseUrl;
+    constructor(operatorKey: string, agentId: string, baseUrl?: string);
+    discover(): Promise<ContextReachDescriptor[]>;
+}

package/dist/http/ContextDiscoveryClient.js

@@ -0,0 +1,35 @@
+import 'dotenv/config';
+import { getBackendUrl } from '../utils/urlUtils.js';
+/**
+ * ZIG-412 discovery — scope descriptors only, no content.
+ */
+export class ContextDiscoveryClient {
+    operatorKey;
+    agentId;
+    baseUrl;
+    constructor(operatorKey, agentId, baseUrl) {
+        if (!operatorKey) {
+            throw new Error('ContextDiscoveryClient: operatorKey is required');
+        }
+        if (!agentId) {
+            throw new Error('ContextDiscoveryClient: agentId is required (operator-token impersonation)');
+        }
+        this.operatorKey = operatorKey;
+        this.agentId = agentId;
+        this.baseUrl = baseUrl || getBackendUrl();
+    }
+    async discover() {
+        const res = await fetch(`${this.baseUrl}/context/discovery`, {
+            headers: {
+                Authorization: `Bearer ${this.operatorKey}`,
+                'X-Agent-Id': this.agentId,
+            },
+        });
+        const body = await res.text().catch(() => '');
+        if (!res.ok) {
+            throw new Error(`ContextDiscoveryClient.discover ${res.status} ${body.slice(0, 200)}`);
+        }
+        const parsed = JSON.parse(body);
+        return parsed.reach ?? [];
+    }
+}

package/dist/http/ContextReadClient.d.ts

@@ -0,0 +1,33 @@
+import 'dotenv/config';
+export type ContextReadType = 'messages' | 'artifacts' | 'agreements' | 'tasks';
+export interface ContextReadQuery {
+    via: string;
+    cursor?: string;
+    limit?: number;
+    after?: string;
+    direction?: 'forward';
+    state?: string;
+    contextGrantId?: string;
+}
+export interface ContextReadEnvelope<T = unknown> {
+    type: ContextReadType;
+    via: {
+        kind: string;
+        id: string;
+    };
+    items: T[];
+    hasMore: boolean;
+    nextCursor: string | null;
+    latestSequence?: string | null;
+}
+/**
+ * Protocol-first uniform context reads (ZIG-427).
+ * Wraps `GET /context/read/:type` — one client, one envelope, four types.
+ */
+export declare class ContextReadClient {
+    private readonly operatorKey;
+    private readonly agentId;
+    private readonly baseUrl;
+    constructor(operatorKey: string, agentId: string, baseUrl?: string);
+    read<T = unknown>(type: ContextReadType, query: ContextReadQuery): Promise<ContextReadEnvelope<T>>;
+}

package/dist/http/ContextReadClient.js

@@ -0,0 +1,54 @@
+import 'dotenv/config';
+import { getBackendUrl } from '../utils/urlUtils.js';
+/**
+ * Protocol-first uniform context reads (ZIG-427).
+ * Wraps `GET /context/read/:type` — one client, one envelope, four types.
+ */
+export class ContextReadClient {
+    operatorKey;
+    agentId;
+    baseUrl;
+    constructor(operatorKey, agentId, baseUrl) {
+        if (!operatorKey)
+            throw new Error('ContextReadClient: operatorKey is required');
+        if (!agentId) {
+            throw new Error('ContextReadClient: agentId is required (operator-token impersonation)');
+        }
+        this.operatorKey = operatorKey;
+        this.agentId = agentId;
+        this.baseUrl = baseUrl || getBackendUrl();
+    }
+    async read(type, query) {
+        if (!query.via?.trim()) {
+            throw new Error('ContextReadClient.read: via is required');
+        }
+        const url = new URL(`${this.baseUrl}/context/read/${encodeURIComponent(type)}`);
+        url.searchParams.set('via', query.via.trim());
+        if (query.cursor)
+            url.searchParams.set('cursor', query.cursor);
+        if (query.limit != null)
+            url.searchParams.set('limit', String(query.limit));
+        if (query.after)
+            url.searchParams.set('after', query.after);
+        if (query.direction)
+            url.searchParams.set('direction', query.direction);
+        if (query.state)
+            url.searchParams.set('state', query.state);
+        if (query.contextGrantId) {
+            url.searchParams.set('contextGrantId', query.contextGrantId);
+        }
+        const headers = {
+            Authorization: `Bearer ${this.operatorKey}`,
+            'X-Agent-Id': this.agentId,
+        };
+        if (query.contextGrantId) {
+            headers['X-Context-Grant-Id'] = query.contextGrantId;
+        }
+        const res = await fetch(url.toString(), { headers });
+        const body = await res.text().catch(() => '');
+        if (!res.ok) {
+            throw new Error(`ContextReadClient.read ${type} ${res.status} ${body.slice(0, 200)}`);
+        }
+        return JSON.parse(body);
+    }
+}

package/dist/http/MessagesClient.d.ts

@@ -10,8 +10,12 @@ export interface ListMessagesResult {
     latestSequence: string | null;
 }
 /**
- * Read-side client for `GET /messages?chatId=&after=&limit=`. Replaces the
- * `history[]` slice of the old context blob.
+ * Read-side client for forward-delta message reads.
+ *
+ * Hits the canonical `GET /chats/:chatId/messages?after=&direction=forward&limit=`
+ * endpoint and returns a `{ messages, latestSequence }` envelope
+ * (`chat-messaging.controller.listMessagesForward` →
+ * `MessagesService.listForChat`).
  */
 export declare class MessagesClient {
     private readonly operatorKey;

package/dist/http/MessagesClient.js

@@ -1,8 +1,12 @@
 import 'dotenv/config';
 import { getBackendUrl } from '../utils/urlUtils.js';
 /**
- * Read-side client for `GET /messages?chatId=&after=&limit=`. Replaces the
- * `history[]` slice of the old context blob.
+ * Read-side client for forward-delta message reads.
+ *
+ * Hits the canonical `GET /chats/:chatId/messages?after=&direction=forward&limit=`
+ * endpoint and returns a `{ messages, latestSequence }` envelope
+ * (`chat-messaging.controller.listMessagesForward` →
+ * `MessagesService.listForChat`).
  */
 export class MessagesClient {
     operatorKey;
@@ -18,10 +22,14 @@ export class MessagesClient {
     async list(chatId, opts = {}) {
         if (!chatId)
             return { messages: [], latestSequence: null };
-        const url = new URL(`${getBackendUrl()}/messages`);
-        url.searchParams.set('chatId', chatId);
-        if (opts.after)
-            url.searchParams.set('after', opts.after);
+        const url = new URL(`${getBackendUrl()}/chats/${encodeURIComponent(chatId)}/messages`);
+        // Forward-delta read mode. Backend routes to `listMessagesForward`
+        // only when BOTH `after` and `direction=forward` are present; without
+        // `after` the same handler falls into backward pagination and returns
+        // a different envelope. Default `after` to the unix epoch so the
+        // forward branch always wins when callers want "from the beginning".
+        url.searchParams.set('direction', 'forward');
+        url.searchParams.set('after', opts.after || '1970-01-01T00:00:00.000Z');
         if (opts.limit != null)
             url.searchParams.set('limit', String(opts.limit));
         const res = await fetch(url.toString(), { headers: this._headers() });

package/dist/http/TaskClient.js

@@ -302,10 +302,19 @@ export async function setTaskSatisfaction(taskId, satisfaction, creds) {
 }
 export async function countTasks(filters = {}, creds) {
     assertCreds(creds, 'count tasks');
-    const res = await fetch(`${getTaskBaseUrl()}/countTasks`, {
-        method: 'POST',
+    // Canonical REST: GET /tasks/count.
+    const url = new URL(`${getTaskBaseUrl()}/count`);
+    if (filters.chatId)
+        url.searchParams.set('chatId', filters.chatId);
+    if (filters.state)
+        url.searchParams.set('state', filters.state);
+    if (filters.userId)
+        url.searchParams.set('userId', filters.userId);
+    if (filters.agentId)
+        url.searchParams.set('agentId', filters.agentId);
+    const res = await fetch(url.toString(), {
+        method: 'GET',
         headers: buildHeaders(creds),
-        body: JSON.stringify(filters),
     });
     if (!res.ok) {
         const body = await res.text().catch(() => '');

package/dist/http/index.d.ts

@@ -8,5 +8,9 @@ export { ArtifactsClient } from './ArtifactsClient.js';
 export type { ArtifactVisibility, ListArtifactsOptions, ListArtifactsQuery, ListArtifactsResult, WriteArtifactInput, } from './ArtifactsClient.js';
 export { ScopeClient } from './ScopeClient.js';
 export type { ScopeKind, ScopeResult, PartyRef } from './ScopeClient.js';
+export { ContextReadClient } from './ContextReadClient.js';
+export type { ContextReadType, ContextReadQuery, ContextReadEnvelope, } from './ContextReadClient.js';
+export { ContextDiscoveryClient } from './ContextDiscoveryClient.js';
+export type { ContextReachDescriptor } from './ContextDiscoveryClient.js';
 export { AgentSearchClient } from './AgentSearchClient.js';
 export { TelemetryClient } from './TelemetryClient.js';

package/dist/http/index.js

@@ -5,5 +5,7 @@ export * from './ChatClient.js';
 export { MessagesClient } from './MessagesClient.js';
 export { ArtifactsClient } from './ArtifactsClient.js';
 export { ScopeClient } from './ScopeClient.js';
+export { ContextReadClient } from './ContextReadClient.js';
+export { ContextDiscoveryClient } from './ContextDiscoveryClient.js';
 export { AgentSearchClient } from './AgentSearchClient.js';
 export { TelemetryClient } from './TelemetryClient.js';

package/dist/types.d.ts

@@ -49,11 +49,19 @@ export interface Agreement {
     engagementKind?: EngagementKind;
     proposalStatus?: ProposalStatus;
     parties?: {
-        proposedToId?: string;
-        providerId?: string;
-        payerId?: string;
+        proposedTo?: string;
+        provider?: string;
+        payer?: string;
+        creator?: string;
+        creatorAgent?: string;
+    };
+    /** Legacy root-level price — always null in practice. Use money.price instead. */
+    price?: number | null;
+    /** Price and payment state. price is in cents (e.g. 6000 = 6000 KRW). */
+    money?: {
+        price?: number | null;
+        paymentStatus?: string;
     };
-    price?: number;
     lifecycle?: string;
     expiresAt?: string;
     maxExecutions?: number;
@@ -87,7 +95,7 @@ export declare const ContentTypes: {
 export type ContentType = (typeof ContentTypes)[keyof typeof ContentTypes];
 /** ⚠️ SYNC: Mirrors backend src/chat/chat.types.ts isValidContentType */
 export declare function isValidContentType(contentType: string, entryType: string): boolean;
-/** ⚠️ SYNC: Keep in sync with backend and agent-sdk/src/tasks/taskCore.js */
+/** ⚠️ SYNC: Keep in sync with backend. This is the canonical SDK-side definition. */
 export declare const OPEN_AGREEMENT_TARGET: "everyone";
 export interface MessageMetadata {
     chatId: string;
@@ -111,10 +119,12 @@ export interface MessageMetadata {
      * `normalizeIncomingEvent` reads `metadata.task` to upgrade structured
      * task notifications into `task_result` events (so executors see
      * `task-assigned` outcomes when the orchestrator calls `task_spawn`),
-     * and the agent FSM treats `metadata.agreement` as the source of truth
-     * for proposal lifecycle without needing a separate fetch.
+     * and maps explicit wire `operation` + `agreementId` lifecycle fields
+     * into `agreement_lifecycle` events for proposal approve/reject.
      */
     task?: Record<string, unknown> | null;
     agreement?: Record<string, unknown> | null;
+    operation?: string | null;
+    agreementId?: string | null;
 }
 export type MessageHandler = (text: string, metadata: MessageMetadata) => Promise<void>;

package/dist/types.js

@@ -46,5 +46,5 @@ const VALID_CONTENT_TYPES = {
 export function isValidContentType(contentType, entryType) {
     return VALID_CONTENT_TYPES[entryType]?.includes(contentType) ?? false;
 }
-/** ⚠️ SYNC: Keep in sync with backend and agent-sdk/src/tasks/taskCore.js */
+/** ⚠️ SYNC: Keep in sync with backend. This is the canonical SDK-side definition. */
 export const OPEN_AGREEMENT_TARGET = 'everyone';

package/dist/websocket/ControlSocket.js

@@ -14,7 +14,8 @@ export function createControlSocket({ wsUrl, operatorKey, agentIds, onWake }) {
         transports: ['websocket'],
         reconnection: true,
         reconnectionDelay: 1000,
-        reconnectionDelayMax: 5000,
+        reconnectionDelayMax: 30000,
+        randomizationFactor: 0.5,
     });
     socket.on('connect', () => {
         const ids = agentIds();