doover-js 0.6.1 → 0.6.3

package/dist/apis/agents-api.d.ts

@@ -32,6 +32,14 @@ export declare class AgentsApi {
     private readonly controlApiUrl?;
     constructor(rest: RestClient, controlApiUrl?: string | undefined);
     listAgents(options?: GetAgentsOptions): Promise<AgentsResponse>;
+    /**
+     * Batch-fetch recent messages for many agents. Auto-chunks `agent_id`
+     * (and the parallel `agent_before` cursors, if given) at MULTI_AGENT_CHUNK_SIZE
+     * so each request's URL stays under CloudFront's 8,192-byte quota. Chunks
+     * are fetched in parallel and merged: `results`/`count` concat-and-sum,
+     * `next_cursors`/`at_limit_agent_ids` union, legacy `next` becomes the
+     * lexically-highest cursor across at-limit agents.
+     */
     getMultiAgentMessages(channelName: string, params: MultiAgentMessagesParams): Promise<BatchMessagesResponse>;
     /**
      * Batch-fetch aggregates for many agents. Auto-chunks `agent_id` so each

package/dist/apis/agents-api.js

@@ -144,12 +144,65 @@ class AgentsApi {
         }
         return { ...raw, agents: merged, results: merged, count: merged.length };
     }
+    /**
+     * Batch-fetch recent messages for many agents. Auto-chunks `agent_id`
+     * (and the parallel `agent_before` cursors, if given) at MULTI_AGENT_CHUNK_SIZE
+     * so each request's URL stays under CloudFront's 8,192-byte quota. Chunks
+     * are fetched in parallel and merged: `results`/`count` concat-and-sum,
+     * `next_cursors`/`at_limit_agent_ids` union, legacy `next` becomes the
+     * lexically-highest cursor across at-limit agents.
+     */
     async getMultiAgentMessages(channelName, params) {
-        const response = await this.rest.get(`/agents/channels/${channelName}/messages`, params);
-        return {
+        const path = `/agents/channels/${channelName}/messages`;
+        const { agent_id, agent_before, ...rest } = params;
+        const stampTimestamps = (response) => ({
             ...response,
             results: response.results.map((message) => "timestamp" in message ? message : (0, snowflake_1.addTimestampToMessage)(message)),
+        });
+        if (agent_id.length <= MULTI_AGENT_CHUNK_SIZE) {
+            const response = await this.rest.get(path, params);
+            return stampTimestamps(response);
+        }
+        if (agent_before && agent_before.length !== agent_id.length) {
+            throw new Error("agent_before must be the same length as agent_id when set");
+        }
+        const chunks = [];
+        for (let i = 0; i < agent_id.length; i += MULTI_AGENT_CHUNK_SIZE) {
+            chunks.push({
+                agent_id: agent_id.slice(i, i + MULTI_AGENT_CHUNK_SIZE),
+                ...(agent_before
+                    ? { agent_before: agent_before.slice(i, i + MULTI_AGENT_CHUNK_SIZE) }
+                    : {}),
+            });
+        }
+        const responses = await Promise.all(chunks.map((chunk) => this.rest
+            .get(path, { ...rest, ...chunk })
+            .then(stampTimestamps)));
+        // Merge: results/count concat-and-sum; next_cursors merge; at_limit_agent_ids
+        // concat (both keyed by agent id, unique across chunks). Legacy `next` is the
+        // lexically-highest oldest-cursor across at-limit agents — snowflakes sort
+        // lexically since they're equal-width digit strings.
+        const merged = {
+            results: responses.flatMap((r) => r.results),
+            count: responses.reduce((acc, r) => acc + r.count, 0),
         };
+        const nexts = responses
+            .map((r) => r.next)
+            .filter((n) => typeof n === "string" && n.length > 0);
+        if (nexts.length > 0) {
+            merged.next = nexts.reduce((a, b) => (a > b ? a : b));
+        }
+        const cursors = {};
+        for (const r of responses) {
+            if (r.next_cursors)
+                Object.assign(cursors, r.next_cursors);
+        }
+        if (Object.keys(cursors).length > 0)
+            merged.next_cursors = cursors;
+        const atLimit = responses.flatMap((r) => r.at_limit_agent_ids ?? []);
+        if (atLimit.length > 0)
+            merged.at_limit_agent_ids = atLimit;
+        return merged;
     }
     /**
      * Batch-fetch aggregates for many agents. Auto-chunks `agent_id` so each

package/dist/react/useMultiAgentChannelMessages.d.ts

@@ -5,7 +5,19 @@ export declare function multiAgentChannelMessagesQueryKey(channelName: string, a
     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 {
+    /**
+     * Global cap on the total number of messages returned across all agents
+     * for a single request. The server distributes this budget across agents
+     * in newest-first order, so a noisy agent can starve quieter ones.
+     * Prefer `agentMessageLimit` when you want a fair per-agent slice.
+     */
     limit?: number;
+    /**
+     * Per-agent cap on messages returned. Forwarded as `agent_message_limit`.
+     * Use this when fanning out across many agents that have wildly different
+     * message rates and you want each agent's window represented.
+     */
+    agentMessageLimit?: number;
     /** If false, skip live subscriptions per agent. Defaults true. */
     liveUpdates?: boolean;
     /**

package/dist/react/useMultiAgentChannelMessages.js

@@ -34,6 +34,7 @@ function useMultiAgentChannelMessages(channelName, agentIds, options) {
     const client = (0, context_1.useDooverClient)();
     const queryClient = (0, react_query_1.useQueryClient)();
     const limit = options?.limit;
+    const agentMessageLimit = options?.agentMessageLimit;
     const liveUpdates = options?.liveUpdates ?? true;
     const fields = options?.fields;
     const initialBefore = options?.initialBefore;
@@ -59,8 +60,12 @@ function useMultiAgentChannelMessages(channelName, agentIds, options) {
             };
         });
     }, 
+    // `key` captures every scope dim (agentIds + sources + after + fields);
+    // serialise the whole thing so the closure refreshes when any dim
+    // changes — listing dims by hand drops live updates whenever the list
+    // grows (we used to omit `after`/`fields`).
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [queryClient, channelName, agentIds.join(","), sources?.join(",")]);
+    [queryClient, JSON.stringify(key)]);
     (0, react_1.useEffect)(() => {
         if (!liveUpdates || agentIds.length === 0)
             return;
@@ -88,6 +93,9 @@ function useMultiAgentChannelMessages(channelName, agentIds, options) {
                 agent_id: agentIds,
                 ...(typeof pageParam === "string" ? { before: pageParam } : {}),
                 ...(limit !== undefined ? { limit } : {}),
+                ...(agentMessageLimit !== undefined
+                    ? { agent_message_limit: agentMessageLimit }
+                    : {}),
                 ...(fields && fields.length > 0 ? { field_name: fields } : {}),
                 ...(after !== undefined ? { after } : {}),
             };

package/dist/rpc/rpc-dispatcher.js

@@ -31,8 +31,10 @@ class RpcDispatcher {
             const startedAt = this.stats?.recordRpcStart() ?? null;
             this.messages
                 .postMessage(channel.agentId, channel.channelName, {
-                type: "rpc",
-                ...request,
+                data: {
+                    type: "rpc",
+                    ...request,
+                },
             })
                 .then((message) => {
                 const pending = {

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

@@ -77,8 +77,9 @@ describe("MessagesApi overloads + defaults", () => {
         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" });
+        const before = "185536526405337088";
+        await apiA.listMessages("a1", "c1", { limit: 5, order: "desc", before });
+        await apiB.listMessages({ agentId: "a1", channelName: "c1" }, { limit: 5, order: "desc", before });
         (0, chai_1.expect)(restA.calls).to.deep.equal(restB.calls);
     });
     it("listMessages defaults limit to 10 when omitted", async () => {

package/dist/test/apis.test.js

@@ -82,6 +82,82 @@ function setupRest(responseFactory) {
         const returnedIds = aggregates.results.map((r) => r.agent_id).sort();
         (0, chai_1.expect)(returnedIds).to.deep.equal([...agentIds].sort());
     });
+    (0, mocha_1.it)("chunks getMultiAgentMessages over the per-request agent cap", async () => {
+        const baseTs = new Date("2026-01-01T00:00:00Z");
+        const { rest, fetchMock } = setupRest((url) => {
+            const ids = [...new URL(url).searchParams.getAll("agent_id")];
+            return (0, helpers_1.createJsonResponse)({
+                results: ids.map((id, i) => ({
+                    id: (0, snowflake_1.generateSnowflakeIdAtTime)(new Date(baseTs.getTime() + i)),
+                    author_id: "u",
+                    channel: { agent_id: id, name: "c1" },
+                    data: {},
+                    attachments: [],
+                })),
+                count: ids.length,
+            });
+        });
+        const api = new agents_api_1.AgentsApi(rest);
+        // 600 agents → 3 chunks of 250/250/100.
+        const agentIds = Array.from({ length: 600 }, (_, i) => `a${i}`);
+        const messages = await api.getMultiAgentMessages("c1", {
+            agent_id: agentIds,
+            agent_message_limit: 50,
+        });
+        (0, chai_1.expect)(fetchMock.callCount).to.equal(3);
+        (0, chai_1.expect)(messages.results).to.have.length(600);
+        (0, chai_1.expect)(messages.count).to.equal(600);
+        const returnedIds = messages.results
+            .map((m) => m.channel.agent_id)
+            .sort();
+        (0, chai_1.expect)(returnedIds).to.deep.equal([...agentIds].sort());
+        // Per-request param survives chunking.
+        for (let i = 0; i < 3; i++) {
+            const url = fetchMock.getCall(i).args[0];
+            (0, chai_1.expect)(url).to.include("agent_message_limit=50");
+        }
+    });
+    (0, mocha_1.it)("merges next_cursors and at_limit_agent_ids across chunks", async () => {
+        let call = 0;
+        const cursors = [
+            { "a0": "100", "a1": "200" },
+            { "a250": "150" },
+        ];
+        const atLimit = [["a0", "a1"], ["a250"]];
+        const { rest } = setupRest((url) => {
+            const idx = call++;
+            const ids = [...new URL(url).searchParams.getAll("agent_id")];
+            return (0, helpers_1.createJsonResponse)({
+                results: ids.map((id) => ({
+                    id: (0, snowflake_1.generateSnowflakeIdAtTime)(new Date("2026-01-01T00:00:00Z")),
+                    author_id: "u",
+                    channel: { agent_id: id, name: "c1" },
+                    data: {},
+                    attachments: [],
+                })),
+                count: ids.length,
+                next: idx === 0 ? "200" : "150",
+                next_cursors: cursors[idx],
+                at_limit_agent_ids: atLimit[idx],
+            });
+        });
+        const api = new agents_api_1.AgentsApi(rest);
+        const agentIds = Array.from({ length: 300 }, (_, i) => `a${i}`);
+        const messages = await api.getMultiAgentMessages("c1", {
+            agent_id: agentIds,
+        });
+        (0, chai_1.expect)(messages.next).to.equal("200"); // max across chunks
+        (0, chai_1.expect)(messages.next_cursors).to.deep.equal({
+            a0: "100",
+            a1: "200",
+            a250: "150",
+        });
+        (0, chai_1.expect)(messages.at_limit_agent_ids?.sort()).to.deep.equal([
+            "a0",
+            "a1",
+            "a250",
+        ]);
+    });
     (0, mocha_1.it)("covers channels methods", async () => {
         const { rest, fetchMock } = setupRest(() => (0, helpers_1.createJsonResponse)([]));
         const api = new channels_api_1.ChannelsApi(rest);

package/dist/types/audit.d.ts

@@ -27,7 +27,7 @@ export interface AuditRequestContext {
     user_agent?: string;
 }
 /** Origin system for the event. */
-export type AuditSource = "control" | "fusionauth" | "data" | "tunnels";
+export type AuditSource = "control" | "auth" | "data" | "tunnels";
 /**
  * String-literal union of every wired audit action — kept in lock-step with
  * ``doover_control/events/types.py``'s ``EventType`` enum. Future event types

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doover-js",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "TypeScript client for Doover.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",