doover-js 0.4.7 → 0.5.0-alpha.0

package/dist/test/api-overloads.test.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRestStub = makeRestStub;
+const chai_1 = require("chai");
+const channels_api_1 = require("../apis/channels-api");
+const messages_api_1 = require("../apis/messages-api");
+function makeRestStub() {
+    const calls = [];
+    const stub = {
+        calls,
+        get: (...args) => {
+            calls.push({ method: "get", args });
+            return Promise.resolve([]);
+        },
+        post: (...args) => {
+            calls.push({ method: "post", args });
+            return Promise.resolve(undefined);
+        },
+        put: (...args) => {
+            calls.push({ method: "put", args });
+            return Promise.resolve(undefined);
+        },
+        patch: (...args) => {
+            calls.push({ method: "patch", args });
+            return Promise.resolve(undefined);
+        },
+        delete: (...args) => {
+            calls.push({ method: "delete", args });
+            return Promise.resolve(undefined);
+        },
+        request: (...args) => {
+            calls.push({ method: "request", args });
+            return Promise.resolve(undefined);
+        },
+    };
+    return stub;
+}
+describe("ChannelsApi overloads", () => {
+    it("getChannel positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new channels_api_1.ChannelsApi(restA);
+        const apiB = new channels_api_1.ChannelsApi(restB);
+        await apiA.getChannel("a1", "c1", { include_aggregate: true });
+        await apiB.getChannel({ agentId: "a1", channelName: "c1" }, { include_aggregate: true });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+    it("listChannels positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new channels_api_1.ChannelsApi(restA);
+        const apiB = new channels_api_1.ChannelsApi(restB);
+        await apiA.listChannels("a1", { include_archived: true });
+        await apiB.listChannels({ agentId: "a1" }, { include_archived: true });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+    it("archiveChannel posts to /archive", async () => {
+        const rest = makeRestStub();
+        const api = new channels_api_1.ChannelsApi(rest);
+        await api.archiveChannel("a1", "c1");
+        (0, chai_1.expect)(rest.calls).to.deep.equal([
+            { method: "post", args: ["/agents/a1/channels/c1/archive", {}] },
+        ]);
+    });
+    it("unarchiveChannel posts to /unarchive", async () => {
+        const rest = makeRestStub();
+        const api = new channels_api_1.ChannelsApi(rest);
+        await api.unarchiveChannel({ agentId: "a1", channelName: "c1" });
+        (0, chai_1.expect)(rest.calls).to.deep.equal([
+            { method: "post", args: ["/agents/a1/channels/c1/unarchive", {}] },
+        ]);
+    });
+});
+describe("MessagesApi overloads + defaults", () => {
+    it("listMessages positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new messages_api_1.MessagesApi(restA);
+        const apiB = new messages_api_1.MessagesApi(restB);
+        await apiA.listMessages("a1", "c1", { limit: 5, order: "desc" });
+        await apiB.listMessages({ agentId: "a1", channelName: "c1" }, { limit: 5, order: "desc" });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+    it("listMessages defaults limit to 10 when omitted", async () => {
+        const rest = makeRestStub();
+        const api = new messages_api_1.MessagesApi(rest);
+        await api.listMessages("a1", "c1");
+        (0, chai_1.expect)(rest.calls).to.have.lengthOf(1);
+        const params = rest.calls[0].args[1];
+        (0, chai_1.expect)(params.limit).to.equal(10);
+        (0, chai_1.expect)(params.before, "before should be set to a snowflake id").to.be.a("string");
+    });
+    it("listMessages with order='asc' reverses the response array", async () => {
+        const rest = makeRestStub();
+        rest.get = ((..._args) => Promise.resolve([
+            { id: "3", data: {}, attachments: [], author_id: "a", channel: { agent_id: "a1", name: "c1" } },
+            { id: "2", data: {}, attachments: [], author_id: "a", channel: { agent_id: "a1", name: "c1" } },
+            { id: "1", data: {}, attachments: [], author_id: "a", channel: { agent_id: "a1", name: "c1" } },
+        ]));
+        const api = new messages_api_1.MessagesApi(rest);
+        const result = await api.listMessages("a1", "c1", { order: "asc", limit: 3 });
+        (0, chai_1.expect)(result.map((m) => m.id)).to.deep.equal(["1", "2", "3"]);
+    });
+    it("listMessages with order='desc' (default) preserves server order", async () => {
+        const rest = makeRestStub();
+        rest.get = ((..._args) => Promise.resolve([
+            { id: "3", data: {}, attachments: [], author_id: "a", channel: { agent_id: "a1", name: "c1" } },
+            { id: "2", data: {}, attachments: [], author_id: "a", channel: { agent_id: "a1", name: "c1" } },
+        ]));
+        const api = new messages_api_1.MessagesApi(rest);
+        const result = await api.listMessages("a1", "c1", { limit: 2 });
+        (0, chai_1.expect)(result.map((m) => m.id)).to.deep.equal(["3", "2"]);
+    });
+    it("getTimeseries strips order before sending to server", async () => {
+        const rest = makeRestStub();
+        const api = new messages_api_1.MessagesApi(rest);
+        await api.getTimeseries("a1", "c1", { limit: 5, order: "asc" });
+        (0, chai_1.expect)(rest.calls).to.have.lengthOf(1);
+        const wireParams = rest.calls[0].args[1];
+        (0, chai_1.expect)(wireParams.order).to.equal(undefined);
+        (0, chai_1.expect)(wireParams.limit).to.equal(5);
+    });
+});
+const aggregates_api_1 = require("../apis/aggregates-api");
+describe("AggregatesApi overloads", () => {
+    it("getAggregate positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new aggregates_api_1.AggregatesApi(restA);
+        const apiB = new aggregates_api_1.AggregatesApi(restB);
+        await apiA.getAggregate("a1", "c1");
+        await apiB.getAggregate({ agentId: "a1", channelName: "c1" });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+    it("patchAggregate identifier form passes through body and params", async () => {
+        const rest = makeRestStub();
+        const api = new aggregates_api_1.AggregatesApi(rest);
+        await api.patchAggregate({ agentId: "a1", channelName: "c1" }, { x: 1 }, { suppress_response: true });
+        (0, chai_1.expect)(rest.calls).to.deep.equal([
+            {
+                method: "patch",
+                args: ["/agents/a1/channels/c1/aggregate", { x: 1 }, { suppress_response: true }],
+            },
+        ]);
+    });
+});
+const alarms_api_1 = require("../apis/alarms-api");
+describe("AlarmsApi overloads", () => {
+    it("listAlarms positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new alarms_api_1.AlarmsApi(restA);
+        const apiB = new alarms_api_1.AlarmsApi(restB);
+        await apiA.listAlarms("a1", "c1");
+        await apiB.listAlarms({ agentId: "a1", channelName: "c1" });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+    it("getAlarm via identifier hits expected path", async () => {
+        const rest = makeRestStub();
+        const api = new alarms_api_1.AlarmsApi(rest);
+        await api.getAlarm({ agentId: "a1", channelName: "c1" }, "alm1");
+        (0, chai_1.expect)(rest.calls).to.deep.equal([
+            { method: "get", args: ["/agents/a1/channels/c1/alarms/alm1"] },
+        ]);
+    });
+});
+const connections_api_1 = require("../apis/connections-api");
+describe("ConnectionsApi overloads", () => {
+    it("getAgentConnections positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new connections_api_1.ConnectionsApi(restA);
+        const apiB = new connections_api_1.ConnectionsApi(restB);
+        await apiA.getAgentConnections("a1");
+        await apiB.getAgentConnections({ agentId: "a1" });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+    it("getChannelSubscriptions identifier form hits expected path", async () => {
+        const rest = makeRestStub();
+        const api = new connections_api_1.ConnectionsApi(rest);
+        await api.getChannelSubscriptions({ agentId: "a1", channelName: "c1" });
+        (0, chai_1.expect)(rest.calls).to.deep.equal([
+            { method: "get", args: ["/agents/a1/channels/c1/subscriptions"] },
+        ]);
+    });
+});
+const notifications_api_1 = require("../apis/notifications-api");
+describe("NotificationsApi overloads", () => {
+    it("getAgentNotifications positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new notifications_api_1.NotificationsApi(restA);
+        const apiB = new notifications_api_1.NotificationsApi(restB);
+        await apiA.getAgentNotifications("a1");
+        await apiB.getAgentNotifications({ agentId: "a1" });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+    it("updateNotificationEndpoint identifier form preserves endpointId and body", async () => {
+        const rest = makeRestStub();
+        const api = new notifications_api_1.NotificationsApi(rest);
+        await api.updateNotificationEndpoint({ agentId: "a1" }, "ep1", { name: "x" });
+        (0, chai_1.expect)(rest.calls).to.deep.equal([
+            {
+                method: "patch",
+                args: ["/agents/a1/notifications/endpoints/ep1", { name: "x" }],
+            },
+        ]);
+    });
+});
+const permissions_api_1 = require("../apis/permissions-api");
+describe("PermissionsApi overloads", () => {
+    it("getAgentPermission positional and identifier-object produce identical requests", async () => {
+        const restA = makeRestStub();
+        const restB = makeRestStub();
+        const apiA = new permissions_api_1.PermissionsApi(restA);
+        const apiB = new permissions_api_1.PermissionsApi(restB);
+        await apiA.getAgentPermission("a1");
+        await apiB.getAgentPermission({ agentId: "a1" });
+        (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
+    });
+});
+const processors_api_1 = require("../apis/processors-api");
+describe("ProcessorsApi overloads", () => {
+    it("createProcessorSchedule identifier form hits expected path", async () => {
+        const rest = makeRestStub();
+        const api = new processors_api_1.ProcessorsApi(rest);
+        await api.createProcessorSchedule({ agentId: "a1" }, "sch1", { foo: "bar" });
+        (0, chai_1.expect)(rest.calls).to.deep.equal([
+            {
+                method: "put",
+                args: ["/agents/a1/processors/schedules/sch1", { foo: "bar" }],
+            },
+        ]);
+    });
+});
+const agents_api_1 = require("../apis/agents-api");
+describe("AgentsApi listAgents", () => {
+    it("calls /agents/ on controlApiUrl with omitSharingHeader", async () => {
+        const rest = makeRestStub();
+        const api = new agents_api_1.AgentsApi(rest, "https://control.example.com");
+        rest.request = ((...args) => {
+            rest.calls.push({ method: "request", args });
+            return Promise.resolve({ agents: [] });
+        });
+        await api.listAgents({ includeArchived: true });
+        (0, chai_1.expect)(rest.calls).to.have.lengthOf(1);
+        (0, chai_1.expect)(rest.calls[0].method).to.equal("request");
+        const req = rest.calls[0].args[0];
+        (0, chai_1.expect)(req.path).to.equal("/agents/");
+        (0, chai_1.expect)(req.baseUrl).to.equal("https://control.example.com");
+        (0, chai_1.expect)(req.omitSharingHeader).to.equal(true);
+        (0, chai_1.expect)(req.query).to.deep.equal({ "include-archived": true });
+    });
+    it("normalises agent entries and merges organisations/users when requested", async () => {
+        const rest = makeRestStub();
+        rest.request = ((..._args) => Promise.resolve({
+            agents: [
+                { id: "a1", name: "Agent One", type: "device" },
+            ],
+            organisations: [{ id: "o1", name: "Org One" }],
+            users: [{ id: "u1", name: "User One" }],
+        }));
+        const api = new agents_api_1.AgentsApi(rest);
+        const result = await api.listAgents({
+            includeOrganisations: true,
+            includeUsers: true,
+            mergeIncludedAsAgents: true,
+        });
+        (0, chai_1.expect)(result.results).to.have.lengthOf(3);
+        (0, chai_1.expect)(result.count).to.equal(3);
+        const ids = (result.results ?? []).map((a) => a.id).sort();
+        (0, chai_1.expect)(ids).to.deep.equal(["a1", "o1", "u1"]);
+        const types = (result.results ?? []).map((a) => a.type).sort();
+        (0, chai_1.expect)(types).to.deep.equal(["device", "organisation", "user"]);
+    });
+});

package/dist/test/gateway-subscriptions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/gateway-subscriptions.test.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const gateway_client_1 = require("../gateway/gateway-client");
+function makeConfig() {
+    return {
+        dataRestUrl: "https://example.com/api",
+        controlApiUrl: "https://example.com/control",
+        dataWssUrl: "wss://example.com/gateway",
+        disableBrowserLifecycleHooks: true,
+    };
+}
+function fakeMessage(channel = { agent_id: "a1", name: "c1" }, id = "m1") {
+    return {
+        id,
+        data: {},
+        attachments: [],
+        author_id: "auth",
+        channel,
+        timestamp: 1,
+    };
+}
+describe("GatewayClient.subscribeToChannel", () => {
+    it("first handler triggers wire-level subscribe", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        let subscribeCalls = 0;
+        gw.subscribe = () => {
+            subscribeCalls += 1;
+        };
+        gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: () => { } });
+        (0, chai_1.expect)(subscribeCalls).to.equal(1);
+    });
+    it("second handler does not trigger another wire-level subscribe", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        let subscribeCalls = 0;
+        gw.subscribe = () => {
+            subscribeCalls += 1;
+        };
+        gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: () => { } });
+        gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: () => { } });
+        (0, chai_1.expect)(subscribeCalls).to.equal(1);
+    });
+    it("returned unsubscribe drops the handler; last drop unsubscribes", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        let unsubCalls = 0;
+        gw.subscribe = () => { };
+        gw.unsubscribe = () => {
+            unsubCalls += 1;
+        };
+        const off1 = gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: () => { } });
+        const off2 = gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: () => { } });
+        off1();
+        (0, chai_1.expect)(unsubCalls).to.equal(0);
+        off2();
+        (0, chai_1.expect)(unsubCalls).to.equal(1);
+    });
+    it("returned unsubscribe is idempotent", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        let unsubCalls = 0;
+        gw.subscribe = () => { };
+        gw.unsubscribe = () => {
+            unsubCalls += 1;
+        };
+        const off = gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: () => { } });
+        off();
+        off();
+        off();
+        (0, chai_1.expect)(unsubCalls).to.equal(1);
+    });
+    it("messageCreate event fans out to onMessage handlers for the matching channel", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        gw.subscribe = () => { };
+        let received;
+        gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: (m) => { received = m; } });
+        gw.emit("messageCreate", fakeMessage());
+        (0, chai_1.expect)(received?.id).to.equal("m1");
+    });
+    it("messageCreate for a different channel does not fire the handler", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        gw.subscribe = () => { };
+        let received = false;
+        gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onMessage: () => { received = true; } });
+        gw.emit("messageCreate", fakeMessage({ agent_id: "a1", name: "c2" }, "m2"));
+        (0, chai_1.expect)(received).to.equal(false);
+    });
+    it("aggregateUpdate fans out to onAggregate handlers", () => {
+        const gw = new gateway_client_1.GatewayClient(makeConfig());
+        gw.subscribe = () => { };
+        let received;
+        gw.subscribeToChannel({ agent_id: "a1", name: "c1" }, { onAggregate: (a) => { received = a; } });
+        const aggregate = { data: { x: 1 }, attachments: [] };
+        gw.emit("aggregateUpdate", { channel: { agent_id: "a1", name: "c1" }, aggregate });
+        (0, chai_1.expect)(received?.data).to.deep.equal({ x: 1 });
+    });
+});

package/dist/test/react.test.js

@@ -336,6 +336,42 @@ function wrapper(client) {
         });
         await (0, react_1.waitFor)(() => (0, chai_1.expect)(result.current.data?.response?.status).to.equal("success"));
     });
+    (0, mocha_1.it)("useInvocationLogs fetches logs for the message", async () => {
+        const messageId = (0, snowflake_1.generateSnowflakeIdAtTime)(new Date("2026-01-01T00:00:00.000Z"));
+        const fetchMock = (0, helpers_1.createFetchMock)(() => (0, helpers_1.createJsonResponse)([
+            { level: "INFO", message: "hello", timestamp: 1 },
+            { level: "ERROR", message: "boom", timestamp: 2 },
+        ]));
+        const client = new doover_client_1.DooverClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+            webSocketImpl: helpers_1.MockWebSocket,
+            disableBrowserLifecycleHooks: true,
+        });
+        const { result } = (0, react_1.renderHook)(() => (0, react_2.useInvocationLogs)({ agentId: "a1", channelName: "dv-proc-inv-1" }, messageId), { wrapper: wrapper(client) });
+        await (0, react_1.waitFor)(() => (0, chai_1.expect)(result.current.isSuccess).to.equal(true));
+        (0, chai_1.expect)(result.current.data?.map((l) => l.level)).to.deep.equal([
+            "INFO",
+            "ERROR",
+        ]);
+        const requestUrl = fetchMock.firstCall?.args[0];
+        (0, chai_1.expect)(requestUrl).to.contain(`/agents/a1/channels/dv-proc-inv-1/messages/${messageId}/logs`);
+    });
+    (0, mocha_1.it)("useInvocationLogs is disabled when messageId is undefined", () => {
+        const fetchMock = (0, helpers_1.createFetchMock)(() => (0, helpers_1.createJsonResponse)([]));
+        const client = new doover_client_1.DooverClient({
+            dataRestUrl: "https://api.example.com",
+            controlApiUrl: "https://control.example.com",
+            dataWssUrl: "wss://ws.example.com",
+            fetchImpl: fetchMock,
+            webSocketImpl: helpers_1.MockWebSocket,
+            disableBrowserLifecycleHooks: true,
+        });
+        (0, react_1.renderHook)(() => (0, react_2.useInvocationLogs)({ agentId: "a1", channelName: "dv-proc-inv-1" }, undefined), { wrapper: wrapper(client) });
+        (0, chai_1.expect)(fetchMock.callCount).to.equal(0);
+    });
     (0, mocha_1.it)("getSharedQueryClient returns the same QueryClient across callers", () => {
         (0, react_2.resetSharedQueryClient)();
         const a = (0, react_2.getSharedQueryClient)();

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

@@ -0,0 +1 @@
+export {};

package/dist/test/rpc-dispatcher.test.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const node_events_1 = require("node:events");
+const rpc_dispatcher_1 = require("../rpc/rpc-dispatcher");
+const errors_1 = require("../rpc/errors");
+const stats_1 = require("../client/stats");
+function makeFakeGateway() {
+    const ee = new node_events_1.EventEmitter();
+    let subscribeCalls = 0;
+    let unsubscribeCalls = 0;
+    const channels = new Map();
+    const key = (c) => `${c.agent_id}/${c.name}`;
+    const subscribeToChannel = (channel, handlers) => {
+        const k = key(channel);
+        let set = channels.get(k);
+        if (!set) {
+            set = new Set();
+            channels.set(k, set);
+            subscribeCalls += 1;
+        }
+        set.add(handlers);
+        ee.on("messageUpdate", (msg, requestData) => {
+            if (msg.channel.agent_id !== channel.agent_id || msg.channel.name !== channel.name)
+                return;
+            handlers.onMessageUpdate?.(msg, requestData);
+        });
+        let off = false;
+        return () => {
+            if (off)
+                return;
+            off = true;
+            set.delete(handlers);
+            if (set.size === 0) {
+                channels.delete(k);
+                unsubscribeCalls += 1;
+            }
+        };
+    };
+    return {
+        subscribeToChannel: subscribeToChannel,
+        emitMessageUpdate: (msg, rd) => ee.emit("messageUpdate", msg, rd),
+        get subscribeCalls() { return subscribeCalls; },
+        get unsubscribeCalls() { return unsubscribeCalls; },
+    };
+}
+function makeFakeMessagesApi() {
+    let nextId = "msg-1";
+    const posts = [];
+    const postMessage = (async (a, b, c) => {
+        const isPositional = typeof a === "string";
+        const agentId = isPositional ? a : a.agentId;
+        const channelName = isPositional ? b : a.channelName;
+        const body = isPositional ? c : b;
+        posts.push({ agentId, channelName, body });
+        const message = {
+            id: nextId,
+            data: body,
+            attachments: [],
+            author_id: "auth",
+            channel: { agent_id: agentId, name: channelName },
+            timestamp: 1,
+        };
+        return message;
+    });
+    return {
+        postMessage,
+        posts,
+        setNextId: (id) => { nextId = id; },
+    };
+}
+function rpcMessage(id, channel, status, request, response) {
+    return {
+        id,
+        data: { method: "do", request, status, response: response },
+        attachments: [],
+        author_id: "auth",
+        channel,
+        timestamp: 1,
+    };
+}
+describe("RpcDispatcher", () => {
+    it("send resolves on terminal success status", async () => {
+        const gw = makeFakeGateway();
+        const messages = makeFakeMessagesApi();
+        messages.setNextId("rpc-1");
+        const dispatcher = new rpc_dispatcher_1.RpcDispatcher(gw, messages);
+        const channel = { agent_id: "a1", name: "c1" };
+        const promise = dispatcher.send({ agentId: "a1", channelName: "c1" }, { method: "do", request: { x: 1 } });
+        // wait one microtask so postMessage settles and pending is registered
+        await new Promise((r) => setImmediate(r));
+        gw.emitMessageUpdate(rpcMessage("rpc-1", channel, { code: "success" }, { x: 1 }, { ok: true }));
+        const result = await promise;
+        (0, chai_1.expect)(result).to.deep.equal({ ok: true });
+        (0, chai_1.expect)(gw.subscribeCalls).to.equal(1);
+        (0, chai_1.expect)(gw.unsubscribeCalls).to.equal(1);
+    });
+});
+describe("RpcDispatcher additional outcomes", () => {
+    it("rejects with DooverRpcError on terminal error status", async () => {
+        const gw = makeFakeGateway();
+        const messages = makeFakeMessagesApi();
+        messages.setNextId("rpc-2");
+        const dispatcher = new rpc_dispatcher_1.RpcDispatcher(gw, messages);
+        const channel = { agent_id: "a1", name: "c1" };
+        const promise = dispatcher.send({ agentId: "a1", channelName: "c1" }, { method: "do", request: {} });
+        await new Promise((r) => setImmediate(r));
+        gw.emitMessageUpdate(rpcMessage("rpc-2", channel, { code: "error", message: "nope" }, {}));
+        let caught;
+        try {
+            await promise;
+        }
+        catch (e) {
+            caught = e;
+        }
+        (0, chai_1.expect)(caught).to.be.instanceOf(errors_1.DooverRpcError);
+        (0, chai_1.expect)(caught.message).to.equal("nope");
+    });
+    it("rejects on timeoutMs with no terminal status", async () => {
+        const gw = makeFakeGateway();
+        const messages = makeFakeMessagesApi();
+        const dispatcher = new rpc_dispatcher_1.RpcDispatcher(gw, messages);
+        const promise = dispatcher.send({ agentId: "a1", channelName: "c1" }, { method: "do", request: {} }, { timeoutMs: 5 });
+        let caught;
+        try {
+            await promise;
+        }
+        catch (e) {
+            caught = e;
+        }
+        (0, chai_1.expect)(caught?.message).to.equal("RPC timed out");
+    });
+    it("rejects on AbortSignal.abort()", async () => {
+        const gw = makeFakeGateway();
+        const messages = makeFakeMessagesApi();
+        const dispatcher = new rpc_dispatcher_1.RpcDispatcher(gw, messages);
+        const ac = new AbortController();
+        const promise = dispatcher.send({ agentId: "a1", channelName: "c1" }, { method: "do", request: {} }, { signal: ac.signal });
+        await new Promise((r) => setImmediate(r));
+        ac.abort(new Error("user cancelled"));
+        let caught;
+        try {
+            await promise;
+        }
+        catch (e) {
+            caught = e;
+        }
+        (0, chai_1.expect)(caught?.message).to.equal("user cancelled");
+    });
+    it("two concurrent RPCs on the same channel share one gateway subscription", async () => {
+        const gw = makeFakeGateway();
+        const messages = makeFakeMessagesApi();
+        const dispatcher = new rpc_dispatcher_1.RpcDispatcher(gw, messages);
+        messages.setNextId("rpc-A");
+        const pA = dispatcher.send({ agentId: "a1", channelName: "c1" }, { method: "do", request: { n: 1 } });
+        await new Promise((r) => setImmediate(r));
+        messages.setNextId("rpc-B");
+        const pB = dispatcher.send({ agentId: "a1", channelName: "c1" }, { method: "do", request: { n: 2 } });
+        await new Promise((r) => setImmediate(r));
+        (0, chai_1.expect)(gw.subscribeCalls).to.equal(1);
+        const channel = { agent_id: "a1", name: "c1" };
+        gw.emitMessageUpdate(rpcMessage("rpc-A", channel, { code: "success" }, { n: 1 }, { a: true }));
+        gw.emitMessageUpdate(rpcMessage("rpc-B", channel, { code: "success" }, { n: 2 }, { b: true }));
+        (0, chai_1.expect)(await pA).to.deep.equal({ a: true });
+        (0, chai_1.expect)(await pB).to.deep.equal({ b: true });
+        (0, chai_1.expect)(gw.unsubscribeCalls).to.equal(1);
+    });
+});
+describe("RpcDispatcher stats integration", () => {
+    it("records start and end via collector when enabled", async () => {
+        const gw = makeFakeGateway();
+        const messages = makeFakeMessagesApi();
+        const dispatcher = new rpc_dispatcher_1.RpcDispatcher(gw, messages);
+        const stats = new stats_1.DooverStatsCollector();
+        stats.setEnabled(true);
+        dispatcher.setStats(stats);
+        messages.setNextId("rpc-stats");
+        const channel = { agent_id: "a1", name: "c1" };
+        const p = dispatcher.send({ agentId: "a1", channelName: "c1" }, { method: "do", request: {} });
+        await new Promise((r) => setImmediate(r));
+        (0, chai_1.expect)(stats.snapshot().rpc.pendingRpcs).to.equal(1);
+        gw.emitMessageUpdate(rpcMessage("rpc-stats", channel, { code: "success" }, {}, { ok: true }));
+        await p;
+        const snap = stats.snapshot();
+        (0, chai_1.expect)(snap.rpc.totalRpcs).to.equal(1);
+        (0, chai_1.expect)(snap.rpc.completedRpcs).to.equal(1);
+        (0, chai_1.expect)(snap.rpc.pendingRpcs).to.equal(0);
+        (0, chai_1.expect)(snap.rpc.peakPendingRpcs).to.equal(1);
+    });
+});

package/dist/test/stats-rpc.test.d.ts

@@ -0,0 +1 @@
+export {};