doover-js 0.5.4 → 0.6.1

package/dist/react/useChannelSubscription.js

@@ -18,24 +18,14 @@ function useChannelSubscription(identifier, handlers) {
     (0, react_1.useEffect)(() => {
         if (!identifier?.agentId || !identifier?.channelName)
             return;
-        const messageCallback = (_id, message) => {
-            handlersRef.current.onMessage?.(message);
-        };
-        const aggregateCallback = (_id, aggregate) => {
-            handlersRef.current.onAggregate?.(aggregate);
-        };
-        const messageUpdateCallback = (_id, message, request_data) => {
-            handlersRef.current.onMessageUpdate?.(message, request_data);
-        };
-        void client.viewer.subscribeToChannel(identifier, messageCallback, aggregateCallback, messageUpdateCallback);
-        return () => {
-            client.viewer
-                .unsubscribeFromChannel(identifier, messageCallback)
-                .catch(() => {
-                // Already unsubscribed — race between strict-mode double-effect
-                // and async subscribe is harmless.
-            });
-        };
+        const channel = { agent_id: identifier.agentId, name: identifier.channelName };
+        const off = client.gateway.subscribeToChannel(channel, {
+            onMessage: (msg) => handlersRef.current.onMessage?.(msg),
+            onMessageUpdate: (msg, rd) => handlersRef.current.onMessageUpdate?.(msg, rd),
+            onAggregate: (agg) => handlersRef.current.onAggregate?.(agg),
+        });
+        void client.gateway.connect();
+        return () => off();
         // Identifier fields are the real deps; we intentionally leave `handlers`
         // out because it's read through handlersRef.
         // eslint-disable-next-line react-hooks/exhaustive-deps

package/dist/react/useClientStatus.d.ts

@@ -0,0 +1,10 @@
+import type { DataClientStatus } from "../client/data-client";
+/**
+ * Returns the live `DataClientStatus` for the client in context. Seeds with
+ * `client.getStatus()`, subscribes via `client.onStatusChange(...)` for the
+ * component's lifetime. Works for a `DooverClient` (single-source) or a
+ * `MultiplexClient` (rolled-up status with a `members` breakdown). Prefer this
+ * over `useConnectionState` for new code — it carries session, latency, last
+ * error and per-source state.
+ */
+export declare function useClientStatus(): DataClientStatus;

package/dist/react/useClientStatus.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useClientStatus = useClientStatus;
+const react_1 = require("react");
+const context_1 = require("./context");
+/**
+ * Returns the live `DataClientStatus` for the client in context. Seeds with
+ * `client.getStatus()`, subscribes via `client.onStatusChange(...)` for the
+ * component's lifetime. Works for a `DooverClient` (single-source) or a
+ * `MultiplexClient` (rolled-up status with a `members` breakdown). Prefer this
+ * over `useConnectionState` for new code — it carries session, latency, last
+ * error and per-source state.
+ */
+function useClientStatus() {
+    const client = (0, context_1.useDooverClient)();
+    const [status, setStatus] = (0, react_1.useState)(() => client.getStatus());
+    (0, react_1.useEffect)(() => {
+        setStatus(client.getStatus());
+        return client.onStatusChange(setStatus);
+    }, [client]);
+    return status;
+}

package/dist/react/useConnectionState.d.ts

@@ -9,6 +9,11 @@ export interface ConnectionState {
     lastOpenedAt: number | null;
 }
 /**
+ * @deprecated Prefer `useClientStatus()` — it works for both `DooverClient` and
+ * `MultiplexClient`, and carries session, latency, last error and per-source
+ * state. `useConnectionState` is gateway-flavoured and single-source only;
+ * it will remain but new code should not use it.
+ *
  * Subscribes to the gateway's connection lifecycle and returns a snapshot
  * suitable for a connection-indicator UI.
  *

package/dist/react/useConnectionState.js

@@ -8,6 +8,11 @@ const INITIAL = {
     lastOpenedAt: null,
 };
 /**
+ * @deprecated Prefer `useClientStatus()` — it works for both `DooverClient` and
+ * `MultiplexClient`, and carries session, latency, last error and per-source
+ * state. `useConnectionState` is gateway-flavoured and single-source only;
+ * it will remain but new code should not use it.
+ *
  * Subscribes to the gateway's connection lifecycle and returns a snapshot
  * suitable for a connection-indicator UI.
  *

package/dist/react/useMultiAgentAggregates.d.ts

@@ -1,6 +1,6 @@
 import { type UseQueryResult } from "@tanstack/react-query";
 import type { Aggregate, JSONValue, AgentAggregate } from "../types/common";
-export declare function multiAgentAggregatesQueryKey(channelName: string, agentIds: string[], fields?: readonly string[]): readonly ["doover", "channel", string, "aggregates", string] | readonly ["doover", "channel", string, "aggregates", string, {
+export declare function multiAgentAggregatesQueryKey(channelName: string, agentIds: string[], fields?: readonly string[], sources?: string[]): readonly ["doover", "channel", string, "aggregates", string, "src", string] | readonly ["doover", "channel", string, "aggregates", string, "src", string, {
     readonly fields: string[];
 }];
 export interface UseMultiAgentAggregatesOptions {
@@ -14,6 +14,13 @@ export interface UseMultiAgentAggregatesOptions {
      * pushes whatever it has, so consumers should still tolerate the full shape.
      */
     fields?: string[];
+    /**
+     * Restrict to these source ids on a `MultiplexClient`. Ignored for a plain
+     * `DooverClient` or `LocalAgentClient`. When set, the query key is
+     * source-dimensioned so data from different source subsets is cached
+     * independently.
+     */
+    sources?: string[];
 }
 export interface UseMultiAgentAggregatesResult<TData> {
     /** Keyed by `agent_id` for O(1) lookup. */

package/dist/react/useMultiAgentAggregates.js

@@ -6,13 +6,16 @@ const react_1 = require("react");
 const react_query_1 = require("@tanstack/react-query");
 const context_1 = require("./context");
 const useChannelAggregate_1 = require("./useChannelAggregate");
-function multiAgentAggregatesQueryKey(channelName, agentIds, fields) {
+function multiAgentAggregatesQueryKey(channelName, agentIds, fields, sources) {
+    const sourceDim = sources && sources.length ? [...sources].sort().join(",") : "*";
     const base = [
         "doover",
         "channel",
         channelName,
         "aggregates",
         [...agentIds].sort().join(","),
+        "src",
+        sourceDim,
     ];
     return fields && fields.length > 0
         ? [...base, { fields: [...fields].sort() }]
@@ -27,24 +30,31 @@ function useMultiAgentAggregates(channelName, agentIds, options) {
     const client = (0, context_1.useDooverClient)();
     const queryClient = (0, react_query_1.useQueryClient)();
     const liveUpdates = options?.liveUpdates ?? true;
+    const sources = options?.sources;
     const fields = options?.fields;
-    const key = multiAgentAggregatesQueryKey(channelName, agentIds, fields);
+    const key = multiAgentAggregatesQueryKey(channelName, agentIds, fields, sources);
     const query = (0, react_query_1.useQuery)({
         queryKey: key,
         enabled: agentIds.length > 0,
         staleTime: Infinity,
         queryFn: async () => {
-            const response = await client.agents.getMultiAgentAggregates(channelName, {
+            const params = {
                 agent_id: agentIds,
                 ...(fields && fields.length > 0 ? { field_name: fields } : {}),
-            });
+            };
+            // Pass `{ sources }` as a trailing bag only when set — cast through
+            // `never` since the TypeScript overloads don't declare it.
+            const sourcesArg = sources ? { sources } : undefined;
+            const response = await (sourcesArg
+                ? client.agents.getMultiAgentAggregates(channelName, params, sourcesArg)
+                : client.agents.getMultiAgentAggregates(channelName, params));
             // Seed the per-agent `channelAggregateQueryKey` cache so that
             // sibling `useChannelAggregate(id, channelName)` calls for any
             // of these agents get an instant cache hit rather than issuing
             // a second fetch for data we already have.
             for (const result of response.results) {
                 const { agent_id, ...aggregate } = result;
-                queryClient.setQueryData((0, useChannelAggregate_1.channelAggregateQueryKey)(agent_id, channelName), aggregate);
+                queryClient.setQueryData((0, useChannelAggregate_1.channelAggregateQueryKey)(agent_id, channelName, sources), aggregate);
             }
             return response;
         },
@@ -65,29 +75,23 @@ function useMultiAgentAggregates(channelName, agentIds, options) {
         });
         // Mirror live updates into the per-agent cache so sibling
         // `useChannelAggregate` consumers see them too.
-        queryClient.setQueryData((0, useChannelAggregate_1.channelAggregateQueryKey)(agentId, channelName), aggregate);
+        queryClient.setQueryData((0, useChannelAggregate_1.channelAggregateQueryKey)(agentId, channelName, sources), aggregate);
     }, 
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [queryClient, channelName, agentIds.join(",")]);
+    [queryClient, channelName, agentIds.join(","), sources?.join(",")]);
     (0, react_1.useEffect)(() => {
         if (!liveUpdates || agentIds.length === 0)
             return;
-        const noopMessage = () => { };
-        const subscriptions = agentIds.map((agentId) => {
-            const identifier = { agentId, channelName };
-            const messageCallback = noopMessage;
-            const aggregateCallback = (_id, aggregate) => {
-                patchAgentAggregate(agentId, aggregate);
-            };
-            void client.viewer.subscribeToChannel(identifier, messageCallback, aggregateCallback);
-            return { identifier, messageCallback };
+        const offs = agentIds.map((agentId) => {
+            const channel = { agent_id: agentId, name: channelName };
+            return client.gateway.subscribeToChannel(channel, {
+                onAggregate: (agg) => patchAgentAggregate(agentId, agg),
+            });
         });
+        void client.gateway.connect();
         return () => {
-            for (const { identifier, messageCallback } of subscriptions) {
-                client.viewer
-                    .unsubscribeFromChannel(identifier, messageCallback)
-                    .catch(() => { });
-            }
+            for (const off of offs)
+                off();
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [client, channelName, liveUpdates, agentIds.join(",")]);

package/dist/react/useMultiAgentChannelMessages.d.ts

@@ -1,6 +1,9 @@
 import { type InfiniteData, type UseInfiniteQueryResult } from "@tanstack/react-query";
 import type { MessageStructure } from "../types/common";
-export declare function multiAgentChannelMessagesQueryKey(channelName: string, agentIds: string[]): readonly ["doover", "channel", string, "messages", string];
+export declare function multiAgentChannelMessagesQueryKey(channelName: string, agentIds: string[], sources?: string[], scope?: {
+    after?: string;
+    fields?: readonly string[];
+}): readonly ["doover", "channel", string, "messages", string, "src", string] | readonly ["doover", "channel", string, "messages", string, "src", string, Record<string, unknown>];
 export interface UseMultiAgentChannelMessagesOptions {
     limit?: number;
     /** If false, skip live subscriptions per agent. Defaults true. */
@@ -12,6 +15,21 @@ export interface UseMultiAgentChannelMessagesOptions {
     fields?: string[];
     /** Optional first-page `before` cursor (snowflake id). */
     initialBefore?: string;
+    /**
+     * Optional lower-bound snowflake id. Forwarded server-side so each
+     * agent's pagination stops on its own once it walks past the bound —
+     * mirrors `useChannelMessages`'s `after`. Use this to fetch a bounded
+     * time window (e.g. last 24h) across many agents without filtering
+     * on the client.
+     */
+    after?: string;
+    /**
+     * Restrict to these source ids on a `MultiplexClient`. Ignored for a plain
+     * `DooverClient` or `LocalAgentClient`. When set, the query key is
+     * source-dimensioned so data from different source subsets is cached
+     * independently.
+     */
+    sources?: string[];
 }
 interface Page<TData> {
     results: MessageStructure<TData>[];

package/dist/react/useMultiAgentChannelMessages.js

@@ -5,14 +5,30 @@ exports.useMultiAgentChannelMessages = useMultiAgentChannelMessages;
 const react_1 = require("react");
 const react_query_1 = require("@tanstack/react-query");
 const context_1 = require("./context");
-function multiAgentChannelMessagesQueryKey(channelName, agentIds) {
-    return [
+function multiAgentChannelMessagesQueryKey(channelName, agentIds, sources, scope) {
+    const sourceDim = sources && sources.length ? [...sources].sort().join(",") : "*";
+    const base = [
         "doover",
         "channel",
         channelName,
         "messages",
         [...agentIds].sort().join(","),
+        "src",
+        sourceDim,
     ];
+    // Pagination cursors come from the first page's response and are scoped
+    // to *that* response's `after`/`fields`. Mixing them under one cache
+    // entry would cause `getNextPageParam` to anchor on an unrelated page,
+    // so a differently-bounded request must live under its own key.
+    const scopeKey = {};
+    if (scope?.after)
+        scopeKey.after = scope.after;
+    if (scope?.fields && scope.fields.length > 0) {
+        scopeKey.fields = [...scope.fields].sort();
+    }
+    return Object.keys(scopeKey).length > 0
+        ? [...base, scopeKey]
+        : base;
 }
 function useMultiAgentChannelMessages(channelName, agentIds, options) {
     const client = (0, context_1.useDooverClient)();
@@ -21,7 +37,12 @@ function useMultiAgentChannelMessages(channelName, agentIds, options) {
     const liveUpdates = options?.liveUpdates ?? true;
     const fields = options?.fields;
     const initialBefore = options?.initialBefore;
-    const key = multiAgentChannelMessagesQueryKey(channelName, agentIds);
+    const sources = options?.sources;
+    const after = options?.after;
+    const key = multiAgentChannelMessagesQueryKey(channelName, agentIds, sources, {
+        after,
+        fields,
+    });
     const prependMessage = (0, react_1.useCallback)((message) => {
         queryClient.setQueryData(key, (current) => {
             if (!current)
@@ -39,25 +60,20 @@ function useMultiAgentChannelMessages(channelName, agentIds, options) {
         });
     }, 
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [queryClient, channelName, agentIds.join(",")]);
+    [queryClient, channelName, agentIds.join(","), sources?.join(",")]);
     (0, react_1.useEffect)(() => {
         if (!liveUpdates || agentIds.length === 0)
             return;
-        const subscriptions = agentIds.map((agentId) => {
-            const identifier = { agentId, channelName };
-            const messageCallback = (_id, message) => {
-                prependMessage(message);
-            };
-            const aggregateCallback = () => { };
-            void client.viewer.subscribeToChannel(identifier, messageCallback, aggregateCallback);
-            return { identifier, messageCallback };
+        const offs = agentIds.map((agentId) => {
+            const channel = { agent_id: agentId, name: channelName };
+            return client.gateway.subscribeToChannel(channel, {
+                onMessage: (msg) => prependMessage(msg),
+            });
         });
+        void client.gateway.connect();
         return () => {
-            for (const { identifier, messageCallback } of subscriptions) {
-                client.viewer
-                    .unsubscribeFromChannel(identifier, messageCallback)
-                    .catch(() => { });
-            }
+            for (const off of offs)
+                off();
         };
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [client, channelName, liveUpdates, agentIds.join(",")]);
@@ -68,12 +84,19 @@ function useMultiAgentChannelMessages(channelName, agentIds, options) {
         initialPageParam: initialBefore,
         getNextPageParam: (lastPage) => lastPage?.next,
         queryFn: async ({ pageParam }) => {
-            const page = await client.agents.getMultiAgentMessages(channelName, {
+            const params = {
                 agent_id: agentIds,
                 ...(typeof pageParam === "string" ? { before: pageParam } : {}),
                 ...(limit !== undefined ? { limit } : {}),
                 ...(fields && fields.length > 0 ? { field_name: fields } : {}),
-            });
+                ...(after !== undefined ? { after } : {}),
+            };
+            // Pass `{ sources }` as a trailing bag only when set — cast through
+            // `never` since the TypeScript overloads don't declare it.
+            const sourcesArg = sources ? { sources } : undefined;
+            const page = await (sourcesArg
+                ? client.agents.getMultiAgentMessages(channelName, params, sourcesArg)
+                : client.agents.getMultiAgentMessages(channelName, params));
             return page;
         },
     });

package/dist/react/useSendMessage.d.ts

@@ -1,9 +1,16 @@
 import { type UseMutationResult } from "@tanstack/react-query";
 import type { MessageStructure } from "../types/common";
 import type { ChannelIdentifier } from "../types/viewer";
+export interface UseSendMessageOptions {
+    /**
+     * Restrict the write to these source ids on a `MultiplexClient`. Ignored
+     * for a plain `DooverClient` or `LocalAgentClient`.
+     */
+    sources?: string[];
+}
 /**
  * Mutation wrapping `DooverDataProvider.sendMessage`. Posts a JSON message
  * to the channel and resolves with the created `MessageStructure` (including
  * its server-assigned `id` and `timestamp`).
  */
-export declare function useSendMessage<TData extends object = object>(identifier: ChannelIdentifier): UseMutationResult<MessageStructure<TData>, Error, TData>;
+export declare function useSendMessage<TData extends object = object>(identifier: ChannelIdentifier, options?: UseSendMessageOptions): UseMutationResult<MessageStructure<TData>, Error, TData>;

package/dist/react/useSendMessage.js

@@ -8,9 +8,22 @@ const context_1 = require("./context");
  * to the channel and resolves with the created `MessageStructure` (including
  * its server-assigned `id` and `timestamp`).
  */
-function useSendMessage(identifier) {
+function useSendMessage(identifier, options) {
     const client = (0, context_1.useDooverClient)();
+    const sources = options?.sources;
     return (0, react_query_1.useMutation)({
-        mutationFn: (data) => client.viewer.sendMessage(identifier, data),
+        mutationFn: (data) => {
+            if (!identifier.agentId || !identifier.channelName) {
+                return Promise.reject(new Error("Identifier must include agentId and channelName"));
+            }
+            const id = { agentId: identifier.agentId, channelName: identifier.channelName };
+            const body = { data: data };
+            // Pass `{ sources }` as a trailing bag only when set — cast through
+            // `never` since the TypeScript overloads don't declare it.
+            const sourcesArg = sources ? { sources } : undefined;
+            return (sourcesArg
+                ? client.messages.postMessage(id, body, sourcesArg)
+                : client.messages.postMessage(id, body));
+        },
     });
 }

package/dist/react/useSendRpc.js

@@ -115,7 +115,10 @@ function useSendRpc(identifier, options) {
                         ? { app_key: options.app_key }
                         : {}),
             };
-            return client.viewer.sendRPC(identifier, rpcRequest, {
+            if (!identifier.agentId || !identifier.channelName) {
+                throw new Error("Identifier must include agentId and channelName");
+            }
+            return client.rpc.send({ agentId: identifier.agentId, channelName: identifier.channelName }, rpcRequest, {
                 onStatus: (status) => appendStatus(commandId, status),
             });
         },

package/dist/react/useUpdateAggregate.d.ts

@@ -11,6 +11,12 @@ export interface UseUpdateAggregateOptions {
      * `suppress_response`. See `AggregateMutationParams`.
      */
     params?: AggregateMutationParams;
+    /**
+     * Restrict the write to these source ids on a `MultiplexClient`. Ignored
+     * for a plain `DooverClient` or `LocalAgentClient`. Also scopes the
+     * react-query cache invalidation to the matching source-dimensioned key.
+     */
+    sources?: string[];
 }
 /**
  * Mutation wrapping `DooverDataProvider.updateAggregate` (PATCH) or

package/dist/react/useUpdateAggregate.js

@@ -15,12 +15,28 @@ function useUpdateAggregate(identifier, options) {
     const queryClient = (0, react_query_1.useQueryClient)();
     const replace = options?.replace ?? false;
     const params = options?.params;
+    const sources = options?.sources;
     return (0, react_query_1.useMutation)({
-        mutationFn: (data) => (replace
-            ? client.viewer.putAggregate(identifier, data, params)
-            : client.viewer.updateAggregate(identifier, data, params)),
+        mutationFn: (data) => {
+            if (!identifier.agentId || !identifier.channelName) {
+                return Promise.reject(new Error("Identifier must include agentId and channelName"));
+            }
+            const id = { agentId: identifier.agentId, channelName: identifier.channelName };
+            const body = data;
+            // Pass `{ sources }` as a trailing bag only when set — cast through
+            // `never` since the TypeScript overloads don't declare it.
+            const sourcesArg = sources ? { sources } : undefined;
+            if (replace) {
+                return (sourcesArg
+                    ? client.aggregates.putAggregate(id, body, params, sourcesArg)
+                    : client.aggregates.putAggregate(id, body, params));
+            }
+            return (sourcesArg
+                ? client.aggregates.patchAggregate(id, body, params, sourcesArg)
+                : client.aggregates.patchAggregate(id, body, params));
+        },
         onSuccess: (aggregate) => {
-            queryClient.setQueryData((0, useChannelAggregate_1.channelAggregateQueryKey)(identifier.agentId, identifier.channelName), aggregate);
+            queryClient.setQueryData((0, useChannelAggregate_1.channelAggregateQueryKey)(identifier.agentId, identifier.channelName, sources), aggregate);
         },
     });
 }

package/dist/react/useUpdateMessage.d.ts

@@ -14,6 +14,11 @@ export interface UpdateMessageCallOptions {
     params?: MessageMutationParams;
 }
 export interface UseUpdateMessageOptions extends UpdateMessageCallOptions {
+    /**
+     * Restrict the write to these source ids on a `MultiplexClient`. Ignored
+     * for a plain `DooverClient` or `LocalAgentClient`.
+     */
+    sources?: string[];
 }
 export interface UpdateMessageVariables<TBody extends MessageBody = MessageBody> {
     messageId: string;

package/dist/react/useUpdateMessage.js

@@ -13,6 +13,7 @@ function useUpdateMessage(identifier, options) {
     const client = (0, context_1.useDooverClient)();
     const defaultReplace = options?.replace ?? false;
     const defaultParams = options?.params;
+    const sources = options?.sources;
     return (0, react_query_1.useMutation)({
         mutationFn: ({ messageId, body, options: call, }) => {
             if (!identifier.agentId || !identifier.channelName) {
@@ -22,8 +23,16 @@ function useUpdateMessage(identifier, options) {
             const params = call?.params || defaultParams
                 ? { ...defaultParams, ...call?.params }
                 : undefined;
-            return replace
-                ? client.messages.putMessage(identifier.agentId, identifier.channelName, messageId, body, params)
+            // Pass `{ sources }` as a trailing bag only when set — cast through
+            // `never` since the TypeScript overloads don't declare it.
+            const sourcesArg = sources ? { sources } : undefined;
+            if (replace) {
+                return sourcesArg
+                    ? client.messages.putMessage(identifier.agentId, identifier.channelName, messageId, body, params, sourcesArg)
+                    : client.messages.putMessage(identifier.agentId, identifier.channelName, messageId, body, params);
+            }
+            return sourcesArg
+                ? client.messages.patchMessage(identifier.agentId, identifier.channelName, messageId, body, params, sourcesArg)
                 : client.messages.patchMessage(identifier.agentId, identifier.channelName, messageId, body, params);
         },
     });

package/dist/rpc/errors.d.ts

@@ -0,0 +1,10 @@
+import type { RpcRequest, RpcStatus } from "../types/common";
+export declare class DooverRpcError extends Error {
+    readonly status: RpcStatus<unknown> & {
+        code: "error";
+    };
+    readonly request: RpcRequest;
+    constructor(status: RpcStatus<unknown> & {
+        code: "error";
+    }, request: RpcRequest);
+}

package/dist/rpc/errors.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DooverRpcError = void 0;
+class DooverRpcError extends Error {
+    constructor(status, request) {
+        const text = typeof status.message === "string"
+            ? status.message
+            : (() => {
+                try {
+                    return JSON.stringify(status.message);
+                }
+                catch {
+                    return "Unknown RPC error";
+                }
+            })();
+        super(text);
+        this.name = "DooverRpcError";
+        this.status = status;
+        this.request = request;
+        Object.setPrototypeOf(this, DooverRpcError.prototype);
+    }
+}
+exports.DooverRpcError = DooverRpcError;

package/dist/rpc/rpc-dispatcher.d.ts

@@ -0,0 +1,28 @@
+import type { MessagesApi } from "../apis/messages-api";
+import type { DooverStatsCollector } from "../client/stats";
+import type { GatewayClient } from "../gateway/gateway-client";
+import type { RpcRequest, RpcStatus } from "../types/common";
+export interface SendRpcOptions<TPending = undefined> {
+    onStatus?: (status: RpcStatus<TPending>) => void;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+interface ChannelIdentifierLike {
+    agentId: string;
+    channelName: string;
+}
+export declare class RpcDispatcher {
+    private readonly gateway;
+    private readonly messages;
+    private pending;
+    private channelRefs;
+    private stats;
+    constructor(gateway: GatewayClient, messages: MessagesApi);
+    setStats(collector: DooverStatsCollector | null): void;
+    send<TReq = object, TRes = object, TPending = undefined>(channel: ChannelIdentifierLike, request: RpcRequest<TReq>, options?: SendRpcOptions<TPending>): Promise<TRes>;
+    private acquireChannel;
+    private releaseChannel;
+    private route;
+    private settle;
+}
+export {};